Claude CodeGitHubSDDv0.7.3 · MIT
House rules for thirty agents.
Bitblitzin Bootstrap is a Claude Code plugin for projects where many AI coding agents work at once. It gives the project house rules and the machinery that enforces them, so the rules hold when nobody is watching.
Without it: thirty new hires, no manager.
Agents are fast and eager, and each one starts with no memory of the project. Left alone, they do what any crowd of newcomers does.
With it: rules that hold.
Every rule came from something that went wrong on a real project. The plugin writes the rules down, and then it enforces them with hooks, checks and a queue that do not get tired or forget.
Built for GitHub, GitHub Actions, the gh CLI and Claude Code. When a project uses something else, the skill says so once and adapts. The rules are about kinds of places, not products.
Eight pieces. Each one closes a gap that a real project fell into.
Tasks live in the issue tracker, one per task. Status lives on a board the tracker feeds automatically. Orientation for a newcomer lives on one generated page built from small per-feature stubs. Design lives in a spec written before building; a pull request names its spec in its body rather than editing a shared spec file. Tasks live in issues, not a tasks file. A dependency bump needs no manual entry. Nothing is appended to a shared page just to pass a check, and a move on main in docs, specs or status never costs a green pull request a re-run.
Dangerous commands are refused before they run, each with one sentence saying what to do instead. A stop hook refuses to let a task end with uncommitted files, stray images, or a server still running. The full list is below.
Finished, green pull requests are combined in the queue's own worktree, tested together, and merged as one. What conflicts or breaks is dropped, not everything. The steps are below.
When an agent starts, it sees where the project stands in one network call, about two seconds. It opens with today's date in the owner's time zone, the zone every date in the repository is written in. No reading twenty files to find out who has the ball.
Stand a project up, find out where everything stands, and propose the next round. Each one reads the project rather than asking you to describe it. The bootstrap survey opens by asking whether a sibling repository can supply the stack. Branch protection and the database are one script each: the rules the queue needs on main, and the project's Supabase database with the password written only to the env file. Only the board's built-in workflows stay manual, because GitHub has no API for them.
Change classification, a spec check, a setup-manual check, a shared-code check, a numbering check so parallel pull requests never take the same migration number, a line-endings check, and a nightly audit that speaks only when something is wrong. A red main closes its own issue when the next run passes, and a job that fails once and passes on re-run is recorded as a flake, the same way a test is. Self-hosted Windows runners are first-class: the templates say where jobs run and which shell they get, the installer refuses to run unelevated and installs one folder per repository, a doctor script checks the machine before any run, and an hourly watch reports a runner gone quiet.
One page from one config file: what the project talks to, the state of each system, and how to do the routine things.
Keeps each project's copies of the scripts current with the plugin, keeps any local edits rather than overwriting them, and says what it left alone.
Each refusal comes with one sentence saying what to do instead, so the agent keeps moving.
It gathers finished work, tests it together, and merges in batches, so nobody merges over anybody.
It also knows the ways a queue goes wrong:
When an agent starts, it gets a brief. One network call, and it knows the state of the project before it touches a file.
/project-bootstrap
Stands a project up for many agents, or rescues one that is struggling.
/project-status
Light subagents read bodies and comments and report one line per item, only for items that changed.
/project-drive
Proposes the next round from the board and the test results, and pursues only what a person approved.
Bitblitzin Bootstrap is the enforcement layer between an agent orchestrator and the repository. It is not a cockpit for launching agents, not a spec-writing tool, and not a hosted merge queue. It is the house rules for the repository those agents drive on, with machinery that makes each rule hold when nobody is watching. It sits alongside most of the tools below.
Conductor, Vibe Kanban, Agor, Claude Squad, Composio's Agent Orchestrator, Vyuha.
They do: run many agents in parallel worktrees behind a dashboard. They are where you launch and watch agents. Composio's is the closest in scope, giving each agent its own workspace, branch and pull request.
The plugin: works underneath any of them. It does not care which cockpit started the agent, only what the agent does to the repository.
claude-code-safety-net and similar.
They do: block commands that destroy files, such as rm, force push and reset, using the same hook mechanism the plugin uses.
The plugin: blocks those too, and also what is safe for files but ruinous for a team: running the whole test suite instead of one file, appending to a generated page, filing an issue with no state, merging around the queue, closing a pull request without a reason, dispatching an agent on a heavier model than the task needs, and stopping a shared build daemon on a machine that hosts a CI runner.
Spec Kit, Kiro, OpenSpec, Tessl. Martin Fowler's site compares three of them.
They do: define how to write a spec.
The plugin: assumes one of them or none, and enforces only that every change belongs to a spec, named in the pull request. One deliberate departure from Spec Kit: a tasks file is written once at planning, turned into issues, and frozen, because a tasks file every pull request appends to is the shared page that breaks batching.
GitHub's merge queue, Mergify.
They do: serialize or batch merges with CI on the combined result. They are the standard answer to agents merging over each other.
The plugin: runs only the tests each change touched before the one full run, explains stuck runs in plain words including when GitHub itself is down, paces itself inside GitHub's hourly API limit and runs one copy at a time, and checks the base is healthy before blaming any pull request. A project happy with GitHub's queue can use it and keep the rest of the plugin.
Built into Claude Code.
They do: give agents in one session a shared task list, messaging and file locks. That coordinates the agents one person is running right now.
The plugin: coordinates agents across sessions, people and days, through the issue tracker and git.
Combine all of it: one home for every kind of thing, hooks, CI checks that run per change class, a batching queue, a session brief that reads the project's live state in one call, a board that feeds itself, and a sync that keeps every project's copy current. Each piece came from a failure on a running project with multiple agents at once.
Parallel agents
pass alone, fail together.
Agents have no protocol to see each other's branches or claim files.
From a shell, which also works in a setup script. The plugin's name inside Claude Code is bitblitzin-bootstrap.
claude plugin marketplace add Pawper/bitblitzin-bootstrap claude plugin install bitblitzin-bootstrap@bitblitzin-bootstrap
Or inside a Claude Code session:
/plugin marketplace add Pawper/bitblitzin-bootstrap /plugin install bitblitzin-bootstrap@bitblitzin-bootstrap
Then, in a repository:
/project-bootstrap set this project up for many agents
Tests run with sh tests/run.sh and need only sh and awk. MIT license. Source on GitHub.
Built from failures.
Every rule here came from running a real project with many agents at once and watching something go wrong: checks that accidentally rewarded appending to shared files, a queue that exhausted its API budget, a test runner that could not find a package in a subfolder. Each failure became a rule. That is the whole method.