Two ideas run through agentic development, and teams tend to learn them separately. Spec-driven development says the written specification is the source of truth and code is a regenerable output. The bolt says the unit of work is a cycle of hours, not a two-week sprint. They are not two methods. They are two halves of one loop, and the loop is the thing worth understanding.
Put simply: the spec is the contract, and the bolt is the cycle that builds against it. Write a tight spec, let an agent generate, verify the result, close the bolt, repeat. That single sentence is the whole agentic development model. Here is what it looks like when a team actually runs it.
Intake: shape the work
Nothing enters the loop without a shape. A unit of work arrives, and the first job is to size it to a single bolt, small enough to specify in a paragraph and verify in an afternoon. Work too big gets decomposed into several bolts here, at intake, before any agent touches it. The intake gate is one question: can I state what done means and how it will be confirmed? If not, the work goes back to shaping. Skip this and every later step wobbles.
Spec: write the contract
A human writes the specification: the behavior, the constraints, the acceptance checks. This is the highest-leverage step, because a precise spec is the difference between an agent that solves your problem and one that solves a convincing nearby problem. The spec is versioned like code, because it is code's source of truth, and it doubles as the checklist the verification step will run against.
Generate: the agent builds
The agent produces against the spec while the engineer supervises rather than types, steering when the run drifts and killing it early when it goes wrong. A bolt can hold several generation attempts; the cost of discarding a bad one is minutes, so discard it without ceremony. The spec keeps the generation honest, giving the model far less room to invent intent than a bare prompt would.
Verify: the gate that earns trust
Verification is not the last five percent of a bolt. It is half of it. The machine layer runs first: types, tests, linters, and an eval suite that encodes the behavior you care about. A skeptic pass, often a second agent whose only job is to find where the output is wrong, runs before any human. Then a person reads for intent on anything above the lowest risk tier. Only a change that clears the gate counts as done. Teams that treat this step as optional ship the paradox where generation sped up and delivery slowed, because unverified code piled up downstream.
Integrate and repeat
The verified change merges, and the loop starts again. Because bolts are short, the team closes many a day, and because each one carries its spec and its verification trail, the work stays auditable rather than living in a chat window that scrolls away. AWS's AI-DLC formalizes this with file-based artifacts at every phase for exactly that reason.
Why the loop scales to many agents
The quiet superpower of the spec-to-bolt loop shows up when you run more than one agent. A spec partitions a problem into modular, non-overlapping pieces sized to a context window, which means you can assign separate specs to separate agents and let them run their own bolts at the same time without stepping on each other. The spec is the boundary. Prompt-driven work cannot do this, because two agents guessing intent will collide; spec-driven work can, because the intent is written down and divided cleanly.
The loop is the method
Everything else is detail on top of this cycle. Intake keeps the work shaped, the spec keeps the generation honest, the gate keeps the output trustworthy, and the short bolt keeps the whole thing visible. Get the loop right and the tooling, the model, and the org chart around it become choices rather than gambles.
For the pieces in depth, see what spec-driven development is and what a bolt is. For running it as a team, the members-only bolts playbook covers roles, WIP limits, and metrics, and for training a team into this loop, AI Team Enablement is the engagement built around it.
Specs without bolts are documentation. Bolts without specs are vibe coding at speed. The loop is where they become a method.