A knowledge graph that maps your repo. Spec-driven planning. Three-stage review. Twenty-eight commands, one plugin, free forever — for Claude Code, Cursor, Copilot, Antigravity, and Gemini.
Knowledge graph engine. 14 deterministic helpers. Track-level impact memory. Confidence-tagged call edges. View full changelog →
Without structure, AI makes assumptions, chooses arbitrary approaches, and produces code that doesn't fit your architecture.
Guesses at requirements instead of asking clarifying questions
Picks random technical approaches without considering your stack
Produces code that doesn't match existing patterns or conventions
Skips verification and claims completion without proof
Draft ships a knowledge graph engine that maps every module, call, dependency, and hotspot in your codebase. Six query modes. No daemon. No external service. Try the queries below — these are real outputs from running Draft against itself.
graph --query --file core/methodology.md --mode impact
Tree-sitter parsers for Go, Python, TS/JS, C/C++ · ctags fallback for Java/Rust/Ruby/Swift · Atomic incremental builds via per-module SHA-256
How the engine works →Most tools cover one corner of AI-assisted development. Draft brings methodology, codebase intelligence, and verification together in one plugin.
| Draft | Cursor / Copilot / Aider | Sourcegraph / GitNexus | ChatPRD / specStory | |
|---|---|---|---|---|
| Spec-driven planning | Specs & phased plans before code | No | No | Yes |
| Knowledge graph engine | Built-in tree-sitter, 6 query modes | Indexes only | Yes (separate service) | No |
| Three-stage code review | Validation · spec compliance · quality | Inline diff suggestions | No | No |
| Bug discovery | 14-dimension sweep + taint tracking | Per-file hints | No | No |
| ACID-style audits | Module lifecycle deep-review | No | No | No |
| Multi-IDE | Claude, Cursor, Copilot, Antigravity, Gemini | Each tool, separately | Editor extensions | Web-only mostly |
| Persistent context | Git-tracked spec/plan/architecture | Session-bound | Index, not artifacts | App-bound |
| Price | Free, MIT, no telemetry | Subscription | SaaS | Subscription |
Comparison reflects Draft 2.4 vs. publicly-documented features of named alternatives as of April 2026. Draft is the open-source plugin you install once and own forever.
Stop re-explaining your codebase to AI.
/draft:init generates an architecture reference once. Every subsequent agent interaction starts with full context. New tracks load only what's relevant.
Spec-driven planning + ACID-grade audits.
Every track ships with a reviewable spec, a phased plan, and three-stage code review. Module audits enforce atomicity, consistency, isolation, and durability.
Knowledge graph + 14 deterministic helpers.
Tree-sitter parsers for 9 languages. Atomic incremental builds. Confidence-tagged call edges. Track-level impact memory. Skills delegate mechanical work to JSON-emitting shell tools.
/draft:init — your codebase, fully mappedOne command performs a 5-phase deep analysis of your entire codebase. Every future interaction is grounded in this understanding.
Directory structure, build files, API definitions, interface/type files. Signal classification categorizes every source file into 11 categories (routes, services, auth, models, state, jobs, persistence, tests, config...) to drive adaptive analysis depth.
Entry points, orchestrator initialization, registry/registration code, dependency injection, module system, import graph. Maps how components find and connect to each other.
End-to-end data flows, core module implementations, concurrency model, safety checks. Traces invariants, validation, auth gates. Identifies state machines and consistency boundaries.
External dependencies, test infrastructure, configuration mechanisms, existing documentation. Maps the full operational envelope of your system.
Cross-reference, completeness validation, pattern identification, Mermaid diagram generation. Produces architecture.md (28 sections + 5 appendices) and derives .ai-context.md (200-400 lines, token-optimized).
SHA-256 hashes of every analyzed file. /draft:init refresh only re-analyzes files with changed hashes — no full re-scan.
11-category signal classification. Detects structural drift on refresh (e.g., auth files added for the first time).
Phases completed, unresolved questions, resumable checkpoints. Interrupted runs resume where they left off.
/draft:new-track
Collaborative intake — AI asks one question at a time, contributes expertise, surfaces risks. Builds spec progressively with citations from DDD, Clean Architecture, OWASP.
/draft:implement
RED → GREEN → REFACTOR. Production robustness patterns enforced (atomicity, isolation, durability, idempotency, fail-closed, resilience). Property-based testing, observability prompts, contract testing at service boundaries.
/draft:review
3-stage review with STRIDE threat modeling, SAST tool integration, breaking change detection, context-specific checks (crypto, DB, API, config, UI).
/draft:bughunt
14-dimension sweep with taint tracking, dependency/supply chain security, algorithmic complexity analysis, mutation testing awareness. Only HIGH/CONFIRMED confidence reported.
Deep codebase analysis generating a comprehensive engineering reference with 28 sections + 5 appendices, Mermaid diagrams, data state machines, and consistency boundaries. Derives a 200-400 line machine-optimized .ai-context.md for all AI agents. Classifies files into 11 signal categories for adaptive analysis depth.
RED → GREEN → REFACTOR cycle. Production robustness patterns enforced: atomicity, isolation, durability, idempotency, fail-closed, resilience. Property-based testing, observability prompts, contract testing at service boundaries.
Automated validation + spec compliance + code quality. STRIDE threat modeling for new endpoints. Context-specific checks (crypto, DB, API, config, UI). SAST tool integration. Adversarial pass on zero findings.
AI as expert partner — asks one question at a time, contributes patterns, risks, trade-offs. Builds spec progressively with citations from DDD, Clean Architecture, OWASP.
Systematic defect discovery across 14 dimensions: correctness, reliability, security, performance, UI responsiveness, concurrency, state management, API contracts, accessibility, configuration, tests, dependency/supply chain security, algorithmic complexity, and i18n/l10n. Severity-ranked with file:line locations. Only HIGH/CONFIRMED confidence — false-positive elimination and taint tracking built in.
Module lifecycle audit evaluating atomicity, isolation, durability, fail-closed behavior, and idempotency. Enterprise-grade production pattern enforcement.
Scans your codebase for recurring patterns (3+ occurrences). Discovers conventions to skip and anti-patterns to always flag. Every quality command updates guardrails.md after each run — your codebase teaches Draft what to enforce, and false positives disappear over time.
Tree-sitter parsers for Go, Python, TS/JS, C/C++ · ctags fallback for Java/Rust/Ruby/Swift. Six query modes — callers, impact, hotspots, modules, cycles, mermaid. Atomic incremental builds via per-module SHA-256 hashing. Call edges carry confidence markers (direct vs inferred); impact queries break results down by code/test/doc/config. Powers /draft:impact, enriches /draft:bughunt and /draft:review.
Each completed track records its blast radius in metadata.json — files touched, modules affected, downstream count, by-category breakdown. /draft:new-track reads recent tracks' impact during context load and surfaces overlap warnings before you even write a spec.
Skills delegate mechanical work to 14 shell tools under scripts/tools/ — git metadata, file classification, hotspot ranking, cycle detection, freshness checks, ADR indexing, test-framework detection, and more. Uniform JSON output and exit-code contract; graceful degradation when input is missing.
Monorepo federation with service discovery and dependency graphs. Jira integration (Track → Epic, Phase → Story, Task → Sub-task). Architecture Decision Records with full lifecycle. Git-aware task/phase/track-level revert. Mid-track change management with impact analysis.
Every markdown file goes through commit → review → merge before a single line of code is written. By the time implementation starts, the entire team has already agreed on what to build.
Tech lead runs /draft:init. Team reviews architecture, tech stack, and workflow via PR.
Lead runs /draft:new-track. Team reviews requirements and task breakdown via PR.
Lead runs /draft:decompose. Team reviews module boundaries and API surfaces via PR.
/draft:jira-create pushes epics and stories to Jira. Developers pick up stories with full context.
Every developer has spec.md, plan.md, and .ai-context.md. Quality tools verify completeness.
Works with your existing tools. Zero switching cost.
# Install from marketplace
/plugin marketplace add mayurpise/draft
/plugin install draft
# Start using
/draft:initPrerequisites: Claude Code CLI, Git, Node.js 18+
# Cursor > Settings > Rules > New > Add from Github:
https://github.com/mayurpise/draft.git
# Then use:
@draft init
@draft new-trackCursor natively supports .claude/ plugin structure
# Download copilot-instructions.md
mkdir -p .github && curl -o .github/copilot-instructions.md \
https://raw.githubusercontent.com/mayurpise/draft/main/integrations/copilot/.github/copilot-instructions.mdWorks in VS Code, JetBrains, Neovim
# Install globally
mkdir -p ~/.gemini/antigravity/skills
git clone https://github.com/mayurpise/draft.git ~/.gemini/antigravity/skills/draft
# Bootstrap
curl -o ~/.gemini.md https://raw.githubusercontent.com/mayurpise/draft/main/integrations/gemini/.gemini.md# Add bootstrap to your project
curl -o .gemini.md https://raw.githubusercontent.com/mayurpise/draft/main/integrations/gemini/.gemini.md/draft:init performs a 5-phase codebase analysis — not a diagram of intent, a map of reality.
Directory structure, entry points, request/response flows with actual file:line references.
State machines per domain object. Storage topology across cache, DB, event log, archive.
End-to-end write/read paths with consistency boundaries and failure recovery matrix.
Critical invariants: data safety, security, concurrency, ordering, idempotency.
Step-by-step guides: "Add a new endpoint", "Add a new model" — file-by-file instructions.
SHA-256 freshness hashes, 11-category signal classification, resumable run memory. Incremental refresh only re-analyzes what changed.
Dense tables, YAML frontmatter, flat sections. Token-efficient — minimal prose, maximum signal. Consumed by all Draft commands and external AI tools.
Prose paragraphs, annotated Mermaid diagrams, onboarding framing. Source of truth — all mutations happen here. For engineers, leads, and PR reviewers.
Human-defined constraints plus auto-discovered conventions and anti-patterns. Quality commands read this file, skip known patterns, and flag violations — then update it after every run. Your codebase teaches Draft what to enforce.
Draft speaks different languages to different roles — but the value compounds across your entire organization.
IC / Senior / Staff
TDD enforcement, 14-dimension bug hunting, architecture discovery with Mermaid diagrams, pattern learning. Write code that fits your system because Draft knows your system.
EM / Director
Review specs before code exists. PR-reviewable planning artifacts. Team alignment through documents, not meetings. Quality gates at every phase boundary.
PM / TPM
Readable specs anyone can review. Jira integration with auto story points. Status tracking across tracks. Know what's being built before it's built.
CTO / VP Eng / CISO
FAANG-level engineering practices at zero cost. ACID compliance audits, Architecture Decision Records, monorepo federation. Maturity Level 4/5. MIT licensed, no vendor lock-in.
Hobbyist / Indie / Student
Architecture discovery turns any project into a documented system. Bug hunting catches what you'd never find manually. Free, open source, MIT license.
Draft codifies the engineering culture of Google, Amazon, and Stripe into an AI-assisted workflow.
| Rank | Practice | Draft Implementation | Industry Equivalent | Companies |
|---|---|---|---|---|
| 1 | Design-First Engineering | spec.md & plan.md per track | Amazon PR/FAQ, Google Design Docs | Google, Amazon, Stripe, Uber |
| 1 | Monorepo / Shared Context | /draft:index federation | Unified codebase, dependency graphing | Google, Meta, Twitter |
| 2 | Test-Driven Development | /draft:implement RED-GREEN-REFACTOR | TDD / CI Gates | Netflix, Pivotal |
| 3 | Structured Code Review | /draft:review 3-stage | Google Critique system | Google, Meta |
| 3 | Architecture Decision Records | /draft:adr + architecture.md | Immutable ADRs | Spotify, AWS, GitHub |
| 4 | Bug Bashes | /draft:bughunt 14 dimensions | Scheduled team testing sessions | Microsoft, Game Studios |
| 5 | Service Catalog | product.md + tech-stack.md | Internal Developer Platform | Spotify, Lyft |
Free forever. Open source, MIT licensed.
Host tool costs apply (Claude Code, Copilot, etc.)
Free preview, then paid tiers
Free tier, then Pro/Business
Free tier, then paid
Draft is a free, open-source plugin that adds Context-Driven Development to AI coding agents. It provides 28 commands covering spec-driven planning, TDD enforcement, 3-stage code review, 14-dimension bug hunting, and architecture discovery for Claude Code, Cursor, GitHub Copilot, Antigravity IDE, and Gemini.
Yes, Draft is completely free and open source under the MIT license. There are no paid tiers, no usage limits, and no vendor lock-in. The only costs are from the host AI tools you use (Claude Code, Copilot, etc.).
Draft supports Claude Code, Cursor, GitHub Copilot, Antigravity IDE, and Gemini. It integrates natively with each platform using their respective configuration formats — slash commands for Claude Code and Cursor, copilot-instructions.md for Copilot, and .gemini.md for Gemini and Antigravity.
For Claude Code, run /plugin marketplace add mayurpise/draft then /plugin install draft. For Cursor, add the GitHub repo via Settings > Rules. For Copilot, download copilot-instructions.md into your .github directory. Each platform takes under 30 seconds to set up.
Context-Driven Development is a methodology where AI coding agents operate from persistent, file-based project context rather than ephemeral chat. Draft analyzes your codebase to generate architecture docs, then enforces a spec-first workflow: specifications and plans are written and reviewed before any code is generated.
Yes. Running /draft:init performs a 5-phase analysis of your existing codebase, generating architecture documentation, AI context files, and signal classifications. It works with any language, framework, or project structure — brownfield or greenfield.
Draft is not an AI coding tool — it is a methodology layer that runs on top of existing AI agents. While tools like Cursor or Copilot generate code, Draft ensures that code follows approved specifications, passes TDD gates, and fits your architecture. It adds structure and quality gates, not another AI model.
Minimal. After installation, run /draft:init and it automatically analyzes your codebase and generates all necessary configuration files (product.md, tech-stack.md, architecture.md, etc.). You can customize these files afterward, but the defaults work out of the box.
Yes. The /draft:index command provides monorepo federation — it discovers services, builds dependency graphs, and aggregates context across multiple packages or services. Each service gets its own context while maintaining a unified root-level view.
Yes. /draft:jira-preview generates a Jira export file mapping tracks to epics, phases to stories, and tasks to sub-tasks with auto-generated story points. /draft:jira-create pushes these issues to Jira via MCP.