Studio 02.
On good days, I was all six people.
Every product I have ever shipped ran the same hidden sequence before any code was written. Someone interviews the idea until it stops hiding. Someone pressures it until it gets honest. Someone writes the brief. Someone defends the scope. Someone breaks the whole into parts. Someone writes the stories the engineers will build from.
On good days, I played all six parts myself. On bad days, the sequence silently did not happen, and we started building before the idea was ready. That is how good products drift into good-looking accidents.
I looked for a tool that ran the sequence with discipline. I found tools that chat, and tools that lock teams into someone else’s process. So I built a line.
01
The Interviewer
Most ideas are hiding from their own gaps. The Interviewer asks until the hiding stops.
It does not brainstorm. It interrogates, gently, until the idea admits what it actually is, and where it actually breaks.
02
The Clarity Analyst
A score you can flatter is a score you cannot trust.
It rates the idea across six dimensions: product, experience, technical, data, business, security. Below threshold, the idea goes back for another round. It refuses to inflate the score, because a number you can talk up cannot save you later.
03
The Brief Architect
If it cannot be written, it is not ready.
It turns the honest idea into a twelve-section brief: the what, the why, the who, the risk, the line between in and out. The brief is where ambiguity gets a body.
04
The Scope Guardian
The argument happens here. Never inside the code.
It negotiates the minimum that ships first and the future that waits, with explicit inclusions and exclusions. The debate that would otherwise surface as a rewrite two months in happens now, in a room, before anything is built.
05
The Feature Mapper
One whole becomes named, buildable parts.
It decomposes the scoped product into features that can be argued about one at a time, each with a shape a developer can actually pick up.
06
The Story Writer
Done means verified.
It writes each feature as a story with acceptance criteria, in Given, When, Then. A task is not finished because an agent said so. It is finished when the criteria pass.
One wall.
Under the six stations runs one rule. Every touch of the outside world, every tool, every model, every repository, every browser check, goes through a single wall. Twenty-eight capabilities. One method signature. Zero direct imports.
On a normal day that wall is invisible. On the day the world underneath it changes, it is everything. Swap a local tool for a remote one, a model for another model, and no workflow above it moves a single line. Most systems skip the wall because it looks like ceremony, until it is the only thing standing between you and a rewrite.
The fallback.
The line runs without API keys. Every station carries a deterministic fallback that produces valid output even when no model answers. The AI makes the output better. The line never stops. That is the difference between a tool and a machine.
01 through 06. Then 01 again.
One test decides when the machine is done. It must be able to forge itself. The foundry that builds my products must build itself through the same six stations, with the same refusal to skip a step. If it cannot forge itself, it is not done.
Whether Caddy becomes a product or stays my private foundry is a decision I have deliberately postponed. The line does not care. The line just runs.