dobby

dobby

Kevin Wolf's agentic engineering kit for Claude Code, packaged as a plugin. dobby doesn't make Claude Code smarter — it makes it disciplined: the main thread stays an architect that frames, asks, decides, and reviews but never writes code, while four worker agents do the hands-on work. Every change is implemented, code-reviewed, and verified by separate agents before it counts as done.

Install

/plugin marketplace add kvnwolf/dobby
/plugin install dobby@dobby

Or with vercel-labs/plugins: npx plugins add kvnwolf/dobby.

Then start your first session from any project:

/dobby:scope <what you want to build>

Prerequisites: the ctx7 CLI (the researcher agent fetches current library docs through it), and vp (vite-plus) on PATH if you want the post-edit check hook to do anything.

The mental model

Two roles, never mixed:

• The architect (your main conversation) — interrogates you until the task has zero ambiguity, plans, dispatches workers, reviews what comes back, and owns every decision. If you ever see the main thread grepping around or editing files during kit stages, that's a bug in the kit.
• The workers (custom agents, addressed as dobby:<name>) — each runs with its own model and effort, tuned to its job:

Agent	Role	Model
researcher	Explore code, fetch current docs (ctx7), resolve unknowns	Opus / medium
implementor	Write the code for one scoped task	Fable 5 / xhigh
reviewer	Code-review a task's diff, pass/fail verdict	Opus / high
verifier	Prove the task works against the running app	Sonnet / high

The payoff: your context stays clean for thinking, implementation quality is enforced by independent review, and "done" means proven against the running app, not "the code looks right".

The lifecycle

A work session moves through six stages. Each stage ends by telling you which command to type next — nothing advances until you type it. Handoffs are typed on purpose: typed entry is what applies each stage's own model and effort (an auto-invoked skill would ride the previous stage's override):

/dobby:scope        ground the goal in the codebase, create STATE.md
      │
/dobby:interview    resolve EVERY ambiguity, one question at a time
      │
/dobby:research     current docs + unknowns, via researchers     (skipped when no external tech)
      │
/dobby:spec         the build plan, printed in full — you approve it
      │
/dobby:execute      waves of implement → review → verify (the trifecta)
      │
/dobby:wrap         human smoke test, docs/ADRs, STATE.md disposed
      │
/dobby:commit       branch, commit, push, PR

Side paths, available at any point:

• /dobby:prototype — when a decision can't be settled with words, interview/research hand off to a throwaway prototype you can play with, then resume.
• /dobby:diagnose — when something breaks during execute (or any time), a disciplined hypothesis-driven debugging loop.
• /dobby:dispatch — the whole architect/worker machinery for a task too small to deserve a session.

Your first session — end-to-end walkthrough

One concrete feature, carried through every stage: adding CSV export to an admin users table. Follow along to see what each command does, what you'll see, and what it leaves behind.

1. Scope

/dobby:scope add a CSV export button to the admin users table

The architect creates STATE.md at your repo root (the session's shared doc) and dispatches a dobby:researcher to ground the goal: where the users table lives, which conventions the project uses, what the domain glossary and ADRs say. You don't wait on grepping — a worker does it.

You'll see: a short grounded summary ("the table is src/admin/users/, it uses the shared DataTable, exports don't exist anywhere yet"), then the suggestion to type /dobby:interview next (or jump straight to research or spec).

Artifact: STATE.md with a filled ## Exploration section.

2. Interview

The architect now interrogates you — one focused question at a time, each informed by what the researcher found, each with a recommended answer:

Should the export respect the current filters and search, or always dump the full table? (Recommended: respect filters — that's what the visible data implies.)

Expect questions about edge cases you hadn't considered: empty results, the 50k-row tenant, who's allowed to export, date formatting, column selection. This is the kit's core bet: misalignment is the most common failure mode, so the interview doesn't stop until there's zero ambiguity — and it will refuse to end on a vague "anything else?" if open threads remain.

If a question can't be settled verbally ("which of these two layouts feels right?"), the interview sends you to type /dobby:prototype and resumes after you've played with the variants.