The 60-second pitch

Your AI assistant just wrote 200 lines. Some of them are bugs. Some don't match your patterns. Some skip tests.

/draft:review

Three stages, one command:

1. Validation — runs your tests, lints, type-checks, and surfaces real failures
2. Spec compliance — checks the diff against the agreed spec, not vibes
3. Code quality — flags hotspots, blast radius, and missing test coverage using a tree-sitter knowledge graph of your repo

Free. No API keys. No paid tier. No vendor lock-in. Catches the 3 bugs you missed before they hit your reviewer.

Demo coming soon — for now, watch the 8-minute walkthrough.

Install (30 seconds)

One command installs Draft into your agent. No clone, no config.

npx @drafthq/draft install <host>      # claude-code | cursor | codex | opencode

…or install the CLI once and reuse it:

npm install -g @drafthq/draft
draft install <host>
draft list                             # show every host + where it installs

Each host installs the way that host actually loads extensions — no manual steps after the command:

| Host | draft install … | What it does | |------|-------------------|--------------| | Claude Code | claude-code | Registers the plugin via claude plugin marketplace add + claude plugin install (user scope). Restart Claude Code. | | Cursor | cursor | Copies the plugin into ~/.cursor/plugins/local/draft/, writes .cursor-plugin/plugin.json, registers draft@draft-plugins in Cursor's plugin registry, and enables it. Restart Cursor (or Developer: Reload Window). Existing installs upgrade with draft install cursor --force. | | Codex | codex | Writes ./AGENTS.md, which Codex reads automatically. | | opencode | opencode | Writes ./AGENTS.md + ~/.agents/skills/draft/, both auto-discovered. |

Flags: --global / --project to pick scope, --dry-run to preview, --force to overwrite, --no-graph to skip the graph-engine fetch.

Then, in Claude Code (after restarting):

/draft:init       # 5-phase codebase analysis (one-time)
/draft:review     # ← run this on every branch before you push

Run /draft for the full command map.

Claude Code — native marketplace

/plugin marketplace add drafthq/draft
/plugin install draft

Cursor — from GitHub

Cursor requires .cursor-plugin/plugin.json; the draft install cursor command also registers the plugin via the shared Claude plugin registry that Cursor reads on many builds. To add from source instead, use Settings > Rules, Skills, Subagents > Rules > New > Add from Github:

https://github.com/drafthq/draft.git

GitHub Copilot

Copilot reads a committed instructions file — copy it directly (not a draft install host):

mkdir -p .github && curl -o .github/copilot-instructions.md \
  https://raw.githubusercontent.com/drafthq/draft/main/integrations/copilot/.github/copilot-instructions.md

Gemini

curl -o .gemini.md https://raw.githubusercontent.com/drafthq/draft/main/integrations/gemini/.gemini.md

Beyond /draft:review — 32 more commands

/draft:review is the wedge. Once Draft has indexed your repo, you also get spec-driven planning, TDD-enforced implementation, exhaustive bug hunting, deep architectural audits, and 32 more commands covering the full development lifecycle.

What You Get

| Command | What It Does | |---------|--------------| | /draft | Overview, intent mapping, and command reference | | /draft:plan | Router for planning, architecture, and track management | | /draft:ops | Router for operations, deployment, incident, and lifecycle | | /draft:docs | Router for authoring and documentation workflows | | /draft:discover | Router for discovery, debugging, investigation, and quality | | /draft:init | Analyze codebase, create context files + state tracking | | /draft:graph | Build / refresh the knowledge-graph snapshot | | /draft:new-track | Collaborative spec + plan with AI | | /draft:decompose | Module decomposition with dependency mapping | | /draft:implement | TDD workflow with checkpoints | | /draft:coverage | Code coverage report (target 95%+) | | /draft:review | 3-stage review (validation + spec compliance + code quality) | | /draft:deep-review | Enterprise-grade module lifecycle and ACID audit | | /draft:bughunt | Exhaustive 14-dimension defect discovery with taint tracking | | /draft:learn | Discover coding patterns, update guardrails | | /draft:adr | Architecture Decision Records | | /draft:status | Show progress overview | | /draft:revert | Git-aware rollback | | /draft:change | Handle mid-track requirement changes | | /draft:debug | Structured debugging: reproduce, isolate, diagnose, fix | | /draft:quick-review | Lightweight 4-dimension code review | | /draft:deploy-checklist | Pre-deployment verification with rollback triggers | | /draft:upload | Pre-upload handoff gate (review, HLD, checklist, validators) | | /draft:testing-strategy | Test plan design with coverage targets | | /draft:tech-debt | Technical debt analysis across 6 dimensions | | /draft:standup | Git activity standup summary (read-only) | | /draft:incident-response | Incident lifecycle: triage, communicate, mitigate, postmortem | | /draft:documentation | Technical docs: readme, runbook, api, onboarding | | /draft:integrations | External system exports and syncs (jira preview / create) | | /draft:jira | Unified Jira workflows (preview / create / review) | | /draft:tour | Interactive architecture mentorship and codebase walk-through | | /draft:impact | ROI analytics tracking friction and timeline metrics | | /draft:assist-review | Summarize intent and highlight structural PR risks for reviewers |

