I'm a non-technical guy who spent 2 months trying to ship software with AI tools. Not toy projects — real things I wanted to use. Finance analyzers, productivity tools, dev utilities.

The models are incredible. But the loop was broken.

Every session started from zero. Context would explode. The AI would hallucinate with confidence. And because I can't read code, I had no way to verify when something was wrong. I just knew it was broken. So I stopped fighting the model and started building the system around it.

Pilot is a /pilot folder you drop into any repo. It's emergent complexity from simple primitives — markdown files that give AI tools:

Persistent state (STATE.md tracks where you are in the workflow) Scoped tasks (TASK.md defines boundaries before implementation) Evidence capture (real terminal output via MCP, not generated text) Protected paths (red zones require human approval) Recovery (LKG commit auto-updated after health passes)

The core insight: split the AI into two roles. Orchestrator (Claude/ChatGPT) — high reasoning, low volume. Writes specs, reviews evidence, manages flow. Builder (Cursor/Claude Code) — high volume, lower cost. Implements, provides proof. The Orchestrator defines scope before the Builder touches anything. The Builder works within boundaries. The Orchestrator reviews after. Two models, two verification passes. It's moving from "trust me" to "show me the terminal."

Why I needed this: I wanted to program by intuition, not by syntax. I can design systems. I can spec features. I can verify that tests pass and URLs work. What I can't do is read 200 lines of generated TypeScript and know if it's correct. So the system had to prove correctness without requiring code review. Evidence-based commits. Scope contracts. Clear rejection criteria. It's shared intuition for messy realities. Not a sandbox — I know markdown isn't a firewall. It's defense in depth: separation of concerns, multi-model review, explicit rules, human gates.

Technical notes: The workflow is a state machine: idle → building → verifying → done. Evidence comes from MCP-captured terminal output. The Orchestrator validates Builder output against TASK.md constraints. Red zone violations trigger automatic escalation. The /pilot folder is just markdown. Any MCP-enabled tool can read it. No vendor lock-in.

Limitations (being honest): Solo builder workflow. Team use needs merge strategy for state files. Convention-based, not filesystem-enforced. If you need true isolation, run in a container. Context can still drift if you skip the workflow. Health checks help, but it's not foolproof. Token overhead exists. Trading cost for correctness insurance.

What I've built with it: Private projects mostly — finance analyzer, productivity tools, Framer components, and Pilot itself. Iterating on the workflow every time I hit a wall until the walls stopped appearing.

Now using it on bigger things I plan to release.

Felt too good not to share.

Happy to discuss the architecture, failure modes, or specific edge cases.

Show HN : Pilot – System to improve dramatically your AI coding