Why AcePilot Exists

I built AcePilot because Claude Code kept making the same mistakes across sessions. It forgot architectural decisions. It skipped security reviews. It had no idea what it shipped yesterday. The fix wasn't a better prompt — it was a persistent execution system.

The problem nobody talks about

AI coding assistants are impressive in a single session. Give Claude Code a clear task, and it performs. But start a new session tomorrow, and everything resets. The context is gone. The decisions are lost. The patterns it learned vanish.

I noticed this after version 30-something of what would become AcePilot. I was using Claude Code to build Claude Code tooling — deeply recursive, I know. And every session, I'd watch the same failure modes:

• Amnesia. It didn't remember that we decided to use flat files instead of a database. So it kept proposing database solutions.
• No self-review. It would ship code with inline onclick handlers (XSS risk) because there was no security specialist checking the diff.
• Scope creep. Ask it to fix a typo, and it refactors the entire module. No sense of proportional response.
• Repeated mistakes. Same error three sessions in a row. No error memory, no pattern recognition, no learning.

These aren't bugs in Claude Code. Claude Code is excellent at what it does. These are gaps in the execution layer — the difference between a smart assistant and an autonomous teammate.

What a teammate actually does

Think about what makes a great engineering teammate. They don't just write code. They:

• Remember every decision the team has made
• Review their own work before submitting it
• Know when to ask and when to just handle it
• Get faster at recurring tasks over time
• Pick up where they left off the next morning
• Scale their ceremony to the size of the task

None of these require being smarter. They require persistent state and structured execution. That's what AcePilot adds.

The solution: 14 state files and 6 specialists

AcePilot is 12 config files that install into Claude Code's native config structure. No fork, no wrapper, no separate tool. It adds a /acepilot command that transforms Claude Code's behavior for that session.

Persistent state that survives sessions

14 state files in .claude/state/. TASKS.md tracks work. DECISIONS.md is append-only — every autonomous decision logged permanently. KNOWLEDGE.md accumulates product understanding with freshness markers. ANALYTICS.md feeds back into the engine so gates and routing get smarter over time. PLAYBOOKS.md captures proven workflows for replay.

6 specialist agents that review every diff

After implementation, before commit, specialist agents review the diff from their domain lens:

• @designer — UX heuristics from Nielsen's 249 usability problems, mobile-first from Wroblewski, accessibility Big 6
• @security — Schneier's attacker mindset, OWASP Top 3 (40%+ of vulnerabilities), secrets detection
• @architect — Gregg's USE method for performance, N+1 detection, coupling analysis from Fowler
• @strategist — conversion optimization, analytics instrumentation, growth patterns from Ellis & Rachitsky
• @reviewer — independent code review with four-status qualify (done, concerns, needs context, blocked)
• @researcher — codebase scanning, task prioritization, knowledge seeding, strategy research

Smart dispatch routes specialists by diff content. CSS changes get @designer. Auth changes get @security. Not every specialist on every task — that would be noise. The routing itself calibrates from historical precision data.

A confidence gate that thinks in doors

Inspired by Bezos's Type 1 / Type 2 decision framework. Reversible changes (two-way doors) execute immediately. Irreversible changes (one-way doors) get careful deliberation. Most changes are two-way doors treated as one-way doors — that kills speed.

What this looks like in practice

Here's a real session. One command:

AcePilot classified the archetype (static site), decided the revenue model (freemium, 3-tier pricing), generated the identity (dark theme, developer aesthetic), expanded into 8 tasks, executed all of them, ran specialist reviews that caught 2 XSS risks and 3 conversion improvements, auto-fixed everything, and committed a buildable checkpoint.

Total time: one session. Total questions asked: zero. Total files created: 9 pages with SEO, analytics, social proof, comparison pages, a badge system, and share mechanics.

That's the landing page you're reading this on.

Why now?

Claude Code reached the threshold where autonomous execution is practical. The base model is smart enough. What's missing is the scaffolding — the state management, the review pipeline, the confidence calibration, the session continuity.

No other tool in this space does this. Cursor is a great IDE but doesn't learn across sessions. Bolt and v0 generate code but don't review it. GitHub Copilot suggests completions but doesn't execute autonomously. AcePilot fills the gap between "AI that writes code" and "AI that ships products."

Try it

30 seconds to install. Free tier includes plan + go modes — full state system, two execution modes, no time limit. Pro unlocks auto, ship, and god modes.