Set up the structure once, and trust what they ship without watching every step.
Romain Pattyn • Codika
A repeatable way to run coding agents on their own, and trust what they ship.
We rebuilt it internally: the same premium features, plus more, and we own 100% of the code.
Each one is a requirement, and the takeaway that solves it.
The agent builds what you give it, not what's in your head. The hard part is making sure the spec really is what you want, and that you and the agent read it the same way. Get this wrong and you can't blame the agent.
Plain plan mode is too thin. Have the agent write a real HTML plan you can see: the data model, the UML, the mermaid flowcharts, and a live roadmap, all in one page.
People avoid changing small plan details to "save context." That's backwards. Go into every detail. Planning rounds are the cheapest, highest-leverage tokens you'll ever spend. A wrong decision here costs you a whole phase later.
An overnight run dies the moment it needs a human. Nothing during implementation or testing can require you, so every manual step has to be handled before launch.
Accounts, OAuth, CLI logins, secrets, all set up before you start, so nothing blocks the agents mid-flight. Plus a stop rule for the rare real blocker: it stops and asks, it never guesses.
A build this size runs to millions of tokens, far past any context window. And you never want to compact the conversation, because that quietly drops information you needed.
Fragment the build into phases. An orchestrator spawns a zero-context sub-agent for each one, auto-merges its PR, and logs the results back into the plan. 38 phases shipped this way across three versions.
The orchestrator never writes code itself. It hands each phase to a fresh sub-agent, follows its progress, and records the outcome, its PR, runtime, tokens, and any deviations, in a roadmap it owns. It delegates and tracks; the sub-agents do the building.
To run unattended, the system has to implement, deploy, test, and fix itself from the test results. The whole loop has to close with no one in it.
Two wins. First, true end-to-end tests: a test becomes a real booking through the real API, not a mock. Second, it makes the product 100% agent-native, any agent can install the CLI and drive the tool itself.
Ask the agent to design the CLI-driven end-to-end flow during planning. Projecting itself actually using the tool surfaces edge cases (concurrency races, timezones, buffers) that enrich the plan before any code exists.
The agent that wrote the code can't be the one that signs it off, it's biased toward its own work. The review has to come from a different agent that never saw the implementation.
A fresh QA agent caught a real serverless bug: a fire-and-forget call that never fired on Vercel. 12/12 end-to-end and 13/13 Playwright, against a live database and calendar. That's how you trust the output.
Romain Pattyn • Codika
Building with agents: the blocks that let them run unattended.