2026 · A working philosophy
How we build software with AI agents — the philosophy and the workflow, written down.
Coding agents crossed a threshold: they write most of the code now. What didn't cross the threshold is the way we work with them — one chat at a time, watching tokens stream, hoping the diff is good.
The bottleneck moved. It is no longer how fast machines write code. It is how deliberately humans direct it.
This is the way we work.
The moment an agent writes your code, your job changes: from typing to directing. Define the work, set the standard, review the result. An engineer who measures themselves in lines written is competing with the machine. An engineer who measures in outcomes shipped is using it.
A prompt is a wish. A spec is a contract: what will be built, which files it touches, what proves it works. Agents are fluent, fast, and confidently wrong — the spec is where wrong gets caught while it is still cheap. Approve the plan, not the surprise.
Cut work into stories: small, independent, verifiable. A story fits inside an agent's context window and inside a reviewer's attention span. If two stories touch the same contract, they are one story — or they run in sequence.
One story, one agent, one isolated worktree. Parallelism without isolation is sabotage: two agents in one checkout will overwrite each other's work, politely and confidently. Everything else in this document is a discipline. Isolation is a law.
Running one agent at a time undersells the machines and wastes the human. Run several stories at once — not because more is impressive, but because waiting became the new idle time. Go parallel until your review queue, not your hardware, says stop.
An agent that can run the tests iterates toward true. An agent that cannot iterates toward plausible. Give every story a definition of done that a machine can check — then let the agent check it, fail, and try again before the work ever reaches you.
Nothing merges from a chat log. Every story ends in a pull request: a bounded diff, traceable to a spec, reviewed by a human. Read the spec first, then the diff. And when it is wrong, do not fix it by hand — fix the spec and send it back.
Agents scale. Review does not. Budget your attention like the constraint it is: smaller stories, sharper specs, fewer but better parallel lanes. The day you start rubber-stamping diffs is the day the system has failed — slow down before the codebase makes you.
Your code on your machine. Your models on your own keys. Your workflow written down, in the open, portable to whatever comes next. The agents will change every year. The process is yours to keep.
One story at a time for the agent. Many stories at a time for you.
Repeat. In parallel.
Vibecoding is a fine way to explore and a terrible way to ship. Production code deserves a plan.
Attention spent watching an agent type is attention stolen from the work only you can do.
If the reasoning behind a change lives only in a scrolled-away conversation, it doesn't live anywhere.
Autonomy ends at the merge button. It stays human.
Terminals, diffs, browsers, boards scattered across a desktop is not a process — it's a coping mechanism.
This manifesto stands on its own — use it with any tools you like. AIDEN is the workspace we build so that working this way is the default, not a discipline.
Written by Kylian Migot · @leonlykiks · July 2026
Download the PDF