CoDD: Coherence-Driven Development — Claude Code plugin for cross-artifact change impact analysis.
$ npx -y skills add yohey-w/codd-dev --agent claude-code
Picture a normal day on a real codebase:
On a large project — or on code an AI wrote for you — this kind of drift is everywhere, and "is everything still consistent?" becomes impossible to answer by hand.
CoDD turns that question into something a machine can answer.
It builds a map of how everything in your project connects — which requirement is implemented by which code, which code is covered by which test, which config value switches which behavior. Once CoDD has that map, it can do three things for you:
flowchart LR
R["Requirements"] <--> D["Design"]
D <--> C["Code"]
C <--> T["Tests"]
R -. "one connected map" .- T
The map works both ways: edit the code, and CoDD points to the design docs and requirements that are now out of date; add a requirement, and it points to the code and tests that need to change. That two-way consistency is the "Co" (coherence) in CoDD.
Those tools make the AI smarter. CoDD makes the AI's input smarter. It hands the AI the exact map of what a change touches — with evidence for each connection — instead of letting it guess from whatever files happen to be open. And CoDD's verification is built so it can't lie: an empty test suite, a build script that's secretly just true, a missing test report — all come back red, never a quiet green.
pip install codd-dev # needs Python 3.10+ · the command is `codd`
codd version # confirm the install
greenfield, fix, generate, implement, brownfield, …). The default is claude --print; override it with --ai-cmd "<command>" or ai_command: in codd.yaml (e.g. to use Codex CLI).init, scan, check, doctor, measure, impact, validate, plan (show), contract verify, dag verify, lexicon, version, …) — they run as-is.Drop CoDD into an existing repo, build the connection map, and run the health check. Everything here works without an AI CLI and is copy-paste-ready.
pip install codd-dev
cd path/to/your-repo
codd init myproject --language python # create the CoDD config (codd/codd.yaml)
codd scan # build the "connection map" from your code
codd check # health check — start here
codd check is the front door: it runs doctor (config diagnostics) → dag verify (connection completeness) → contract verify (artifact contract) in one shot. Drill into details with codd doctor, or see metrics with codd measure.
From here, pick the entry point that matches where you are — build from scratch, recover design from existing code, or fix something already shipping.
codd greenfieldWrite what you want as a plain Markdown file, then let CoDD build the whole thing unattended (design → code → tests → verify, fixing problems as it goes):
codd greenfield --requirements docs/requirements/requirements.md \
--project-name myapp --language python
It saves a checkpoint after every step, so codd greenfield --resume continues where it left off. Add --dry-run to preview the plan without calling the AI, or --ntfy-topic <topic> to get progress pings on your phone.
Language coverage today: unattended greenfield is empirically validated end-to-end on all six top languages — Python, TypeScript, JavaScript, Java, C++, and C# — from the same neutral requirements spec (a multi-module calculator library, 15–20 files). Validation is execution-based: each run's verifiable behaviors are cross-checked against the language's native test report (pytest / vitest / surefire / ctest / dotnet-trx), and a run that does not converge is stopped honestly rather than reported as a false pass. Repetition is not uniform — TypeScript and Python have ≥2-of-3 independent green runs; JavaScript, Java, C++, and C# have n≥1. This validates the pipeline's cross-language wiring and convergence machinery at library scale; it does not yet claim enterprise-scale complexity (the subject of a follow-on real-spec campaign).
The same one-command pipeline (codd greenfield --requirements FILE) also ships as three transparent, adaptable vehicles you can read and tweak: a shell script (examples/greenfield_autopilot.sh), a Claude Code workflow (examples/claude_workflows/codd-greenfield.js), and a skill (codd skills install codd-greenfield --target both).
codd init + codd scanCoDD reads your existing code, works out the design behind it, and keeps the two in sync from then on:
codd init # set CoDD up in your repo
codd scan # build the connection map from your code
codd brownfield . # recover design docs, compare them to reality, list the gaps
codd fixcodd fix "the login error messages are confusing"
CoDD finds the design docs your request touches, updates them, then carries the change through design → code → tests → verify. It only edits the files the map says are involved, and if the final check fails, it rolls back exactly those files — nothing else.
With no argument, codd fix is a legacy mode that picks up your failing tests or CI and repairs them (codd fix --ci / --local / --dry-run).
Within one automatic repair session, the built-in LLM engine carries related prior hypotheses, actual applied changes, and verification results into the next attempt, for both Codex and Claude. Private records live under .codd/repair_history/ (owner-only and Git-ignored); prompts receive at most 16,000 characters of history excerpts, with truncation and unread originals identified. Missing observations—including model/token metadata an adapter does not expose—stay unknown. Existing retry limits and safety gates remain unchanged; this does not automatically switch to a larger model.
| Job | What it does | Main commands |
|---|---|---|
| 1. Build from intent | Turns requirements into design options, then code and test scaffolding. The AI proposes; you choose (you stay in control). | greenfield, plan, generate, implement, fix |
| 2. Trace every change (the core) | A connection map across requirements, design, code, config, data, and tests. Change one thing and CoDD shows the ripple — sorted into Green (safe to auto-fix), Amber (please review), Gray (just so you know) — with the reason for each link. | scan, impact, propagate, diff |
| 3. Verify for real | Runs your actual build and tests so they can't fake a pass, and traces any failure back to the artifact that caused it. | verify, check, coverage |
These three feed each other in a loop: building decides what changes, tracing finds where it lands, verifying proves it holds — and every commit you make sharpens the map for next time. (Want the full story? See docs/explainer.md.)
The most-used commands, grouped by purpose. Run codd --help for the complete list and codd <command> --help for the details of any one.
| Purpose | Commands |
|---|---|
| Build | greenfield (unattended) · plan (derive tasks) · generate (design/tests) · implement (code) · assemble (stitch fragments) · fix (from a phenomenon) |
| Trace | scan (update the map) · impact (ripple of a diff) · propagate (code → design) · diff (implementation vs requirements) · watch (file changes) · drift (URL/design drift) |
| Verify | verify (build + tests) · check (health — start here) · doctor (config diagnostics) · dag (completeness gate) · contract (artifact contract) · coverage (coverage gate) · measure (metrics) · policy (policy rules) · validate (frontmatter) |
| Elicit & shape | elicit (find spec gaps) · lexicon (industry checklists) · brownfield (recover from code) · extract / require / restore (facts → design) · qc (evaluate criteria) · preflight (task pre-check) |
| Integrate & ship | mcp-server (MCP) · skills (install skills) · hooks (Git hooks) · deploy (deploy) · e2e (E2E generation) |
Older CoDD had knowledge of specific languages and frameworks (Go, Python, Next.js…) baked into its core. v3.0 took all of that out of the core and moved it into swappable description files ("profiles") plus small adapters:
codd verify runs against your project, live.In short: one core now serves Next.js, Django, FastAPI, Rails, Go services, and more — and anyone can add support without touching it.
codd mcp-server exposes CoDD to any MCP client (such as Claude Code or Cursor) over stdio. Configure it in Claude Code with:
"mcpServers": { "codd": { "command": "codd", "args": ["mcp-server"] } }
codd skills install <name> --target both drops ready-made skills (e.g. the greenfield autopilot) into ~/.claude/skills/ and ~/.agents/skills/. Use codd skills list to see them and codd skills remove <name> to uninstall.
View @yohey-w’s profileCommand your AI army like a feudal warlord. Run 10 AI coding agents in parallel — Claude Code, OpenAI Codex, GitHub Copilot, Kimi Code, OpenCode, Cursor, Antigravity — orchestrated through a samurai-inspired hierarchy with zero coordination overhead.
@yohey-wcodd-dev is a Claude Code plugin with 11 hand-picked skills, indexed on Flowy in the Skill Authoring category. Install it with the command on its page. It includes codd-assemble, codd-evolve, codd-fable-consult. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.
Is this plugin yours?
Claim it with GitHubSubmit a pluginPromote it