How Run The Machine Works

The same installer from Ship Your Product, extended with a third phase. It asks if this is a personal machine or an agent machine. For agent mode, the installer does several additional things.

It enables bypass permissions so Claude can execute commands without asking for confirmation on every action. This is what makes autonomous operation possible — the agent can build, test, commit, and create PRs without waiting for you to click "approve" on each step.

It installs 5 agent templates: fullstack-dev (writes code across the full stack), designer (visual design specs, read-only), content (marketing copy, docs, SEO content), quality (testing, code review, security audit), and research (codebase exploration, market research, read-only). Each template defines what the agent can do, what model it uses, and what files it can access.

It configures Telegram bot notifications so you get real-time alerts when tasks complete, sessions crash, or overnight processing finishes. And it installs management daemons — background services that monitor sessions, sync configuration, and deliver output. One script, fully configured.

Your projects are defined in projects.yaml — a single file that tells the system everything it needs to know about each project you're managing. Each entry includes: the project name, local file path, GitHub repository URL, and a priority level (high, medium, or low).

Priority affects how overnight issue processing allocates time across your projects. High-priority projects get processed first and receive more agent time. Low-priority projects get handled after high-priority work is done. This means your most important project always gets attention, even when you have ten projects configured.

The system manages Claude Code sessions for each project via tmux — persistent, recoverable terminal sessions that survive network disconnects, SSH timeouts, and even machine restarts. If a session crashes, the watchdog daemon detects it within 5 minutes and restarts it automatically. You don't manage tmux directly — the system handles session creation, naming, recovery, and cleanup.

When you need to build something significant — a new feature, a major refactor, a new product — you run /ax-plan instead of jumping straight into code. This skill runs two AIs independently on the same problem to catch blind spots neither would find alone.

First, Claude enters plan mode. It explores your codebase, reads your existing architecture, understands the data model, and designs a detailed implementation plan. This includes: which files to create or modify, what the data flow looks like, where the tricky parts are, and what order to build things in. You review this plan and approve, edit, or redirect it.

Then Codex (OpenAI's code-focused model) independently analyzes the same codebase and requirements. Codex produces its own plan without seeing Claude's. It might propose a different data model, flag a performance concern Claude missed, or suggest a simpler approach to a component Claude over-engineered.

The system synthesizes both plans into a unified spec. Where they agree, you have high confidence. Where they disagree, you have a decision point that deserves your attention. This dual-AI approach catches architectural issues before you write code — saving hours or days of rework that would happen if you discovered the problem mid-implementation.

With a unified plan approved, /ax-feature breaks the work into 2–5 independent workstreams. Each stream runs in its own git worktree — an isolated copy of your repository with its own branch, its own working directory, and its own Claude Code session.

Dedicated subagents work on each stream simultaneously. The fullstack-dev agent handles implementation. The quality agent writes tests. The content agent handles copy and documentation. They don't step on each other because each worktree is completely isolated — no branch collisions, no merge conflicts during development, no context bleed between streams.

When all streams complete, changes are integrated and verified. The system merges the branches, runs the full test suite, and flags any integration issues. What would take one developer a week of sequential work gets done in parallel — multiple features shipping simultaneously instead of one at a time.

This is the most thorough review pipeline available to a solo developer. Three AI systems review your code from different perspectives before you approve a merge.

Step 1: Claude self-review. Claude reviews its own work, looking for issues it might have introduced. Then it runs /simplify — a dedicated pass that reduces complexity, removes unnecessary abstractions, and tightens the code. The goal is to make the PR as small and clean as possible before external review.

Step 2: Codex peer review. Codex gets up to 3 rounds of peer review. It's a dialogue — Codex raises concerns, you accept them or push back with reasoning, and Codex reviews again with your feedback incorporated. This back-and-forth catches subtle issues that a single-pass review would miss.

Step 3: GitHub Copilot review. A pull request is created on GitHub, and Copilot reviews it automatically. Copilot often pushes its own fix commits — small improvements, typo corrections, edge case handling. The PR includes a detailed summary of all review rounds so you can see what was flagged and how it was addressed.

Three AI perspectives, each with different training data, different strengths, and different blind spots. By the time you review the PR, the obvious issues are already resolved. Your review focuses on business logic and product decisions — not syntax, security basics, or missing error handling.

The overnight daemon (/ax-overnight) is where the system truly becomes autonomous. You go to sleep, and it goes to work.

It reads open GitHub Issues across all your configured projects. It prioritizes them based on your projects.yaml priority settings and any labels you've applied. For each issue, it: plans the solution (using the dual-AI planning workflow), builds the feature or fix (in an isolated worktree), runs the full review pipeline (self-review, simplify, Codex rounds, Copilot), runs tests, and creates a pull request with a detailed description of what was done and why.

In the morning, you open GitHub and find completed PRs waiting for your review. Each one has been through the same quality pipeline as if you'd built it yourself during the day. You review the changes, merge what looks good, and leave comments on anything that needs adjustment. The system picks up your comments in the next cycle and addresses them.

Priority-based scheduling ensures high-priority projects get processed first. If you have three projects and limited overnight hours, the system focuses on what matters most. Low-priority maintenance tasks get handled after your core product work is done.

Five launchd daemons run in the background, keeping the entire system healthy and responsive. You don't interact with them directly — they just work.

Session Watchdog (every 5 minutes): Monitors all active Claude Code sessions. If a session crashes, hangs, or becomes unresponsive, the watchdog restarts it automatically and sends a Telegram alert so you know what happened. No manual babysitting required.

Config Sync (every 10 minutes): Pulls the latest skill and stack module updates from git. When new patterns are added or constraints are updated, your agents get them automatically without manual intervention.

Health Report (daily): A summary of system health — which sessions are running, how many tasks were completed, any errors or warnings that need attention. Delivered to Telegram so you see it first thing in the morning.

Schedule Sync (daily): Reconciles your cowork schedules and task queues, ensuring overnight processing happens at the right times and doesn't conflict with your active work sessions.

Output Watcher (every 5 minutes): Monitors output directories and delivers completed files — generated content, design specs, research reports — via notification so you can review them immediately. Use /ax-monitor from within Claude Code to check the status of everything at any time.

Five specialized agents, each with defined capabilities and access levels. They're spawned automatically by orchestration skills like /ax-feature and /ax-deliver, but you can also invoke them manually for specific tasks.

fullstack-dev — The primary implementation agent. Writes code across the full stack: frontend components, API routes, database queries, integrations. Uses the Opus model for maximum capability. Has write access to the codebase and can commit, push, and create PRs. This is the workhorse that builds your features.

designer — Produces visual design specs, UX improvement recommendations, component layouts, and color system suggestions. Read-only — it doesn't write code. It outputs specifications that the fullstack-dev agent implements. Useful when you need design direction before building.

content — Writes marketing copy, product descriptions, documentation, blog posts, SEO content, email sequences, and landing page text. Has write access to content files but not application code. The content it produces is ready to ship, not placeholder text.

quality — Handles testing, code review, and security auditing. Writes test files, reviews PRs, runs security scans, and reports findings. Can push fix commits for issues it finds. This is the agent that catches problems before they reach production.

research — Explores codebases, researches libraries, analyzes competitor implementations, and produces research reports. Read-only — it doesn't modify anything. Use it when you need to understand an unfamiliar codebase, evaluate a library, or gather information before making a technical decision.