What We Built

PAI (Personal AI Infrastructure) is a general-purpose AI system built on top of Claude Code. It transforms the base Claude Code CLI into a structured, capable agent system — adding a multi-phase execution engine, 49 skills, lifecycle hooks, persistent memory, and a live 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:

  • The Algorithm — a 7-phase execution engine (Observe → Think → Plan → Build → Execute → Verify → Learn) that governs every complex task
  • 49 skills across 12 categories — from web research to code generation to ServiceNow operations
  • 21+ 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 We 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

PAI's 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: PAI Installation

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

  • CLAUDE.md — system prompt loaded on every session
  • PAI/Algorithm/ — the versioned execution engine
  • PAI/skills/ — 49 skill definitions across research, coding, writing, platform integrations
  • PAI/hooks/ — lifecycle hook scripts wired into Claude Code's settings
  • PAI/memory/ — 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 PAI, it becomes something different: a structured agent system that can plan, execute, verify, and remember across long-running projects.

  • The Algorithm prevents shallow responses — complex tasks go through all seven 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 (user, feedback, project, reference) with explicit descriptions are far more useful than unstructured notes