spec-kit-command-cursor — Summary

spec-kit-command-cursor (madebyaris) is a Spec-Driven Development toolkit for Cursor IDE (v5.1) that ships 18 slash commands, 6 background/foreground subagents, 5 skills, and a hooks file — making it the most component-rich single framework in the batch. It introduces several architectural innovations unique in this corpus: async background subagents with a parent-that-continues model, subagent trees (orchestrator → implementers → verifiers), file-conflict detection via sdd.touchedFiles declarations to prevent parallel-edit collisions, checkpoint-based resume (execution-checkpoint.json) for interrupted parallel runs, and downstream propagation (marking stale docs when specs change via /evolve). The framework uses Cursor-specific features including .cursor/hooks.json (2 hooks: subagentStop, stop), .cursor/agents/ (subagent definitions), .cursor/skills/ (5 skill packs), and .cursor/sandbox.json (granular network access). It can be distributed as a Cursor Marketplace plugin via .cursor-plugin/. Version 5.1, 182 stars, active as of May 2026.

Differs from seeds: Most similar to superpowers in its subagent-driven development pattern, but explicitly targets Cursor's async agent runtime rather than Claude Code's Task tool. Compared to spec-kit (GitHub), this adds 6 subagents, 5 skills, 2 hooks, parallel execution with DAG scheduling, and deep-research capability — all absent from the seed. Compared to kiro, it replicates the three-phase spec workflow (requirements/design/tasks) but replaces Kiro's IDE-native hooks with Cursor's hook system. No MCP dependency.

spec-kit-command-cursor — Overview

Origin

Created by madebyaris (Aris) for Cursor IDE. Explicitly frames itself as a Cursor-native spec-driven development system (v5.1, optimized for Cursor 3.2+ agent runtime). 182 GitHub stars, 1 contributor. First public release adapted spec-kit concepts for Cursor's command format; v5.1 adds async subagents, parallel DAG execution, checkpoints, and the Cursor 3.2 Agents Window worktree integration.

Philosophy (From README)

"Spec-Driven Development for Cursor IDE. Create specifications before code. Plan-approve-execute for all operations."

"Async Subagents — Background subagents (is_background: true) let the parent agent continue working while long tasks run."

"Subagent Tree — Subagents spawn their own subagents: orchestrator → implementers → verifiers."

"Deep Research — Multi-pass external investigation with web search, documentation deep-dives, real-world validation, and confidence scoring (/research --deep)."

Key Design Choices

1. Async background agents: sdd-implementer and sdd-orchestrator run as background subagents, allowing the parent Cursor session to continue other work while tasks execute.

2. Subagent tree pattern: sdd-orchestrator (background) spawns sdd-implementer (background) per task, which then spawns sdd-verifier (foreground) for post-implementation completeness checks. Three tiers of agents.

3. File conflict detection: Tasks declare sdd.touchedFiles — the orchestrator checks for overlapping file sets before dispatching parallel batches, preventing two agents from editing the same file simultaneously.

4. Checkpoint + resume: execution-checkpoint.json tracks completed tasks so /execute-parallel --resume can restart after interruption without re-running completed work.

5. Downstream propagation: /evolve marks downstream documents as stale when a spec changes, preventing agents from implementing based on outdated design docs.

6. Hooks for observability: .cursor/hooks.json fires subagentStop and stop hooks that log session and subagent completion events to files, providing an audit trail.

7. Cursor Marketplace plugin packaging: .cursor-plugin/plugin.json makes the framework distributable as a Cursor IDE plugin.

Antipatterns Named

• Using /execute-parallel when simple single-agent execution is sufficient
• Spawning more than maxParallelImplementers (default 4) simultaneously
• Using Cursor's built-in /multitask for SDD roadmap work (recommended for independent prompts only)

spec-kit-command-cursor — Architecture

Distribution

• Cursor commands pack installed by cloning and copying to .cursor/
• Also distributable as Cursor Marketplace plugin via .cursor-plugin/
• Language: Shell/JavaScript (hooks); Markdown (commands, skills, agents)
• Install: git clone + cp -r .cursor/ <project>/.cursor/

Directory Tree