See full command reference →

Recommended next step after install: run /draft:init to index your repo, then /draft:review on any branch with AI-generated changes. Once you've seen what it catches, explore the rest.

Built-in Code Intelligence

Draft is powered by a local knowledge graph engine (codebase-memory-mcp) that gives every command precise structural context — module boundaries, call graphs, dependencies, hotspots. It's 100% local (no API key, no SaaS), fetched during draft install (best-effort; --no-graph to skip), with first-use fetch as a fallback.

/draft:graph                                  # build / refresh the snapshot
scripts/tools/graph-impact.sh --file src/auth/login.go
# → blast radius: which files, which symbols, which tests/docs/configs

| Capability | What it provides | |---|---| | Multi-language extraction | Tree-sitter + LSP-grade resolution across 159 languages, 100% local | | Call graph | Callers/callees with confidence signals so review/bughunt can weight findings | | Impact analysis | Blast-radius with file-class dimension (code/test/doc/config) — answers "what breaks if I change this?" | | Cycle detection | Flags circular call dependencies before they bite | | Hotspot ranking | Fan-in score so high-risk symbols get extra scrutiny | | Incremental indexing | git-aware, content-based; only changed code re-indexes | | Track impact memory | metadata.json.impact snapshots each completed track's blast radius — /draft:new-track flags overlap with recent work |

The graph powers /draft:graph and /draft:impact, enriches /draft:bughunt and /draft:review, and is consumed by skills via core/shared/graph-query.md. The engine is installed via scripts/fetch-memory-engine.sh; the deterministic shell helpers live under scripts/tools/.

Deterministic helper tools

Skills also call into shell helpers under scripts/tools/ for mechanical work — git metadata, file classification, test-framework detection, hotspot ranking, freshness checks, ADR indexing, and live graph queries (graph-callers.sh, graph-impact.sh, hotspot-rank.sh, cycle-detect.sh, mermaid-from-graph.sh). All emit JSON or markdown, follow a uniform exit-code contract, and degrade gracefully when their input source is unavailable.

How It Works

┌─────────────────────────────────────────────────────────────┐
│                        /draft:init                          │
│    5-phase codebase analysis + signal detection + state     │
│  architecture.md + .ai-context.md + .state/ (freshness,    │
│                   signals, run memory)                      │
└────────────────────────────┬────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────┐
│                      /draft:new-track                       │
│            AI-guided spec.md + phased plan.md               │
└────────────────────────────┬────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────┐
│                     /draft:implement                        │
│              RED → GREEN → REFACTOR (repeat)                │
└────────────────────────────┬────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────┐
│                      /draft:review                          │
│        Three-stage review (validation + spec + quality)     │
└─────────────────────────────────────────────────────────────┘

         /draft:init refresh  ←── incremental: only re-analyze
                                   files with changed hashes

Context output modes (/draft:init)

/draft:init packages your architecture context in one of two modes, selected automatically by repo size (override with DRAFT_INIT_MODE):

• monolith (default for small repos, tiers 1–2) — a single graph-primary architecture.md is the source of truth; .ai-context.md is the token-optimized AI view derived from it.
• okf (default for larger repos, tiers 3+) — an OKF concept taxonomy under draft/wiki/ is the source of truth (one concept per file, cross-links form the graph), .ai-context.md becomes the navigable index root (Synopsis + Concept Map), and architecture.md is demoted to a generated rendered view. An optional self-contained offline HTML viewer ships under draft/wiki/web/.

Both modes produce the same product.md, tech-stack.md, workflow.md, guardrails.md, tracks, and .state/ — only the architecture packaging differs.

Full workflow →

Why Draft?

AI tools are fast but unstructured. Draft applies Context-Driven Development to impose clear boundaries: explicit context, phased execution, and built-in verification, ensuring outputs remain aligned, predictable, and production-ready.

product.md       →  "Build a task manager"
tech-stack.md    →  "React, TypeScript, Tailwind"
architecture.md  →  Comprehensive: 10-section graph-primary engineering reference, Mermaid diagrams (source of truth). Mature brownfield projects with strong existing agent docs (CLAUDE.md, INVARIANTS.md, etc.) receive early Context Quality Audit, graph fidelity dashboard, and explicit Relationship + Gaps sections (no blind duplication).
.ai-context.md   →  200-400 lines: condensed from architecture.md (token-optimized AI context)
.state/          →  freshness hashes, signal classification, run memory (incremental refresh)
spec.md          →  "Add drag-and-drop reordering"
plan.md          →  "Phase 1: sortable, Phase 2: persist"

Each layer narrows the solution space. By the time AI writes code, decisions are made.

Incremental refresh: After initial setup, /draft:init refresh uses stored file hashes and signal classification to only re-analyze what changed — no full re-scan needed.

Read methodology →

Contributing

Source of Truth

1. core/methodology.md — Master methodology
2. skills/<name>/SKILL.md — Command implementations
3. integrations/ — Auto-generated (don't edit)

Update Workflow

# 1. Edit core/methodology.md or skills/*/SKILL.md
# 2. Rebuild integrations
./scripts/build-integrations.sh

Full architecture →

Star History