Skip to content
Back to Blog

Bolts: A Team Playbook for Running Agentic Work in Hours

AI Transformation Lead
  • Agentic AI
  • AIDLC
  • Bolts
  • Engineering Management
  • Workflow
  • Developer Productivity

The word "sprint" stopped describing the work the moment agents started writing most of the code. A sprint assumes a person sits down and types for two days. When the typing collapses to minutes and the bottleneck moves to deciding what to build and trusting what came back, the two-week container is the wrong shape. AWS renamed the unit to make the point. The week-long sprint becomes a bolt, a cycle measured in hours, because the constraint is no longer how fast anyone types.

Bar-chart motif illustrating a team playbook for running agentic work in short bolts

A bolt is one loop, run tight: a spec, a generation, a verification. Most teams already do all three. They just do them slowly, across days, with the steps smeared together so nobody can see which one is actually holding things up. Running bolts means separating the steps, making each one fast and explicit, and repeating the loop many times a day instead of once a fortnight. Here is how a team runs them without it turning into chaos.

Intake: nothing enters without a shape

A bolt starts with a unit of work small enough to specify in a paragraph and verify in an afternoon. If it cannot be shaped that small, it is not a bolt, it is an epic, and it gets decomposed first. This is the discipline most teams skip, and skipping it is why their agent runs wander. An agent pointed at a vague ticket produces vague output that fails review, and the failure looks like a model problem when it was an intake problem.

The intake gate is one question: can I write, in a few sentences, what "done" means and how a machine or a person will confirm it? If yes, the bolt is ready. If no, it goes back to shaping.

The loop: spec, generate, verify

Spec. A human writes the specification. Not a novel, a contract: the behavior, the constraints, the acceptance checks. This is where the engineer's judgment now lives, and it is the highest-leverage ten minutes in the whole cycle. A good spec is the difference between an agent that solves your problem and one that solves a nearby problem convincingly.

Generate. The agent produces against the spec. The engineer supervises rather than types, steering when the run drifts and killing it early when it goes sideways. A bolt can contain several generation attempts. The cost of throwing one away is minutes, so throw the bad ones away without ceremony.

Verify. The result meets the gate before it counts as done. Types, tests, and evals run first. A skeptic pass looks for what the spec missed. A human reads for intent on anything above the lowest risk tier. Verification is not the last five percent of a bolt, it is half of it, and teams that treat it as an afterthought ship the productivity paradox: faster generation, slower delivery, because the unverified code piles up somewhere downstream.

Roles inside a bolt

The roles do not disappear, they shift. The engineer moves from author to specifier and verifier. The tech lead owns the repo conventions and agent rules that make generation predictable, and draws the line on what agents may touch. QA owns the eval suite, the part of verification that runs without a human. The manager owns nothing inside the loop and everything around it: making sure bolts are shaped, unblocking the intake queue, and reading the throughput.

The standup changes with the roles. "What did you do yesterday" becomes "how many bolts cleared the gate, and which ones bounced and why." The bounces are the signal. A bolt that fails verification twice is telling you the spec was weak or the work was too big, and both are fixable at intake.

Cadence and WIP limits

Bolts tempt teams into starting everything at once, because generation is cheap. Resist it. The bottleneck is verification, and verification is human attention, which does not parallelize the way generation does. Cap work in progress at what your reviewers can actually clear. A team that starts twenty bolts and can verify six has not gone faster, it has built a queue and hidden it. Fewer bolts, fully closed, beat many bolts left open.

Run bolts in a steady rhythm rather than a heroic burst. The engineers who sustain this are the ones who trust the loop enough to stop hovering over every generation, and who let the gate, not their anxiety, decide when a change is done.

Measure verified throughput

The only number that matters is verified work that stayed green. Count bolts that cleared the gate and held in production. Watch the bounce rate at verification and the escape rate past it. Rising throughput with a flat escape rate means the loop is healthy. Rising throughput with a rising escape rate means your gates are decorative, and you are generating faster than you can trust, which is exactly the trap that made "faster" feel like progress while delivery slowed.

Teams do not become agentic by buying a tool. They become agentic by changing the unit of work, and the bolt is that unit.

Questions about this piece

Follow-ups readers ask most often about the argument above.

  • A bolt is a short unit of work built around one loop: write a tight spec, let an agent generate against it, and verify the result before moving on. AWS uses the term to replace the week-long sprint, because the constraint is no longer how fast a person types. A bolt is measured in hours or a day, not a fortnight.

  • An assistant speeds up one person typing. A bolt reorganizes how the whole team works: intake, spec, generation, and a verification gate, run as a repeatable loop with explicit roles and WIP limits. The point is throughput of verified work, not raw output, which is the metric that actually moved the wrong way when teams only sped up generation.