DonnyClaude turns Claude Code into a build loop with deterministic verification gates, so “done” actually means done.

Anyone who has run an agentic coding session knows the moment. The model grinds for ten minutes, prints a confident “Done! ✅,” and you open the file to find the tests never ran, the function is half written, or the thing it swore it verified was never executed. The agent is not lying on purpose. It simply cannot tell the difference between finished work and a fluent sentence claiming the work is finished.

That gap is the entire problem. A language model grading its own output is a model writing fiction about itself. “Looks good to me” is not a gate. It is a vibe. And once you have felt an autonomous run plow through three phases on top of a broken first one, you stop trusting “looks good” forever.

DonnyClaude is what I built to close that gap. It installs with one command, npx donnyclaude, and reshapes Claude Code into a workflow whose defining feature is the opposite of self assessment: deterministic verification.

The idea: take the verdict away from the model

In most agent setups, the same model that writes the code also decides whether the code is good. DonnyClaude splits those jobs and then refuses to trust either of them on faith.

The generator never grades its own work. A separate, deliberately skeptical verifier actually runs the code and checks whether the goal was achieved. And beneath even the verifier sits a deterministic engine gate that parses the real pass or fail status from disk, so the final verdict cannot drift from the truth. A phase ships only when its recorded status is literally passed. Not "the model thinks it passed." Passed, read from a file, by code that does not have opinions.

That single design choice changes how it feels to use. You can hand it a roadmap and walk away, because the loop stops cold the moment something breaks instead of confidently building on a cracked foundation.

Four disciplines in one config

The deterministic gate is the headline, but it only works because three other things are in place. The four disciplines that decide whether an AI coding setup is a toy or a tool usually live scattered across blog posts and private dotfiles. DonnyClaude assembles all four.

Prompt engineering. 48 specialized agents and 94 slash command skills, each one a deliberately engineered prompt with a single responsibility and a minimal tool grant. Planners, reviewers, researchers, verifiers, agents that fix builds, each named and scoped so the right prompt runs for the right job, instead of one overloaded system prompt trying to do everything at once.

Context engineering. Every nontrivial task writes its state to disk under .planning/: requirements, roadmap, per phase plans, summaries, verification reports. That means context survives /clear and survives new sessions. Subagents each receive a curated slice of that context rather than the entire transcript, and the Context7 MCP feeds in live library docs so the model codes against current APIs rather than stale training data.

Harness engineering. Under the agents runs the Donny engine, a deterministic Node CLI that handles the things a language model should never guess at: plan dependency graph validation, frontmatter schemas, requirement coverage, secret scanning, phase completion. Subagents are tiered by cost, heavier models for planning and verification, lighter ones for mechanical work, so spend stays proportional to the task. Hooks enforce formatting, guards, and state integrity on every single turn.

Loop engineering. The unit of work is a loop: discover the next phase, plan it, execute it with subagents running in parallel waves, verify it, ship it, repeat. Run one phase by hand, or hand the whole roadmap to autonomous mode and let it advance unattended, knowing the verifier and the engine gate are standing between it and a false “done.”

What actually lands on your machine

One command installs the lot, and then Claude itself walks you through your first project:

• 94 skills (the Donny workflow plus utilities and language packs)
• 48 specialized agents
• Coding and writing rules for 13 languages, loaded automatically every session
• 29 hooks for formatting, guards, and state integrity
• A curated MCP setup (Context7 for live docs, Playwright for the browser)
• The Donny engine and its workflow library

Everything lands in ~/.claude/. Existing settings are preserved, never clobbered. If you do not already have Claude Code, the installer sets it up for you. The only hard requirement is Node 20 or newer.

A first run looks like this:

npx donnyclaude
/donny-init            # research, then requirements, then roadmap
/donny-plan-phase 1    # plan a phase, with dependency and requirement gates
/donny-execute-phase 1 # build it, with subagents and atomic commits
/donny-verify-work 1   # conversational UAT
/donny-ship            # open a PR once verification actually passes

/donny-progress shows where you are at any time. /donny-autonomous runs the whole roadmap hands off.

What it is not

I want to be straight about the boundaries. This is opinionated, and it is built specifically for Claude Code, so if your workflow lives somewhere else, this is not for you. The Donny engine began as a fork of the GSD workflow engine and has since diverged substantially, rebuilt around deterministic verification gates, model tiers, and a research path that is safe for subagents to use. It is MIT licensed, it is young, and I would rather you tell me where it breaks than tell me it is perfect.

Try it, then tell me where it breaks

If you have ever watched an agent declare victory over code that does not run, this is the config I wanted in that moment.

npx donnyclaude

The repo is here: https://github.com/d0nmega/donnyclaude. If the deterministic verification idea resonates, a star helps it reach the next person who is tired of being lied to by a robot. And if it falls over on your project, open an issue. That is the fastest way to make it better.