Next-Generation Specification Driven Development Tool with 27 Agents for 7 AI Coding Platforms + MCP Integration (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Windsurf, Codex, Qwen Code)
npm install itda-sddNext-Generation Specification Driven Development Tool





English | νκ΅μ΄ | Documentation | npm
---
> π€ 7 AI Coding Agents Γ π 31 Specialized Skills Γ βοΈ Constitutional Governance
ITDA (μλ€ - "connection/binding") is a comprehensive Specification Driven Development (SDD) framework that synthesizes the best features from 6 leading frameworks into a production-ready tool for multiple AI coding agents.
| Challenge | ITDA Solution |
| ------------------------- | ---------------------------------------------- |
| π Fragmented AI tools | 7 agents, 1 unified workflow |
| π Ambiguous requirements | EARS format with 5 patterns |
| π Lost traceability | 100% ReqβDesignβCodeβTest mapping |
| β οΈ Quality inconsistency | 9 Constitutional Articles + Phase -1 Gates |
| π Brownfield challenges | Delta specs + Change management |
``bashInstall and initialize in 30 seconds
npx itda-sdd init
π¦ More installation options
`bash
Global installation
npm install -g itda-sddInitialize for specific AI agent
itda init --copilot # GitHub Copilot
itda init --cursor # Cursor IDE
itda init --gemini # Gemini CLI
itda init --codex # Codex CLI
itda init --qwen # Qwen Code
itda init --windsurf # Windsurf IDE
`---
π What's New in v7.0.0
$3
Complete separation of document types for better organization and clarity.
#### Storage Structure
| Document Type | Storage Path | Naming Pattern |
|---------------|--------------|----------------|
| Requirements |
storage/specs/ | {feature}-requirements.md |
| Design | storage/design/ | {feature}-design.md |
| Tasks | storage/tasks/ | {feature}-tasks.md |
| Validation | storage/validation/ | {feature}-validation-report.md |`
storage/
βββ specs/ # Requirements only
β βββ auth-requirements.md
βββ design/ # Design documents only
β βββ auth-design.md
βββ tasks/ # Tasks only
β βββ auth-tasks.md
βββ validation/ # Validation reports
βββ auth-validation-report.md
`#### Updated All 7 Agent Platforms
All prompts and templates updated with correct storage paths:
- Claude Code, GitHub Copilot, Cursor, Gemini CLI, Codex CLI, Qwen Code, Windsurf
#### Test Results
- Unit Tests: 4,827 passing β
- Integration Tests: 660 passing β
---
π What's New in v6.2.0
$3
New quality gates for systematic review at each development stage.
#### Review Gates
| Gate | Description | Prompt |
|------|-------------|--------|
| Requirements Gate | EARS format, priority, acceptance criteria validation |
#sdd-review-requirements |
| Design Gate | C4 model, ADR, component design validation | #sdd-review-design |
| Implementation Gate | Code quality, test coverage, naming conventions | #sdd-review-implementation |
| Full Review | All gates in sequence | #sdd-review-all |`bash
Use review prompts in your AI agent
#sdd-review-requirements user-auth
#sdd-review-design user-auth
#sdd-review-implementation user-auth
`#### Workflow Dashboard
- Progress Visualization: Real-time progress across 5 stages
- Blocker Management: Add, resolve, and track blockers
- Transition Recording: Record and analyze stage transitions
- Sprint Planning: Task prioritization with velocity tracking
`bash
itda dashboard show # Show workflow status
itda dashboard start # Start new workflow
itda dashboard blocker # Manage blockers
`#### Traceability System
- Auto-Extraction: Automatic ID extraction from code, tests, commits
- Gap Detection: Detect missing design, implementation, or tests
- Matrix Storage: YAML-based traceability matrix with history
`bash
itda-trace extract # Extract traceability IDs
itda-trace gaps # Detect gaps
itda-trace matrix # Generate matrix report
`#### Enterprise Features
| Feature | Description |
|---------|-------------|
| Error Recovery | Auto error analysis with remediation steps |
| Rollback Manager | File/commit/stage/sprint level rollback |
| CI Reporter | GitHub Actions integration |
| Phase -1 Gate | Constitutional compliance before all stages |
| Steering Sync | Auto-update steering files on version change |
---
π What's New in v5.9.0
$3
Major update with enterprise-ready features for large-scale projects and monorepo support.
#### Workflow Flexibility (Phase 1)
- 3 Workflow Modes:
small (bug fixes), medium (features), large (architecture)
- Auto-detection: Smart mode selection based on feature name patterns
- itda-release: New CLI for release automation with CHANGELOG generation`bash
Generate CHANGELOG from commits
itda-releaseShow detected mode for a feature
itda-workflow mode --detect "feat: user authentication"
`#### Monorepo Support (Phase 2)
- Package Registry:
steering/packages.yml for dependency management
- Dependency Graphs: Mermaid diagram generation for visualization
- Coverage Tracking: Per-package test coverage reporting#### Constitution Level Management (Phase 3)
- 3 Enforcement Levels:
critical (blocking), advisory (warnings), flexible (suggestions)
- Level-aware Validation: Different enforcement based on article importance
- Project Overrides: Custom levels per project type| Level | Articles | Behavior |
|-------|----------|----------|
| Critical | CONST-001, 002, 003, 005, 009 | Blocks workflow |
| Advisory | CONST-004, 006, 007 | Warnings only |
| Flexible | CONST-008 | Suggestions |
#### Project Configuration (Phase 4)
-
itda-config: New CLI for configuration management
- Schema Validation: v2.0 schema with AJV validation
- Auto-migration: Upgrade v1.0 configs to v2.0`bash
itda-config validate # Validate project.yml
itda-config migrate # Migrate to v2.0
itda-config show # Show effective config
`#### Orchestrator Integration
5 new built-in skills for programmatic access:
| Skill | Category | Usage |
|-------|----------|-------|
|
release-manager | release | CHANGELOG generation |
| workflow-mode-manager | workflow | Mode detection & management |
| package-manager | configuration | Package & dependency analysis |
| constitution-level-manager | validation | Level-aware validation |
| project-config-manager | configuration | Config validation & migration |`javascript
const { workflowModeSkill } = require('itda-sdd/src/orchestration');const result = await workflowModeSkill.execute({
action: 'detect',
featureName: 'fix: minor bug'
});
console.log(result.detectedMode); // 'small'
`---
π What's New in v5.8.0
$3
Major update to CodeGraph MCP integration with expanded language support and new features.
#### 16 Language Support (NEW: Kotlin, Swift, Scala, Lua)
- Python, TypeScript, JavaScript - Full AST analysis
- Rust, Go, Java, PHP, C# - Enterprise language support
- C, C++, HCL (Terraform) - System and infrastructure code
- Ruby - Dynamic language support
- Kotlin (NEW) -
.kt, .kts files with classes, interfaces, functions
- Swift (NEW) - .swift files with classes, structs, protocols
- Scala (NEW) - .scala, .sc files with traits, objects
- Lua (NEW) - .lua files with functions, table assignments#### File Watching & Auto Re-indexing
-
codegraph-mcp watch - Real-time file monitoring
- Debounce configuration - Configurable delay (default: 1.0s)
- Community detection - Optional --community flag after re-index#### Enhanced MCP Tools (14 Tools)
| Category | Tools |
|----------|-------|
| Graph Query |
query_codebase, find_dependencies, find_callers, find_callees, find_implementations, analyze_module_structure |
| Code Retrieval | get_code_snippet, read_file_content, get_file_structure |
| GraphRAG | global_search, local_search |
| Management | suggest_refactoring, reindex_repository, execute_shell_command |#### Security & Performance (v0.7.3)
- Security fixes: Path traversal and command injection protection
- Connection pooling: Improved database performance
- Caching: Faster repeated queries
`javascript
// Use CodeGraph MCP integration
const { CodeGraphIntegration } = require('itda-sdd');const cg = new CodeGraphIntegration('/path/to/repo');
await cg.indexRepository();
// File watching (v0.7.0+)
await cg.startWatch({ debounce: 2.0, community: true });
// Query codebase
const results = await cg.queryCodebase('authentication');
const callers = await cg.findCallers('UserService::login');
`---
π What's New in v5.6.0
$3
Major improvements based on analysis of GCC codebase (10+ million lines, 100,000+ files).
#### Large Project Analyzer
- Scale-aware analysis: Automatically detects project size and selects appropriate strategy
- Memory-efficient processing: Chunk-based processing with garbage collection for 100K+ files
- Multi-language support: JavaScript, TypeScript, C, C++, Python, Rust, Go, Java
- Giant function detection: Flags functions with 100+ (warning), 500+ (critical), 1000+ (extreme) lines
#### CodeGraph MCP Integration
- Deep code graph analysis: Integration with CodeGraph MCP for relationship analysis
- Call graph generation: Track callers and callees with configurable depth
- Impact analysis: Identify affected files when code changes
- Hotspot identification: Detect highly-connected entities (refactoring candidates)
#### Enhanced Complexity Analyzer
- Cyclomatic complexity: Standard decision-point counting
- Cognitive complexity: SonarSource-style readability measurement
- Severity levels: Ideal β Warning β Critical β Extreme thresholds
#### Rust Migration Generator
- Unsafe pattern detection: Identify C/C++ memory-unsafe patterns
- Migration priority scoring: Automatic prioritization for Rust migration
- Security component analysis: Flag security-critical code sections
`javascript
// Analyze enterprise-scale projects (100,000+ files)
const { LargeProjectAnalyzer, ComplexityAnalyzer } = require('itda-sdd');const analyzer = new LargeProjectAnalyzer('/path/to/gcc');
const result = await analyzer.analyze();
console.log(result.stats); // { totalFiles: 109073, ... }
// Calculate code complexity
const complexity = new ComplexityAnalyzer();
const score = complexity.calculateCyclomaticComplexity(code, 'javascript');
`$3
- π
--reference / -r Option - Reference multiple GitHub repositories for pattern analysis
- π Repository Analysis - Fetch metadata, structure, and key files via GitHub API
- ποΈ Pattern Detection - Clean Architecture, Hexagonal, DDD, Monorepo patterns
- π‘ Improvement Suggestions - Architecture and technology recommendations
- π Analysis Output - Saved to steering/references/github-references-YYYY-MM-DD.md`bash
Reference multiple repositories for improvement suggestions
itda init -r facebook/react -r vercel/next.js -r denoland/denoWith branch specification
itda init --reference tokio-rs/tokio@mainFull URL format
itda init --reference https://github.com/rust-lang/rust
`$3
- π Technology Stack Selection - Single, Multiple, Undecided, or Help me decide
- π€ Language Recommendation Engine - AI-powered suggestions based on app type, performance needs, team expertise
- π 10 Languages Supported - JS/TS, Python, Rust, Go, Java, C#, C++, Swift, Ruby, PHP
- π Dynamic tech.md - Language-specific templates with frameworks and tools
$3
- π Steering Auto-Update - Automatic project memory synchronization with 5 trigger types
- β
Steering Validator - Comprehensive validation for steering documents
- π Template Constraints - Enforce structure requirements with ThinkingChecklist
- π Quality Dashboard - A-F grade metrics with health status monitoring
- π Advanced Validation - Cross-artifact consistency, gap detection, traceability validation
- π― Phase 5 Integration - Unified access to all advanced features
$3
- π§ Codebase Intelligence - RepositoryMap, ASTExtractor, ContextOptimizer
- π Agentic Reasoning - ReasoningEngine, PlanningEngine, SelfCorrection
- β‘ Code Generation - CodeGenerator, CodeReviewer with multiple modes
- π Integrated Agent - Unified agent with all Phase 4 capabilities
`bash
Use advanced features via orchestrator
const { Phase5Integration, createIntegratedAgent } = require('itda-sdd');Quality dashboard
const dashboard = new QualityDashboard();
const metrics = await dashboard.collectMetrics(projectPath);Advanced validation
const validator = new AdvancedValidation();
const result = await validator.validateAll(projectPath);
`$3
- π WebSocket Real-time GUI - Live replanning updates with
itda-browser dashboard
- π GUI Quick Actions - Modal dialog for New Requirement, Validate Project, Export Report
- π GitHub Actions Integration - itda-action for CI/CD with ITDA validation
- π§ OpenAPI Converter - Convert OpenAPI 3.x/Swagger 2.x specs to ITDA format
- π Multi-language Templates - 7 language support (EN, JA, ZH, KO, ES, DE, FR)
- π€ Ollama Integration - Local LLM support with 9 model presets$3
- π§ Dynamic Replanning Engine - AI agents can now dynamically adjust plans when tasks fail
- π LLM Provider Abstraction - Multi-provider support (Copilot, Anthropic, OpenAI)
- π‘ Real-time Plan Monitoring - Detect failures, timeouts, and quality degradation
- π Alternative Path Generation - LLM-powered alternative strategies with confidence scoring
- π Replan History & Audit - Full audit trail with JSONL persistence and export
$3
- π Workflow Engine - New
itda-workflow CLI for stage management and metrics
- π Metrics Collection - Track time per stage, iteration counts, feedback loops
- π¬ Spike/PoC Stage - Stage 0 for research and prototyping before requirements
- π Code Review Stage - Stage 5.5 between implementation and testing
- π Retrospective Stage - Stage 9 for continuous improvement
- β
Stage Validation Guide - Checklists for stage transition validation$3
- π§ CLI Integration - Added CLI command references to all 8 Claude Code skills
- π Platform Documentation - CLI Commands section added to all 6 non-Claude platforms
$3
- π CodeGraphMCPServer Integration - 14 MCP tools for enhanced code analysis
- π§ GraphRAG-Powered Search - Semantic code understanding with Louvain community detection
- π 11 Agents Enhanced - Key agents now leverage MCP tools for deeper code analysis
Features
- π€ Multi-Agent Support - Works with 7 AI coding agents (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Codex CLI, Qwen Code, Windsurf)
- π§ Dynamic Replanning - AI agents dynamically adjust plans on failure with LLM-powered alternatives (v3.6.0+)
- π MCP Server Integration - CodeGraphMCPServer for advanced code analysis (v2.0.0)
- π Flexible Command Formats - Supports Markdown, TOML, and AGENTS.md formats
- π― 27 Specialized Skills (All Platforms) - 25 platform agents + 5 orchestrator built-in skills (v5.9.0)
- Claude Code: Skills API (25 skills + 5 built-in)
- GitHub Copilot & Cursor: AGENTS.md (official support)
- Other 4 agents: AGENTS.md (compatible format)
- π Constitutional Governance - 9 immutable articles + Phase -1 Gates for quality enforcement
- π EARS Requirements Generator - Create unambiguous requirements with 5 EARS patterns (v0.8.0)
- ποΈ Design Document Generator - Create C4 models and ADRs with traceability (v0.8.2)
- π Change Management System - Delta specifications for brownfield projects (v0.8.6)
- π Gap Detection System - Identify orphaned requirements and untested code (v0.8.7)
- π§ Auto-Updating Project Memory - Steering system maintains architecture, tech stack, and product context
- π Automatic Onboarding -
itda-onboard analyzes existing projects and generates steering docs (2-5 minutes)
- π Auto-Sync - itda-sync detects codebase changes and keeps steering docs current
- π Intelligent Code Analysis - itda-analyze provides quality metrics, complexity analysis, and technical debt detection
- π€ Team Collaboration - itda-share enables memory sharing, import/export, and multi-platform sync (v0.6.0)
- β
Constitutional Validation - itda-validate enforces 9 immutable governance articles with Phase -1 Gates (v0.7.0)
- β
Complete Traceability - Requirements β Design β Code β Tests mapping
- π Bilingual Documentation - All agent-generated documents created in both English and KoreanSupported AI Coding Agents
ITDA supports 7 AI coding agents, each with tailored configurations:
| Agent | Skills API | 27 Skills | Command Format | Command File Format | Installation Directory |
| ------------------ | -------------- | -------------- | ---------------- | ------------------------- | --------------------------------------------- |
| Claude Code | β
(27 skills) | β
|
/sdd-* | Markdown (.md) | .claude/skills/, .claude/commands/ |
| GitHub Copilot | β | β
(AGENTS.md) | /sdd-* | Prompt File (.prompt.md) | .github/prompts/, .github/AGENTS.md |
| Cursor IDE | β | β
(AGENTS.md) | /sdd-* | Markdown + AGENTS.md | .cursor/commands/, .cursor/AGENTS.md |
| Gemini CLI | β | β
(GEMINI.md) | /sdd-* | TOML + GEMINI.md | .gemini/commands/, GEMINI.md |
| Codex CLI | β | β
(AGENTS.md) | /prompts:sdd-* | Markdown + AGENTS.md | .codex/prompts/, .codex/AGENTS.md |
| Qwen Code | β | β
(AGENTS.md) | /sdd-* | Markdown + AGENTS.md | .qwen/commands/, .qwen/AGENTS.md |
| Windsurf IDE | β | β
(AGENTS.md) | /sdd-* | Markdown + AGENTS.md | .windsurf/workflows/, .windsurf/AGENTS.md |Notes:
- Skills API is exclusive to Claude Code
- All 7 platforms now support 27 skills via Skills API (Claude Code) or AGENTS.md (others)
- v5.9.0 added 5 built-in orchestrator skills (release, workflow, package, constitution-level, project-config)
- GitHub Copilot uses
.prompt.md extension per VS Code official documentation
- AGENTS.md: OpenAI specification, officially supported by GitHub Copilot & Cursor
- Gemini CLI uses TOML format + GEMINI.md integration---
Constitutional Governance
ITDA enforces 9 Constitutional Articles for quality assurance:
`bash
Validate constitutional compliance
itda-validate all
itda-validate constitution
itda-validate gates
itda-validate complexity
`9 Articles:
1. Library-First Principle - All features begin as independent libraries
2. CLI Interface Mandate - All libraries expose CLI functionality
3. Test-First Imperative - Tests written before code (80% coverage required)
4. EARS Requirements Format - 5 EARS patterns for unambiguous requirements
5. Traceability Mandate - 100% traceability: Requirements β Design β Code β Tests
6. Project Memory - Steering system maintains project context
7. Simplicity Gate - Maximum 3 sub-projects initially (Phase -1 Gate)
8. Anti-Abstraction Gate - Use framework APIs directly (Phase -1 Gate)
9. Integration-First Testing - Integration tests use real services (no mocks)
Phase -1 Gates: Pre-implementation validation checkpoints for Articles VII & VIII. See:
- steering/rules/constitution.md - Full constitutional text
- steering/rules/phase-gates.md - Approval process and active gates
- All other agents use Markdown format + AGENTS.md
Quick Start
$3
`bash
Initialize ITDA for your preferred agent
Claude Code (default) - 27 Skills (25 + 5 built-in)
npx itda-sdd init
npx itda-sdd init --claudeGitHub Copilot - 27 skills (AGENTS.md, official support)
npx itda-sdd init --copilotCursor IDE - 27 skills (AGENTS.md, official support)
npx itda-sdd init --cursorGemini CLI - 27 skills (GEMINI.md integration)
npx itda-sdd init --geminiCodex CLI - 27 skills (AGENTS.md)
npx itda-sdd init --codexQwen Code - 27 skills (AGENTS.md)
npx itda-sdd init --qwenWindsurf IDE - 27 skills (AGENTS.md)
npx itda-sdd init --windsurfOr install globally
npm install -g itda-sdd
itda init --claude # or --copilot, --cursor, etc.Onboard existing project (automatic analysis)
itda-onboardSynchronize steering docs with codebase
itda-sync
itda-sync --dry-run # Preview changes
itda-sync --auto-approve # Auto-apply (CI/CD)Analyze code quality (v0.5.0)
itda-analyze # Full analysis
itda-analyze --type=quality # Quality metrics only
itda-analyze --type=dependencies # Dependencies only
itda-analyze --type=security # Security audit
itda-analyze --output=report.md # Save reportShare project memories with team (v0.6.0)
itda-share export # Export memories to JSON
itda-share import memories.json # Import from teammate
itda-share sync --platform=copilot # Sync to specific platformValidate constitutional compliance (v0.7.0)
itda-validate constitution # Validate all 9 articles
itda-validate article 3 # Validate Test-First Imperative
itda-validate gates # Validate Phase -1 Gates
itda-validate complexity # Check complexity limits
itda-validate all -v # Full validation with detailsGenerate EARS requirements documents (v0.8.0)
itda-requirements init "User Authentication" # Initialize requirements doc
itda-requirements add # Add requirement interactively
itda-requirements list # List all requirements
itda-requirements validate # Validate EARS format
itda-requirements trace # Show traceability matrixGenerate design documents (v0.8.2)
itda-design init "User Authentication" # Initialize design document
itda-design add-c4 context # Add C4 Context diagram
itda-design add-c4 container --format plantuml # Add Container with PlantUML
itda-design add-adr "Use JWT for tokens" # Add Architecture Decision
itda-design validate # Validate design completeness
itda-design trace # Show requirements traceabilityBreak down design into tasks (v0.8.4)
itda-tasks init "User Authentication" # Initialize task breakdown
itda-tasks add "Database Schema" # Add task interactively
itda-tasks list # List all tasks
itda-tasks list --priority P0 # List critical tasks
itda-tasks update 001 "In Progress" # Update task status
itda-tasks validate # Validate task completeness
itda-tasks graph # Show dependency graphEnd-to-end traceability (v0.8.5)
itda-trace matrix # Generate traceability matrix
itda-trace matrix --format markdown > trace.md # Export to markdown
itda-trace coverage # Calculate coverage statistics
itda-trace coverage --min-coverage 100 # Require 100% coverage
itda-trace gaps # Detect orphaned requirements/code
itda-trace requirement REQ-AUTH-001 # Trace specific requirement
itda-trace validate # Validate 100% traceability (Article V)
itda-trace bidirectional # Bidirectional traceability analysis (v0.9.4)
itda-trace impact REQ-AUTH-001 # Impact analysis for requirement changes (v0.9.4)
itda-trace statistics # Comprehensive project statistics (v0.9.4)Change management for brownfield projects (v0.8.6)
itda-change init CHANGE-001 --title "Add authentication" # Create change proposal
itda-change validate CHANGE-001 --verbose # Validate delta specification
itda-change apply CHANGE-001 --dry-run # Preview changes
itda-change apply CHANGE-001 # Apply changes to codebase
itda-change archive CHANGE-001 # Archive to specs/
itda-change list --status pending # List pending changes
itda-change list --format json # List in JSON formatGap detection and coverage validation (v0.8.7)
itda-gaps detect # Detect all gaps
itda-gaps detect --verbose # Show detailed gap information
itda-gaps requirements # Detect orphaned requirements
itda-gaps code # Detect untested code
itda-gaps coverage # Calculate coverage statistics
itda-gaps coverage --min-coverage 100 # Require 100% coverage
itda-gaps detect --format markdown > gaps.md # Export gap report
`Documentation
Comprehensive guides are available in
docs/guides/:- Brownfield Tutorial - Step-by-step guide for managing changes in existing projects
- Delta Specification Guide - Format reference for change tracking
- Change Management Workflow - End-to-end workflow documentation
- Traceability Matrix Guide - Traceability system usage
- Video Tutorial Plan - Video content script
$3
During initialization, ITDA asks you to select a Project Type. This determines the workflow and features available:
#### Greenfield (0β1)
- What it is: Starting a new project from scratch
- Use cases:
- New application development
- Proof-of-concept projects
- Greenfield microservices
- Features enabled:
- Full 8-stage SDD workflow (Research β Monitoring)
-
/sdd-steering - Generate initial project memory
- /sdd-requirements - Create new requirements from scratch
- /sdd-design - Design architecture (C4 model + ADR)
- /sdd-tasks - Break requirements into tasks
- /sdd-implement - Implement features (test-first)
- /sdd-validate - Constitutional compliance checks
- Benefits:
- Clean start with best practices enforced
- Constitutional governance from day one
- Complete traceability from requirements to code#### Brownfield (1βn)
- What it is: Working with existing codebases
- Use cases:
- Adding features to existing applications
- Refactoring legacy code
- Migrating/modernizing systems
- Features enabled:
- Delta Specifications (ADDED/MODIFIED/REMOVED)
-
/sdd-change-init - Create change proposal
- /sdd-change-apply - Apply changes with impact analysis
- /sdd-change-archive - Archive completed changes
- change-impact-analyzer skill (Claude Code) - Automatic impact detection
- Reverse engineering: /sdd-steering analyzes existing code
- Benefits:
- Safe incremental changes with impact analysis
- Preserves existing architecture while improving incrementally
- Full audit trail of what changed and why#### Both
- What it is: Hybrid approach for complex scenarios
- Use cases:
- Monolith β Microservices migration (brownfield + greenfield services)
- Platform modernization (keep some, rebuild others)
- Multi-component systems with mixed maturity
- Features enabled:
- All Greenfield + Brownfield features
- Flexibility to choose workflow per component
- Mixed delta specs and greenfield specs in same project
- Benefits:
- Maximum flexibility for complex transformation projects
- Unified steering/governance across all components
- Single tool for entire modernization journey
Example Selection:
`text
? Project type:
β― Greenfield (0β1) β New projects
Brownfield (1βn) β Existing codebases
Both β Complex/hybrid scenarios
`$3
#### Claude Code (Skills API)
`text
your-project/
βββ .claude/
β βββ skills/ # 25 Skills API + 5 built-in (Claude Code exclusive)
β β βββ orchestrator/
β β βββ steering/
β β βββ requirements-analyst/
β β βββ ... (22 more)
β βββ commands/ # Slash commands (/sdd-*)
β βββ CLAUDE.md # Claude Code guide
βββ steering/ # Project memory (all agents)
β βββ project.yml # Project configuration (v0.2.1+)
β βββ structure.md # Architecture patterns
β βββ tech.md # Technology stack
β βββ product.md # Product context
β βββ memories/ # Persistent knowledge (v0.2.0+)
β β βββ architecture_decisions.md
β β βββ development_workflow.md
β β βββ domain_knowledge.md
β β βββ lessons_learned.md
β β βββ suggested_commands.md
β β βββ technical_debt.md
β βββ rules/
β βββ constitution.md # 9 Constitutional Articles
β βββ workflow.md # 8-Stage SDD workflow
β βββ ears-format.md # EARS syntax guide
βββ templates/ # Document templates (all agents)
βββ storage/ # Specs, changes, features (all agents)
`#### Other Agents (GitHub Copilot, Cursor, Gemini, etc.)
`text
your-project/
βββ .github/prompts/ # For GitHub Copilot (/sdd-*, .prompt.md)
β βββ sdd-steering.prompt.md # Prompt files use .prompt.md extension
β βββ sdd-requirements.prompt.md
β βββ ... (9 prompt files)
β βββ AGENTS.md # 27 skills definition (official support)
β OR
βββ .cursor/commands/ # For Cursor (/sdd-*, Markdown)
β βββ AGENTS.md # 27 skills definition (official support)
β OR
βββ .gemini/commands/ # For Gemini CLI (/sdd-*, TOML)
β β βββ sdd-steering.toml
β β βββ sdd-requirements.toml
β β βββ ... (6 TOML files)
β OR
βββ .codex/prompts/ # For Codex CLI (/prompts:sdd-*, Markdown)
β βββ AGENTS.md # 27 skills definition
β OR
βββ .qwen/commands/ # For Qwen Code (/sdd-*, Markdown)
β βββ AGENTS.md # 27 skills definition
β OR
βββ .windsurf/workflows/ # For Windsurf (/sdd-*, Markdown)
β βββ AGENTS.md # 27 skills definition
β
βββ GEMINI.md (root, for Gemini) # 27 skills integrated into existing file
βββ steering/ # Project memory (same for all)
β βββ project.yml # Project configuration (v0.2.1+)
β βββ memories/ # Persistent knowledge (v0.2.0+)
β β βββ architecture_decisions.md
β β βββ development_workflow.md
β β βββ domain_knowledge.md
β β βββ lessons_learned.md
β β βββ suggested_commands.md
β β βββ technical_debt.md
β βββ ... (structure.md, tech.md, product.md, rules/)
βββ templates/ # Document templates (same for all)
βββ storage/ # Specs, changes, features (same for all)
`Key Differences:
- Claude Code: 27 Skills (25 + 5 built-in) + commands (Markdown)
- GitHub Copilot: AGENTS.md (official support) + prompt files (
.prompt.md)
- Cursor: AGENTS.md (official support) + commands (Markdown)
- Gemini CLI: GEMINI.md integration (27 skills) + TOML commands (unique)
- Others: AGENTS.md (compatible) + Markdown commands
- All platforms: Same 27 skills, different implementation formatsUsage
$3
ITDA provides several CLI commands for project management:
`bash
Show version
itda --version
itda -vShow help
itda --helpShow comprehensive info
itda infoCheck project status
itda statusValidate constitutional compliance
itda validate
itda validate --verbose # Detailed output
itda validate --all # Validate all featuresInitialize ITDA (interactive)
itda initOnboard existing project (v0.3.0+)
itda-onboard
itda-onboard --auto-approve # Skip confirmation
itda-onboard --skip-memories # Skip memory initializationSynchronize steering docs with codebase (v0.4.0+)
itda-sync # Interactive mode
itda-sync --dry-run # Preview changes only
itda-sync --auto-approve # Auto-apply (CI/CD)Analyze code quality (v0.5.0+)
itda-analyze # Full analysis (quality + dependencies + security)
itda-analyze --type=quality # Code quality metrics only
itda-analyze --type=dependencies # Dependency analysis
itda-analyze --type=security # Security vulnerabilities
itda-analyze --output=report.md # Save report to file
itda-analyze --json # JSON outputShare project memories with team (v0.6.0+)
itda-share export # Export memories to JSON/YAML
itda-share export --output=memories.yaml # YAML format
itda-share import memories.json # Import and merge
itda-share import memories.json --strategy=theirs # Auto-accept
itda-share sync # Sync across AI platforms
itda-share sync --platform=cursor # Sync specific platform
itda-share status # Show sharing status
`#### itda-onboard
Automatically analyzes existing projects and generates steering documentation:
`text
π ITDA Onboarding WizardAnalyzing your project...
β
Project structure analyzed
β
Technology stack detected
- Node.js, TypeScript, React, Jest
β
Steering documents generated
- steering/structure.md (en + ko)
- steering/tech.md (en + ko)
- steering/product.md (en + ko)
β
Memories initialized (6 files)
β
Project configuration created
- steering/project.yml
β±οΈ Onboarding completed in 2.5 minutes
π‘ Next steps:
- Review generated steering docs
- Run: itda-sync to keep docs current
- Create requirements: /sdd-requirements [feature]
`Features:
- Automatic codebase analysis (package.json, directory structure)
- Technology stack detection (languages, frameworks)
- Bilingual steering docs generation (English + Korean)
- Memory system initialization (6 memory files)
- Project configuration (project.yml)
- 96% time reduction (2-4 hours β 2-5 minutes)
#### itda-sync
Detects codebase changes and keeps steering documents synchronized:
`text
π ITDA Steering SyncDetected changes:
π¦ Version: 0.3.0 β 0.4.0
β New framework: js-yaml@4.1.0
π New directory: bin/
? Apply these changes? (Y/n) Y
β
Updated steering/project.yml
β
Updated steering/tech.md (en + ko)
β
Updated steering/structure.md (en + ko)
β
Recorded change in memories/architecture_decisions.md
π Steering synchronized successfully!
`Features:
- Change detection (version, languages, frameworks, directories)
- Interactive mode (default): Show changes, ask confirmation
- Auto-approve mode (--auto-approve): CI/CD integration
- Dry-run mode (--dry-run): Preview only
- Bilingual updates (English + Korean together)
- Memory recording (audit trail)
Usage:
`bash
Interactive (default)
itda-syncPreview changes without applying
itda-sync --dry-runAuto-apply for CI/CD pipelines
itda-sync --auto-approve
`#### itda-share
Share and merge project memories across team members and AI platforms (v0.6.0+):
`text
π€ ITDA Memory ExportExport Summary:
File: team-memories.json
Format: json
Size: 1098.28 KB
Memories: 7 files
Agents: 1 platforms
`Features:
- Export: Share memories as JSON/YAML
- Import: Merge memories from teammates
- Sync: Synchronize across AI platforms
- Conflict Resolution: Interactive, auto-accept, keep-local, or merge with markers
- Status: Show installed platforms and memory counts
Usage:
`bash
Export memories
itda-share export
itda-share export --output=memories.yamlImport and merge
itda-share import colleague-memories.json
itda-share import memories.json --strategy=theirs # Auto-accept
itda-share import memories.json --strategy=ours # Keep local
itda-share import memories.json --strategy=merge # With markersPlatform sync
itda-share sync
itda-share sync --platform=cursorStatus check
itda-share status
`#### itda status
Shows the current state of your ITDA project:
`text
π ITDA Project Statusβ
ITDA is initialized
π Claude Code Skills: 27 installed (25 + 5 built-in)
Location: .claude/skills/
π§ Steering Context:
β
structure.md (updated: 2025-11-16)
β
tech.md (updated: 2025-11-16)
β
product.md (updated: 2025-11-16)
β
Constitutional Governance: Enabled
π Specifications: 3 documents
Latest specs:
- auth-requirements.md
- auth-design.md
- auth-tasks.md
π‘ Next steps:
- Review steering files in steering/
- Create requirements: /sdd-requirements [feature]
- Validate compliance: itda validate
`#### itda validate
Performs quick constitutional compliance checks:
- Article I: Library-First Principle (checks
lib/ directory)
- Article II: CLI Interface Mandate (checks for cli.ts files)
- Article IV: EARS Requirements Format (validates EARS patterns)
- Article VI: Project Memory (checks steering files)For comprehensive validation, use your agent's
/sdd-validate (or equivalent) command.$3
#### Claude Code
`bash
Generate project memory
/sdd-steeringCreate requirements
/sdd-requirements authenticationDesign architecture
/sdd-design authenticationBreak down into tasks
/sdd-tasks authenticationImplement feature
/sdd-implement authenticationValidate constitutional compliance
/sdd-validate authentication
`Skills (Auto-Invoked): Claude Code automatically selects the appropriate skill:
- "Review my code" β
code-reviewer skill
- "Create requirements for user login" β requirements-analyst skill
- "Design API for payment" β api-designer skill#### GitHub Copilot
`bash
Use # prefix for custom prompts
#sdd-steering
#sdd-requirements authentication
#sdd-design authentication
#sdd-tasks authentication
#sdd-implement authentication
#sdd-validate authentication
`#### Gemini CLI
`bash
Use / prefix for commands (TOML format)
/sdd-steering
/sdd-requirements authentication
/sdd-design authentication
/sdd-tasks authentication
/sdd-implement authentication
/sdd-validate authentication
`Note: Gemini CLI commands are defined in TOML format (
.toml files) instead of Markdown.#### Cursor IDE, Qwen Code, Windsurf
`bash
Use / prefix for commands (Markdown format)
/sdd-steering
/sdd-requirements authentication
/sdd-design authentication
/sdd-tasks authentication
/sdd-implement authentication
/sdd-validate authentication
`#### Codex CLI
`bash
Use /prompts: prefix
/prompts:sdd-steering
/prompts:sdd-requirements authentication
/prompts:sdd-design authentication
/prompts:sdd-tasks authentication
/prompts:sdd-implement authentication
/prompts:sdd-validate authentication
`27 Skills Overview (All Platforms)
Available on all 7 platforms via:
- Claude Code: Skills API (automatic invocation) + 5 built-in orchestrator skills
- GitHub Copilot & Cursor: AGENTS.md (official support, reference via
@agent-name)
- Gemini, Windsurf, Codex, Qwen: AGENTS.md (compatible format, natural language reference)$3
- orchestrator - Master coordinator for multi-skill workflows
- steering - Project memory manager (auto-updating context)
- constitution-enforcer - Governance validation (9 Articles + Phase -1 Gates)
#### Built-in Orchestrator Skills (v5.9.0)
- release-manager - CHANGELOG generation, version management
- workflow-mode-manager - Mode detection (small/medium/large)
- package-manager - Monorepo package & dependency analysis
- constitution-level-manager - Level-aware validation (critical/advisory/flexible)
- project-config-manager - Schema validation & migration
$3
- requirements-analyst - EARS format requirements generation
- project-manager - Project planning, scheduling, risk management
- change-impact-analyzer - Brownfield change analysis
$3
- system-architect - C4 model + ADR architecture design
- api-designer - REST/GraphQL/gRPC API design
- database-schema-designer - Database design, ER diagrams, DDL
- ui-ux-designer - UI/UX design, wireframes, prototypes
$3
- software-developer - Multi-language code implementation
$3
- test-engineer - Unit, integration, E2E testing with EARS mapping
- code-reviewer - Code review, SOLID principles
- bug-hunter - Bug investigation, root cause analysis
- quality-assurance - QA strategy, test planning
- traceability-auditor - Requirements β Code β Test coverage validation
$3
- security-auditor - OWASP Top 10, vulnerability detection
- performance-optimizer - Performance analysis, optimization
$3
- devops-engineer - CI/CD pipelines, Docker/Kubernetes
- cloud-architect - AWS/Azure/GCP, IaC (Terraform/Bicep)
- database-administrator - Database operations, tuning
- site-reliability-engineer - Production monitoring, SLO/SLI, incident response
- release-coordinator - Multi-component release management
$3
- technical-writer - Technical documentation, API docs
- ai-ml-engineer - ML model development, MLOps
Governance Articles
ITDA enforces 9 immutable constitutional articles:
1. Library-First Principle - Features start as libraries
2. CLI Interface Mandate - All libraries expose CLI
3. Test-First Imperative - Tests before code (Red-Green-Blue)
4. EARS Requirements Format - Unambiguous requirements
5. Traceability Mandate - 100% coverage required
6. Project Memory - All skills check steering first
7. Simplicity Gate - Maximum 3 projects initially
8. Anti-Abstraction Gate - Use framework features directly
9. Integration-First Testing - Real services over mocks
SDD Workflow (8 Stages)
`text
1. Research β 2. Requirements β 3. Design β 4. Tasks β
5. Implementation β 6. Testing β 7. Deployment β 8. Monitoring
`Each stage has:
- Dedicated skills
- Quality gates
- Traceability requirements
- Constitutional validation
EARS Requirements Format
`markdown
$3
WHEN user provides valid credentials,
THEN the system SHALL authenticate the user
AND the system SHALL create a session.
#### Scenario: Successful login
- WHEN user enters correct email and password
- THEN system SHALL verify credentials
- AND system SHALL redirect to dashboard
`Bilingual Documentation
All agent-generated documents are created in both English and Korean.
$3
- English: Reference/source documents (
.md)
- Korean: Translations (.ko.md)
- Skills: Always read English versions for work
- Code References: Requirement IDs, technical terms stay in English$3
Steering Context:
-
steering/structure.md + steering/structure.ko.md
- steering/tech.md + steering/tech.ko.md
- steering/product.md + steering/product.ko.mdSpecifications:
-
storage/specs/auth-requirements.md + storage/specs/auth-requirements.ko.md
- storage/design/auth-design.md + storage/design/auth-design.ko.md
- storage/tasks/auth-tasks.md + storage/tasks/auth-tasks.ko.md$3
1. English version generated FIRST (reference/source)
2. Korean version generated SECOND (translation)
3. Technical terms (REQ-XXX-NNN, EARS keywords, API endpoints) remain in English
4. Both versions maintained in sync
Delta Specifications (Brownfield)
`markdown
ADDED Requirements
$3
...
MODIFIED Requirements
$3
Previous: Email + password
Updated: Email + password + OTP
...
REMOVED Requirements
$3
Reason: Security policy change
`Example Usage
$3
`bash
1. Initialize
npx itda-sdd init2. Generate steering
/sdd-steering3. Create requirements
/sdd-requirements user-authentication4. Design architecture
/sdd-design user-authentication5. Break into tasks
/sdd-tasks user-authentication6. Implement
/sdd-implement user-authentication
`$3
`bash
1. Initialize with existing codebase
npx itda-sdd init2. Generate steering from existing code
/sdd-steering3. Create change proposal
/sdd-change-init add-2fa4. Impact analysis (automatic via change-impact-analyzer skill)
5. Implement change
/sdd-change-apply add-2fa6. Archive change
/sdd-change-archive add-2fa
`Configuration
$3
ITDA v2.0.0 integrates with CodeGraphMCPServer for advanced code analysis.
#### Option 1: Claude Code (Terminal)
`bash
Install CodeGraph MCP with pipx (--force ensures latest version)
pipx install --force codegraph-mcp-serverAdd to Claude Code
claude mcp add codegraph -- codegraph-mcp serve --repo .Verify installation
claude mcp list
`#### Option 2: VS Code with Claude Extension
1. Install Prerequisites:
`bash
# --force ensures latest version even if already installed
pipx install --force codegraph-mcp-server
`2. Configure VS Code (
.vscode/mcp.json):
`json
{
"servers": {
"codegraph": {
"type": "stdio",
"command": "codegraph-mcp",
"args": ["serve", "--repo", "${workspaceFolder}"]
}
}
}
`3. Or use Claude Desktop config (
~/.claude/claude_desktop_config.json on macOS/Linux, %APPDATA%\Claude\claude_desktop_config.json on Windows):
`json
{
"mcpServers": {
"codegraph": {
"command": "codegraph-mcp",
"args": ["serve", "--repo", "/path/to/your/project"]
}
}
}
`#### Option 3: npx (No Installation)
`bash
Add via npx (no global install needed)
claude mcp add codegraph -- npx -y @anthropic/codegraph-mcp --codebase .
`#### Verify MCP Server is Working
After setup, test in Claude:
`text
Use the init_graph tool to analyze this codebase
`If successful, you'll see the code graph initialization output.
Available MCP Tools (14 tools):
| Category | Tools | Description |
| ---------- | --------------------------------------------------------------------- | -------------------------------- |
| Code Graph |
init_graph, get_code_snippet, find_callers, find_dependencies | Build and query code graph |
| Search | local_search, global_search, query_codebase | GraphRAG-powered semantic search |
| Analysis | analyze_module_structure, suggest_refactoring | Code structure analysis |
| Navigation | jump_to_definition, find_implementations | Code navigation |Agent Γ MCP Tool Mapping:
| Agent | Primary MCP Tools | Use Case |
| ----------------------- | ------------------------------------------- | -------------------------------- |
| @change-impact-analyzer |
find_dependencies, find_callers | Impact analysis |
| @traceability-auditor | query_codebase, find_callers | Traceability validation |
| @system-architect | analyze_module_structure, global_search | Architecture analysis |
| @code-reviewer | suggest_refactoring, get_code_snippet | Code quality review |
| @security-auditor | find_callers, query_codebase | Security vulnerability detection |Also integrates with other MCP servers:
- Context7 MCP - Up-to-date library documentation (Next.js, React, etc.)
- Azure MCP - Azure resource management
- Microsoft Learn MCP - Microsoft documentation
Skills automatically use available MCP servers when needed.
$3
Edit steering files to customize for your project:
`bash
Architecture patterns
steering/structure.mdTechnology stack
steering/tech.mdProduct context
steering/product.mdConstitutional rules (if needed)
steering/rules/constitution.md
`Development
$3
1. Fork the repository
2. Create a feature branch:
git checkout -b feature/your-feature
3. Make your changes
4. Run tests locally: npm test
5. Run lint: npm run lint
6. Commit with conventional commits: git commit -m "feat: add new feature"
7. Push to your fork: git push origin feature/your-feature
8. Create a Pull Request
9. Wait for CI checks to pass (all checks must succeed)
10. Request review
11. Merge after approval$3
- CI: Runs on every PR and push to
main
- ESLint & Prettier
- Jest Tests (80% coverage required)
- Build Verification
- Security Audit
- Platform Initialization Tests (7 platforms)
- Release: Automated npm publish on version tags (v..*)
- Dependabot: Weekly dependency updates (Mondays 9:00 KST)$3
`bash
Clone repository
git clone https://github.com/gaebalai/itda-sdd.git
cd itdaInstall dependencies
npm installRun tests
npm testRun lint
npm run lintCheck formatting
npm run format:checkLink for local development
npm link
itda init
``Contributions welcome! See CONTRIBUTING.md for guidelines.
If you find ITDA useful, please consider:
- β Star this repository - It helps others discover ITDA
- π Report issues - Help us improve
- π‘ Suggest features - We value your ideas
- π Share your experience - Write about ITDA on your blog
MIT License - see LICENSE for details.
ITDA synthesizes features from:
- itdda - 20-agent system, steering, EARS format
- OpenSpec - Delta specs, brownfield support
- ag2 (AutoGen) - Multi-agent orchestration
- ai-dev-tasks - Simplicity, progressive complexity
- k-sdd - P-label parallelization, validation gates
- spec-kit - Constitutional governance, test-first
- π Documentation
- π SRS v3.0.0
- π
Project Plan v3.0.0
- ποΈ Blueprint
- π Project Plan
---
π ITDA - μλ€ - Bringing specifications, design, and code together.