Multi-IDE Support

Part VI: Enterprise · Chapter 20

4 min read

Draft is not locked to a single AI coding tool. The methodology — the skills, agents, templates, and procedures — exists as markdown and bash, independent of any platform. A build pipeline transforms these source files into platform-specific integration formats. The result: every supported IDE gets the same methodology, with minor syntax adaptations.

Claude Code (Native)

Claude Code is Draft's native environment. The plugin is installed directly via the marketplace:

/plugin marketplace add mayurpise/draft
/plugin install draft

All 25 commands are available as /draft:* slash commands. Skills are loaded from the .claude-plugin/plugin.json manifest, which points to the skills/ directory. Each skill's SKILL.md file is read at invocation time, giving Claude Code direct access to the full methodology without any transformation.

The 7 specialized agents (Architect, Debugger, Planner, RCA, Reviewer, Ops, Writer) are referenced as @architect, @debugger, etc., and resolved from core/agents/.

Cursor

Cursor natively supports the .claude/ plugin structure, making it a near-identical experience to Claude Code. Installation is through Cursor's settings:

Cursor > Settings > Rules, Skills, Subagents > Rules > New > Add from Github
https://github.com/mayurpise/draft.git

Commands use @draft syntax: @draft init, @draft new-track, @draft implement. The same plugin.json, the same skill files, the same agent definitions — no separate build step required.

GitHub Copilot

Copilot does not have a plugin system that can read skill files at runtime. Instead, Draft uses a .github/copilot-instructions.md file — a single, large generated file (15,000+ lines) that encodes the entire Draft methodology inline.

This file is produced by the build pipeline (scripts/build-integrations.sh) and includes:

• All 25 skill definitions (minus frontmatter, plus syntax transforms)
• All core reference files (methodology, knowledge base, shared procedures, templates, agent definitions)
• Quality disciplines, communication style, and proactive behaviors
• Intent mapping for natural language triggers

Two key syntax transformations apply:

Source Syntax	Copilot Syntax	Example
/draft:command	draft command	/draft:implement becomes draft implement
@architect, @debugger, etc.	@workspace	All agent references become @workspace

Installation is a single curl command that drops the generated file into the project:

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

Gemini

Gemini uses a .gemini.md bootstrap file that instructs Gemini where to find Draft's skill files. Rather than inlining all content (as Copilot requires), the bootstrap points to the skills directory and lets Gemini read files as needed.

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

Antigravity IDE

Antigravity IDE supports global skill installation. Draft is cloned to a central location and configured via a global .gemini.md bootstrap:

# Clone to global skills directory
git clone https://github.com/mayurpise/draft.git \
  ~/.gemini/antigravity/skills/draft

# Configure bootstrap
echo 'Skill Locations:
/Users/you/.gemini/antigravity/skills/draft/skills' >> ~/.gemini.md

This makes Draft available across all projects without per-project setup.

The Build Pipeline

The transformation from source skills to platform-specific integrations is handled by scripts/build-integrations.sh, a ~700-line bash script that is the critical path for multi-IDE support.

The pipeline works as follows:

1. Skill ordering — A SKILL_ORDER array defines the 25 skills and their generation order. This order is independent of the alphabetical order in plugin.json.
2. Frontmatter extraction — Each skill's YAML frontmatter (name: and description:) is validated. The body is extracted via extract_body(), which strips the frontmatter delimiters.
3. Body format validation — The body must follow a strict format: blank line, # Title heading, blank line, then content. The build skips the first 3 body lines when inlining (the title is replaced by the integration's section header).
4. Syntax transformation — Platform-specific transforms are applied: /draft:command becomes draft command for Copilot, agent references become @workspace.
5. Core file inlining — 22 core reference files (methodology, shared procedures, templates, agents) are inlined into the output, each wrapped in <core-file> tags.
6. Verification — verify_output() checks minimum line count (>1000), completeness sentinel (DRAFT_BUILD_COMPLETE), and that no untransformed syntax remains.

The build is atomic: output is written to a temporary file, verified, then moved to the final location. A failed verification deletes the temp file and exits with an error, leaving the previous output intact.

Choosing Your IDE

All supported IDEs receive the same Draft methodology. The differences are operational, not functional:

Factor	Claude Code / Cursor	Copilot	Gemini / Antigravity
Setup	Plugin install	Copy one file	Bootstrap file or global clone
Command syntax	/draft:command	draft command	Natural language
Agent references	@architect, etc.	@workspace	As configured
Skill loading	On-demand from files	Pre-inlined in one file	Bootstrap + file read
Updates	/plugin update	Re-download file	git pull

The methodology is identical. The context files are identical. The plans, specs, architecture documents, and tracks are identical regardless of which IDE produced them. A team can have one developer using Claude Code and another using Copilot — both work on the same draft/ directory with full compatibility.