Throughliner has three concepts that define how it works. The throughline carries the why — the reasoning behind decisions, preserved so it's never lost. Scope lock sets the boundary — what the agent is allowed to touch right now and nothing else. But neither of those explains where good scope and good reasoning come from in the first place.
That's the build cycle.
Four phases, three chances to think
The build cycle is the full journey of an idea from first impulse to built, shipped, recorded work. It has four phases, and the most important thing about it is that a piece of work gets independently evaluated at least three times before it becomes code.
1. Capture
You're in the middle of building something, and you notice something else. A bug. A missing feature. An idea for later. A thing the agent flagged while working.
In most workflows, this is where ideas either interrupt what you're doing or get forgotten. You stop and deal with it now — breaking your current focus — or you tell yourself you'll remember it later and you don't.
In Throughliner, you capture it. Right now, in whatever words come to mind, wherever you are in the process. It gets filed to the queue's Unprocessed section and you keep working. The capture doesn't need to be polished. It doesn't need to be a plan. It just needs to exist.
First evaluation: the moment of capture. Is this worth writing down? Usually yes — the bar is deliberately low, because a thought that doesn't get recorded doesn't get a second chance.
2. Process
Later, in a planning session, every unprocessed capture gets looked at again. This time with context: the rest of the queue, what's already been built, what's coming up, what the project actually needs right now.
This is where most ideas change shape. The raw capture — "maybe we need password reset" — becomes a specific, scoped piece of work, or gets combined with something related, or gets killed because it turns out to be unnecessary now that you see it next to everything else.
The AI evaluates the idea fresh, with the full queue in front of it. You evaluate it too, with the benefit of time and distance from the moment you first thought of it. Things that seemed urgent at capture time often look different when you see them alongside everything else that needs doing.
Second evaluation: processing. Is this the right work? Is it scoped correctly? Does it conflict with or duplicate something else? Is it ready to build, or does it need more thought? Both you and the AI weigh in, and only work that survives this pass moves to the ready region.
3. Execute
A new session. The AI reads the processed work item fresh — no memory of the planning conversation, no momentum from having just discussed it. It sees the item as a specification, evaluates what it would take to build, and presents the plan to you for one explicit approval before starting.
This fresh read is not a redundancy. It's a feature. An AI that just finished processing an item carries its own momentum — it's invested in the shape it helped create. An AI reading the item cold will catch things the planning session missed: ambiguity, missing details, assumptions that made sense in conversation but don't hold up on their own.
This is also where scope lock engages. The approved work becomes the boundary. The agent builds what was agreed and only what was agreed. Anything it notices outside that scope gets captured — fed back into phase 1, not acted on.
Third evaluation: execution. Does this item actually make sense as a build instruction? Can the agent determine what files to touch? If the scope is unclear, it halts rather than guessing — because building an ambiguous item means inventing scope the user never agreed to.
4. Close
The build is verified, committed, and recorded. This is where the throughline gets written — what was built, why, and what was decided along the way. Anything the agent noticed during the build that's outside scope gets filed as new captures, feeding phase 1 again.
The cycle loops. Today's close produces tomorrow's captures. Tomorrow's planning processes them. The queue is never finished — it's a living record of where the project is and where it's headed.
Why three passes matter
Most AI coding workflows have one pass. You describe what you want, the agent builds it, you look at the result. If the description was vague, the build is vague. If the idea was half-formed, the build is half-formed. You're betting everything on the quality of that one description, in that one moment, with whatever was in your head at the time.
The build cycle doesn't ask you to be good at describing what you want on the first try. It gives the idea three separate chances to be refined, challenged, and sharpened — each time in a different context, each time with both you and the AI looking at it independently.
That matters most when you're not a programmer. A programmer can compensate for a vague plan by reading the code and course-correcting on the fly. If you can't read code, the quality of the plan is the quality of the build. Three passes produces better plans than one pass, every time.
The build cycle is the engine; scope lock and the throughline are what it produces
Scope lock doesn't come from nowhere — it comes from a work item that survived processing and got scoped during planning. The throughline doesn't come from nowhere — it comes from the close recording what was built and why. The build cycle is the process that produces both of them.
Take away the cycle and scope lock becomes something you have to define manually, from scratch, every time. The throughline becomes something you have to write yourself, after the fact. The cycle is what makes those two concepts automatic rather than effortful — which is what makes Throughliner a workflow rather than a checklist.
We've written about scope lock — what it is and why it matters. We've written about the state of the industry — who else is thinking about agent restraint, and who they're building for. And we've written about why non-coders need this most — the gap between what the agent changed and what you can verify. The build cycle is the mechanism underneath all of it.