What I Built

The setup is an orchestration tool I'm building on top of Claude Code. It turns the base Claude Code CLI into a structured agent system — adding a staged execution loop, an on-demand skill library, lifecycle hooks, persistent memory, and a voice interface.

It runs on Bazzite Linux (a Fedora Silverblue-based gaming distro that also makes an excellent AI workstation) with Bun as the runtime and Obsidian as the project vault.

The system includes:

  • A staged execution loop — complex tasks run through structured phases instead of one-shot prompting
  • A skill library — specialized capabilities on demand, from web research to code generation to ServiceNow operations
  • Lifecycle hooks — security checks, voice notifications, memory persistence, session management
  • Persistent memory — conversations accumulate context across sessions via a structured memory system
  • Voice interface — ElevenLabs TTS through a local voice server, so the agent speaks responses aloud

How I Built It

Step 1: Base Platform — Bazzite Linux

Bazzite is an immutable Linux distro built on Fedora Silverblue. The immutable base means system packages are locked and rollback-safe, while layered packages and Flatpaks handle everything else. For an AI workstation it's ideal — stable base, modern kernel, excellent hardware support.

Claude Code installs globally via npm on top of the system Node:


npm install -g @anthropic-ai/claude-code

Step 2: Bun Runtime

The skill execution layer uses Bun for speed. Install via the official installer:


curl -fsSL https://bun.sh/install | bash

Bun handles TypeScript natively with no compilation step, making it the right choice for fast skill invocation.

Step 3: Tool Installation

The tool lives in ~/.claude/ — Claude Code's config directory. The structure includes:

  • CLAUDE.md — system prompt loaded on every session
  • an engine folder — the versioned execution loop
  • a skills folder — skill definitions across research, coding, writing, and platform integrations
  • a hooks folder — lifecycle hook scripts wired into Claude Code's settings
  • a memory folder — persistent cross-session memory store

Step 4: Voice Server

The ElevenLabs voice interface runs as a local HTTP server on port 8888. Skills and hooks POST to it when they want spoken output:


curl -s -X POST http://localhost:8888/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Task complete", "voice_id": "pFZP5JQG7iQjIQuC4Bku", "voice_enabled": true}'

The server queues requests and handles synthesis in the background, so the agent doesn't block waiting for audio.

Step 5: Obsidian Vault as Project Hub

All project documentation, tasks, logs, and decisions live in an Obsidian vault called Skynet at ~/Documents/projects/skynet. Claude Code reads and writes markdown files in this vault directly, creating a bidirectional link between the AI agent and the knowledge base.

Each project gets its own directory with:

  • Overview.md — project description, stack, goals, status
  • Tasks.md — active and completed tasks
  • Log.md — running journal of decisions and discoveries

Why It Matters

Out of the box, Claude Code is a capable coding assistant. With this setup, it becomes something different: a structured agent system that can plan, execute, verify, and remember across long-running projects.

  • The staged loop prevents shallow responses — complex tasks go through structured phases before declaring done
  • Skills give the agent specialized capabilities on demand — web research, ServiceNow ops, deployment, and more
  • Hooks make the system reactive — security checks before destructive operations, voice notifications on completion, memory saves at session end
  • Memory means you don't re-explain context every conversation — the agent accumulates knowledge about your projects, preferences, and past decisions
  • Voice turns a text interface into something you can hear — useful when you're heads-down in other work and want the agent to narrate what it's doing

The combination makes the agent genuinely useful for long-running, multi-project work — not just one-shot code questions.

Lessons Learned

1. Immutable base + layered tools is the right model — Bazzite's approach means the AI environment doesn't break when the system updates

2. Bun over Node for skill execution — significantly faster cold starts for short-lived skill invocations

3. Obsidian as the knowledge layer — plain markdown files that both humans and AI can read and write is the right abstraction

4. Voice feedback changes how you work — hearing "task complete" while looking at something else is a different workflow than polling a terminal

5. Memory structure matters — typed memories with explicit descriptions are far more useful than unstructured notes