# Buildomator AI software engineering for Claude Code ## Beyond code generation. Buildomator plans, builds, tests, reviews, and ships. It brings the discipline of real software engineering to Claude Code, and only stops to ask about the decisions that need a human. - [View on GitHub](https://github.com/buildomator/buildomator) - [How it works](https://buildomator.com/#how) - [New in 5.0: Superpowers integration](https://buildomator.com/#superpowers) - [Now with VibeDrift protection](https://buildomator.com/#vibedrift) - [New in 4.9.2: Craft Skill Catalog](https://buildomator.com/#craft-skills) Built for developers shipping with Claude Code. ## Now with VibeDrift protection New in Buildomator 4. Long AI coding sessions leave drift behind: copy-pasted near-duplicates, stubs that look finished, patterns that slowly wander apart. Buildomator scans for it and flags it before it ships. The checks are ported natively from VibeDrift, so there is nothing extra to install. - **Near-clones**: files that are the same code with the names changed, found by structural similarity (MinHash and LCS). - **Phantom scaffolding**: stubs, TODOs and placeholder returns that look finished but do nothing. - **Duplicated logic**: the same logic pasted into several places instead of shared once. Where it runs: - `/bm:scan --drift` - `verify drift` - `/bm:audit-milestone` integrity gate (opt-in) Heuristics ported from [VibeDrift](https://www.npmjs.com/package/@vibedrift/cli). Never installed, never run. 100% native. ## Six upstreams, one tool Buildomator curates selected skills from Superpowers, packages the GSD workflow engine, borrows ideas from VibeDrift and Simplified Technical English, implements the workspace.json spec and draws on a curated catalog of skills.sh skills. None of them ships as a runtime dependency. You install one plugin and get what all six are good at. - **[Superpowers](https://github.com/obra/superpowers)** (skills curated): Five skills, offered when the task fits. Buildomator curates five skills from Superpowers: test-driven development, writing plans, verification before completion, root-cause debugging and brainstorming. It keeps only metadata and a pinned, reviewed commit, never the skill text. Each skill is proposed on fit to the agent that needs it (planner, debugger, verifier or executor), passes the same safety and license check as every other catalog entry, and is never installed or run. Superpowers by Jesse Vincent (obra), MIT. New in Buildomator 5.0. - **[GSD core](https://github.com/open-gsd/get-shit-done-redux)** (packaged): A real workflow, not a chat log. Every piece of work goes through discuss, plan, execute and verify. Specialized agents (planner, executor, verifier, code reviewer, debugger) pick up their part, and independent tasks run side by side in parallel waves. GSD by TACHES, continued by open-gsd. - **[VibeDrift](https://www.npmjs.com/package/@vibedrift/cli)** (ideas ported): Drift caught before it ships. It spots copy-pasted logic, placeholder scaffolding and near-duplicate files that long AI sessions tend to leave behind. The checks are ported natively, so there is nothing extra to install. - **[workspace.json](https://github.com/workspace-json/spec)** (spec implemented): Sessions that already know your codebase. When `.agents/workspace.json` exists, Buildomator reads it at session start and hands Claude your fragile files, frameworks and co-change notes. The file is version-gated and sanitized against prompt injection. Integration contributed by Qwynn Marcelle. - **[ASD-STE100 Simplified Technical English](https://www.asd-ste100.org/)** (ideas ported): Docs in plain English. A prose check borrowed from the 1986 aerospace writing standard keeps READMEs and changelogs free of filler. It only fails a commit when the count grows past a frozen baseline. - **[skills.sh](https://skills.sh)** (curated, pinned): Skills that show up when the task needs them. Craft skills add highly specialised capabilities for specific tasks, such as database performance tuning or Search Engine Optimisation. A small curated catalog points at them in the skills.sh ecosystem, each pinned to a commit. When a task mentions something like meta tags or a sitemap, Buildomator shortlists a matching skill and asks once before adding it. Nothing adds tokens unless it is deemed appropriate for that specific task. Licenses get checked too: copyleft is flagged for you to decide, unlicensed skills are blocked. The prompt shows the publisher, the license (MIT) and the trust tier (A); if you accept, the skill is inserted for that task only and released afterwards. New in 4.9.2 as the Craft Skill Catalog. Starts with SEO and DuckDB; more are added as we go. Context overhead per turn drops from about 3,000 to 5,000 tokens with GSD via CLAUDE.md to about 200 with Buildomator, because skill bodies run in forked sub-agents and state lives in MCP. What Buildomator adds on top: - MCP-backed project state - Auto-resume across `/compact` - Skill isolation with `context: fork` - Convention conformance gate - Cross-session memory - ~92% less per-turn token overhead ## Engineering discipline: Not just faster. Better. Buildomator follows proven engineering practices end to end, so you get code you can trust and a project that stays maintainable. 1. **Plan with intent**: Architect features before writing code. Clear plans, fewer surprises. 2. **Design for change**: Well-structured code and clean interfaces that age gracefully. 3. **Test everything**: Automated tests by default. Confidence with every change. 4. **Review always**: Every change reviewed. Quality isn't optional, it's built in. 5. **Ship with confidence**: Pull requests that are ready. From local to production. ## What is Buildomator: Built for the long game For people who know what they want to build but would rather not live in the code. Buildomator brings real planning, testing, and release discipline to AI-assisted work. It only asks you about the calls that genuinely need a human, and keeps token use low across long projects. - **~92% less per-turn token overhead**: A performance-optimized evolution of GSD with a dramatically reduced prompt weight. - **MCP-backed project state**: Durable project memory that persists across sessions using the Model Context Protocol. - **Auto-resume across /compact**: Survives Claude's context compaction. Pick up right where you left off. - **Single-install plugin**: Install directly inside Claude Code with one command: /plugin install. ## How it works: Describe what you want, then ship it Tell Buildomator the software you want. It runs the whole lifecycle (plan, orchestrate, verify, ship) and only stops to ask about the decisions that need a human. You get real planning and testing without reading every line of code. ### 1. Install Run these inside a Claude Code session. ``` /plugin marketplace add buildomator/marketplace /plugin install bm@buildomator /reload-plugins ``` ### 2. Start a project or quick task ``` /bm:new-project # describe what you want; it becomes a roadmap /bm:ddd # start with user-facing docs; implementation follows /bm:quick # knock out one small, well-defined task ``` ### 3. Drive the lifecycle Run automatically or step through manually. ``` /bm:autonomous # run all phases end-to-end automatically /bm:next # advance to the next logical step ``` Autonomous runs all phases end-to-end. Use /bm:next to navigate step-by-step, or switch manually between commands (plan, execute, verify, ship). ### 4. Granular commands When you need fine-grained control. ``` /bm:plan # break the work into a phased roadmap /bm:execute # run each step in its own subcontext /bm:verify # check the change against the plan /bm:progress # see status across every step /bm:ship # close the milestone and prep the release ``` ### 5. Resume & navigate ``` /bm:resume-work # pick up where you left off (auto-restored via MCP) /bm:pause-work # save checkpoint before switching context ``` State persists automatically across sessions via MCP. Survives context compaction, power loss, and terminal resets. ## Core principles: Four principles. One mindset. 1. **Plan with clarity**: Every project starts with a structured plan, not a guess. 2. **Orchestrate in parallel**: Independent work runs as parallel agents, so complex builds move quickly. 3. **Verify every change**: Each change is checked against its plan before it becomes permanent. 4. **Ship with confidence**: From plan to production, every step is traceable and controlled. ## What builders say: Built for builders, by builders Example layout. Real testimonials coming soon. > "Finally, a tool that makes long-horizon Claude Code projects actually manageable. The per-turn token reduction alone changed how I plan work." > - Early-access user, backend engineer > "The /bm:plan → /bm:execute loop is exactly how structured AI coding should work. Every step traceable, every change verifiable." > - Open-source contributor Using Buildomator? Share your experience with the community. [Share feedback](https://github.com/buildomator/buildomator/discussions) ## Coverage: In the community Buildomator is new. Community features, articles, and mentions will appear here as they arrive. Written about Buildomator? [Let us know](https://github.com/buildomator/buildomator/issues) ## Support the project - [Star on GitHub](https://github.com/buildomator/buildomator) - [Join the discussion](https://github.com/buildomator/buildomator/discussions) - [Sponsor](https://github.com/sponsors/jnuyens) ## Footer Open source. Community driven. - [Buildomator on GitHub](https://github.com/buildomator/buildomator) --- Source: https://buildomator.com · GitHub: https://github.com/buildomator/buildomator