Buildomator
5.0 Superpowers integration New Now with VibeDrift protection 4.9.2 Craft Skill Catalog: skills on demand

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 How it works

New in Buildomator 4

Now with VibeDrift protection.

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. Never installed, never run. 100% native.

THE STACK

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.

Context overhead, every turn

Skill bodies run in forked sub-agents and state lives in MCP, so the parent context stays clean.

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.

Superpowers on GitHub
GSD core 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.

GSD core on GitHub
VibeDrift 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.

Read more VibeDrift on npm
workspace.json 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.

workspace.json spec on GitHub
ASD-STE100 ideas ported

Docs in plain English

A prose check borrowed from Simplified Technical English, 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.

ASD-STE100 website
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. Licenses get checked too: copyleft is flagged for you to decide, unlicensed skills are blocked. Nothing adds tokens unless it is deemed appropriate for that specific task.

New in 4.9.2 as the Craft Skill Catalog. Starts with SEO and DuckDB; more are added as we go.

skills.sh

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.

  • Plan with intent

    Architect features before writing code. Clear plans, fewer surprises.

  • Design for change

    Well-structured code and clean interfaces that age gracefully.

  • Test everything

    Automated tests by default. Confidence with every change.

  • Review always

    Every change reviewed. Quality isn't optional, it's built in.

  • 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. 01

    Plan with clarity

    Every project starts with a structured plan, not a guess.

  2. 02

    Orchestrate in parallel

    Independent work runs as parallel agents, so complex builds move quickly.

  3. 03

    Verify every change

    Each change is checked against its plan before it becomes permanent.

  4. 04

    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 →

COVERAGE

In the community

Buildomator is new. Community features, articles, and mentions will appear here as they arrive.

Written about Buildomator? Let us know →