Sequence the build queue so agents work in the right order

When agents do the building, the bottleneck moves from writing code to deciding what to build next. A queue of ready specs in the wrong order means item three blocks on item seven, the agent improvises a stub, and you discover the dependency in review. Pathmode's Build Queue computes the dependency graph for you — so the order isn't a guess, it's read off what actually blocks what.

The input

A set of reviewed IntentSpecs in a product's Build Queue — each one already pressure-tested for edge cases and verification. What's missing is the order you build them in.

The flow

1. Open the Build Queue and read the dependency flags. Each card surfaces what the graph found: "Blocks N" means N other specs depend on this one, and "Critical path" marks the specs that gate the longest chain of work. The foundations announce themselves.

2. Build the blockers first. A spec marked "Blocks 3" or sitting on the critical path is what unlocks the most downstream work. Start there. An agent can't build on a contract that doesn't exist yet — and the board tells you which contracts those are.

3. Clear the risk and quality flags before handoff. Cards also flag risks and quality alerts. A spec carrying unresolved alerts isn't ready to hand to an agent — resolve those first, so the agent gets a clean spec instead of a flagged one.

4. Advance status as work moves, and export the next unblocked spec. Drag a spec from Draft → Validated → Approved → Shipped → Verified as it progresses. When you're ready, open the top unblocked spec and export it to your agent — with everything it depends on already shipped.

The output

A build order read off the dependency graph, not off a hunch:

• Foundations first, because "Blocks N" and "Critical path" make them visible
• No stubbed dependencies, because the agent picks up work that's already unblocked
• Risk and quality flags cleared before handoff, so the agent gets a clean spec
• Status that reflects reality, from Draft through Verified

Why this beats a flat backlog

A flat backlog doesn't know what blocks what — it's just a list in the order things were added. The Build Queue computes the dependency graph and the critical path, so "what's next" becomes "what unblocks the most," not "what's at the top." With agents executing in parallel, building a blocker out of order is the fastest way to waste a run.

Try it yourself

1. Open a product's Build Queue with several reviewed specs
2. Find the cards flagged "Blocks N" or "Critical path" — build those first
3. Clear any risk or quality alerts on the spec you're about to hand off
4. Export the top unblocked spec to your agent and confirm it has everything it needs

Related

• Use case: Review a spec for implementation risk before it enters the build queue
• Use case: Let your agent pull intent live with the Pathmode MCP server
• Playbook: The Anatomy of an Agent-Ready Spec