AI Lab · productized
Directing AI, not coding in its place
Rebuilding a product by directing AI end to end, and measuring that direction the way you measure a product: 21,458 directed AI actions over a four-month window, five directing verbs, a system of guardrails. The bet: prove that orchestration is a method, not a stroke of luck.
Everyone says “I use AI”. The interesting question is elsewhere: what do we have it do, what do we keep, and does it hold over time? During the rebuild of a product portal, every action entrusted to the AI was recorded, then compiled into an orchestration report. Not for the vanity of the number: to verify a conviction. Directing AI is design and lead work, and work can be measured.
The result over the rebuild window, four months from first commit to production: 21,458 directed AI actions, 206 active hours, 251 sessions. Every action falls into one of five directing verbs: explore, act, structure, document, delegate.
The breakdown tells the posture better than any speech. Execution dominates: 56% act, 37% explore. Structure and documentation weigh only 6% of the actions, and that is exactly the point: they are the gestures the human keeps, because they are what makes the rest delegable. A product whose structure and decisions are traced on the human side stays steerable when you are no longer in the loop. A product generated without that backbone becomes a stranger nobody dares touch anymore.
Read the full story · the false start, the system, the method
The false start that taught everything
Honesty first: the start failed. The urge to do things well produced an overloaded instructions file, an architecture thought out in advance and injected into the AI. Result: the agent started from scratch on every component, reinvented the design, mixed technologies. The problem was not the AI. It generated exactly what it had been given.
The correction came from tech, and not after the fact: the tech lead structured beforehand. Instructions split by folder and by feature, under 200 lines each, naming conventions, test rules. The principle that comes out of it holds in one sentence: frame before generating. The instructions file is not documentation, it is infrastructure.
A three-layer system, not vigilance
The method holds because it rests on no manual vigilance, which would eventually give way. Three layers carry it.
Written instructions first: about fifteen hierarchical files, loaded in cascade depending on context, with a single source for the product vision and one for the design system. Automated guardrails next: every commit goes through a conventions check, a pre-commit hook (types, capped lint), a pre-push hook (tests, build), and the CI replays the same barrier downstream. Visibility last: a local playground that renders every screen in seconds, tests, and specialized review agents that challenge conventions, security and debt.
Inside that frame, a feature’s journey follows nine validated steps, from ticket to production, with a systematic decomposition before the first line: target files, states to cover, blocking questions. The AI speeds up the journey. It never decides the course.
One writing rule completes the setup on the front-end side: the design system component first, custom only when the system does not cover the need, and then flagged with a greppable comment from the very first line. Simple governance, enforceable through text search, which keeps an AI-assisted product maintainable and auditable.
Coding is designing
The deepest shift is not in the tooling, it is in the design gesture. Iteration no longer happens on a mockup, it happens on the real screen: a framed intention, an AI proposal already in the design system, then the live adjustment of hierarchy, density, clarity, up to the final call. Figma has not disappeared, it has returned to its rightful place: the decisions that deserve a mockup, and only those.
This is not skipping the design step. It is moving it into a more demanding medium: you judge on the true rendering, not on a mockup that always lies a little.
One last lesson, almost in passing: the coding agent changed mid-course, for an availability and cost trade-off, then changed again. Neither switch changed the method. That may be the best test of an orchestration practice: if it survives a tool change, it really exists.
What remains to be proven
The method became a framework: fifteen self-assessable dimensions, from product context to design system governance, instantiated on other teams, each at its own maturity. And the test became real in the summer of 2026: its creator left, the system remains. The instructions, the guardrails, the framework and the instances carry on without the person who built them, and that was the criterion from the start: a practice that only holds through its creator is not a method. As for the numbers in this report, they are already there: they are gladly shown, live.