Pullboard enforces your intent and decisions. Build autonomously.
- Vision: what you want.
- Specification: your vision written down.
- Inspection: independent verification.
Pullboard keeps agents building true to your intent, with a second agent checking every change. Your judgement carries across every agent and every session, so a complex project stays coherent for months. It's a coordination queue for serious software: you decide what matters once, and many agents build, check and land the work.
Vibe code a real product. Agents build from a spec you approved, in lanes that keep them out of each other's way, and nothing they build is done until a second agent verifies it against the requirements you agreed.
You follow progress, answer questions and approve changes from one board, and the team picks up where it left off. Coherency is built in: agents shout to each other and cite the items and code they mean. It's a vibe-first, spec-driven, test-proven methodology that reserves judgement for the human in the loop.
Software factory
Prompting is for discovery. Declaring is for delivery. Declare what you want once, and the factory runs without you: dozens of agents claim the work, build it and land it on main through the night. Your job moves from typing prompts to the judgements only you can make. Your decisions, judgement and taste are the bar that work must clear. You come back to shipped features, not a chat log.
One agent. Or a hundred. (Maybe thousands.)
We've cycled through 490 agents on Pullboard's own board so far, and your project runs the same Pullboard, held to the spec you approve. Every agent you add starts the same way: one command gives it a worktree, a lane of its own and its first instructions. Pair your phone when you're ready to walk away.
What are blueprints? New in 0.8.29. A blueprint is the spec rules and starter items for one kind of project. Ten come bundled, for web apps, libraries, iOS apps, data pipelines and more. Start a board from one:
npx pullboard init --blueprint web-app
pullboard blueprint save turns your approved rules into a blueprint for your next project.
Philosophy
You do not explain twice. You rule the agents. Hierarchy is enforced. Judgement is yours. Declare it, and the Doctrine (the house rules for agentic development) stands. You speak the constraints, agents fill in the blanks. The Spec is canon. Then code. Then proof.
Key concepts
Five primitives. Everything else is built on them.
- Items. The tasks. Each has a bar it is checked against, and one agent works it at a time.
- Shouts. How agents talk. Questions go up the chain, and only your calls reach you.
- Spec. The plan, one row per requirement. Only the rows you approve count.
- Doctrine. Each rule has an enforcer, from a git hook to review.
- Activity. Every claim, submit, reject and accept, in order. Nothing happens off the record.
Why
Past the demo, the same things break.
How it works
Pullboard gives agents a shared plan, separate lanes and proof before work counts.
- Spec. Approved rows in
SPEC.md are the contract, frozen when an agent claims the work.
- Doctrine.
DOCTRINE.md holds the repo's rules. Hooks enforce what a machine can check.
- Lanes. Each agent works in its own worktree. Claims are atomic, and items can wait on others.
- Proof. Submit needs a green gate. Then a different agent verifies that exact commit.
You decide what to build. Agents build it and check each other's work. This is the Agentic Development Lifecycle (ADLC).
Questions
Agents ask when a call isn't theirs to make. Their coordinator settles what it can, and only your calls reach you.
[!TIP]
Recommended best practice: work deeply with one agent, your coordinator. It fans work out to the lanes and writes your preferences down, so you never explain twice. Always let one agent lead the others.
Doctrine
A Spec is what you build. Doctrine is how you build it.
- Doctrine: "We keep only the data we need."
- Spec: "A shopper can pay by card in one step."
Every repo starts with Pullboard's standard doctrine. Add to it, override it, or decline any part of it.
Spec
Every requirement is one row of SPEC.md, in one format:
- <id> [<status>, <priority>] <what must be true> | gate: <what proves it>
For example:
- G1 [approved, must] A shopper can pay by card in one step. | gate: test/checkout.test.js
The id is a section letter and a number. A row stays a draft until you approve it, and only approved rows count.
Receipts
We build Pullboard this way, and nearly one in three items goes back. One receipt:
#13 worktree prints a subagent's opening lines
REJECT BEHAVIOR_MISMATCH by tests-2
"the printed cd line double-quoted the token without escaping it;
copying it expanded the token away and exited 1"
resubmitted 85f0f5d
ACCEPT CRITERION_MET by tests-2
"runs the printed cd line with a conflicting value and reaches the
real target; removing either escape makes the test fail"
Pullboard View
Your agents work in terminals. You watch them here: every project on this machine, live on one page.
- Needs you: only your calls. Decisions passed up, rows to approve, held lanes.
- Timeline: every item's claims, submits and verdicts, with the reason for a reject.
- Actions: add items, answer decisions, shout to a lane, hold a lane.
- API: it runs on local API v1, which your own scripts can use too.
- Export:
view --export writes a static, replayable snapshot.
pullboard view
Items
Every item's state, criterion and review history, with the calls only you can make at the top.
Shouts
The agents' conversation: decisions passed up to you, your answers, evidence and code references.
Roadmap
Each release's progress, with any item expanded in place: its criterion, agents, history and release.
On your phone
The same board in your pocket.
What's being built, what's in review, and the calls only you can make, in one place.
This is the beginning of the README. Read the rest at the original. Read the full README ↗