.cursor/
  commands/
    _shared/agent-manual.md
    brief.md
    research.md
    specify.md
    plan.md
    tasks.md
    generate-prd.md
    sdd-full-plan.md
    implement.md
    execute-task.md
    execute-parallel.md
    evolve.md
    refine.md
    upgrade.md
    audit.md
    generate-rules.md
    pecut-all-in-one.md
  agents/
    sdd-explorer.md
    sdd-planner.md
    sdd-implementer.md
    sdd-verifier.md
    sdd-reviewer.md
    sdd-orchestrator.md
  skills/
    sdd-research/SKILL.md
    sdd-planning/SKILL.md
    sdd-implementation/SKILL.md
    sdd-audit/SKILL.md
    sdd-evolve/SKILL.md
  hooks.json
  hooks/
    sdd-log-subagent-stop.py
    sdd-log-session-stop.py
  sandbox.json
  worktrees.json
  rules/

.sdd/
  config.json          # settings.maxParallelImplementers etc.
  guidelines.md
  templates/
  FULL_PLAN_EXAMPLES.md
  ROADMAP_FORMAT_SPEC.md
  TEAM_SETUP_GUIDE.md
  archive/

.cursor-plugin/
  plugin.json          # Cursor Marketplace plugin manifest

specs/
  active/
    {task-id}/
      feature-brief.md
      spec.md
      plan.md
      tasks.md
  todo-roadmap/
    {project-id}/
      roadmap.json
      dag.json
      execution-checkpoint.json
      tasks/{task-id}.json

Required Runtime

• Cursor IDE 3.2+
• Python 3 (for hooks: sdd-log-subagent-stop.py, sdd-log-session-stop.py)

Target AI Tools

Cursor IDE (primary). Commands use .cursor/ format.

spec-kit-command-cursor — Components

Slash Commands (17 in .cursor/commands/ + _shared/)

Planning Commands

Execution Commands

Maintenance Commands

Subagents (6, in .cursor/agents/)

Skills (5, in .cursor/skills/)

Hooks (2, from .cursor/hooks.json)

Config Files

spec-kit-command-cursor — Uniqueness and Positioning

Differs from Seeds

Most similar to superpowers in its multi-tier subagent pattern, but explicitly Cursor-native rather than Claude Code cross-platform. Compared to kiro (seed), this replicates the three-phase spec workflow but replaces Kiro's IDE-native hooks with Cursor's hooks.json system and adds a parallel DAG executor. Compared to spec-kit (GitHub), this framework is vastly more complex: 17 commands (vs 9), 6 subagents (vs 0), 5 skills (vs 9 skills but different architecture), 2 hooks (vs 18), and introduces async background agents, file-conflict detection, and checkpoint-resume — all absent from the seed. The parallel-fan-out orchestration with sdd.touchedFiles conflict detection is unique in the entire batch and would only appear in a framework designed for genuinely parallel, multi-file code generation.

Distinctive Positioning

1. File-conflict detection in parallel dispatch: sdd.touchedFiles declarations and set-overlap checking before batch construction — prevents two implementer agents from editing package.json simultaneously.
2. Checkpoint + resume: Interrupted parallel runs can resume from execution-checkpoint.json without re-running completed tasks.
3. Downstream propagation via /evolve: Stale-marking of docs when specs change prevents agents from implementing based on outdated plans.
4. Deep research mode with confidence scoring: /research --deep performs multi-pass web investigation with a confidence rating — more sophisticated than basic web search.
5. Background async agents: is_background: true on implementers lets the Cursor parent session stay responsive, approaching a true daemon-like execution model.

Observable Failure Modes

1. Cursor-only lock-in: Deep reliance on Cursor-specific features (is_background, Agents Window, .cursor/ path) makes migration to Claude Code or Codex non-trivial.
2. 1 contributor, no team adoption evidence: Sophisticated orchestration patterns (DAG, file conflict, checkpoint) that have not been battle-tested at scale.
3. Worktree optional, hooks required: The Python hook scripts require Python 3 in PATH — missing Python silently skips audit logging.
4. Roadmap.json format complexity: The ROADMAP_FORMAT_SPEC.md + dag.json structure is non-trivial to generate correctly by hand; errors in task dependencies may cause deadlock.