# ITDA for Claude Code

**Next-Generation Specification Driven Development with 25 Specialized Skills**

This project uses **ITDA** (Next-Generation Specification Driven Development) configured for Claude Code.

## Features

- 🎯 **25 Specialized Skills** - Orchestrator, Steering, Requirements, Architecture, Development, Quality, Security, Infrastructure
- 📋 **Constitutional Governance** - 9 immutable articles + Phase -1 Gates
- 📝 **EARS Requirements Format** - Unambiguous requirements with complete traceability
- 🧭 **Auto-Updating Project Memory** - Steering system maintains architecture, tech stack, and product context
- 🌐 **Bilingual Documentation** - All documents created in both English and Korean

## 25 Skills Overview

### Orchestration & Management (3)

- **@orchestrator** - Master coordinator for multi-skill workflows
- **@steering** - Project memory manager (auto-updating context)
- **@constitution-enforcer** - Governance validation (9 Articles + Phase -1 Gates)

### Requirements & Planning (3)

- **@requirements-analyst** - EARS format requirements generation
- **@project-manager** - Project planning, scheduling, risk management
- **@change-impact-analyzer** - Brownfield change analysis

### Architecture & Design (4)

- **@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

### Development (1)

- **@software-developer** - Multi-language code implementation

### Quality & Review (5)

- **@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

### Security & Performance (2)

- **@security-auditor** - OWASP Top 10, vulnerability detection
- **@performance-optimizer** - Performance analysis, optimization

### Infrastructure & Operations (5)

- **@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
- **@release-coordinator** - Multi-component release management

### Documentation & Specialized (2)

- **@technical-writer** - Technical documentation, API docs
- **@ai-ml-engineer** - ML model development, MLOps

## Slash Commands

```bash
# Generate project memory
/sdd-steering

# Create requirements
/sdd-requirements <feature>

# Design architecture
/sdd-design <feature>

# Break down into tasks
/sdd-tasks <feature>

# Implement feature
/sdd-implement <feature>

# Validate constitutional compliance
/sdd-validate <feature>
```

## Project Memory (Steering System)

**IMPORTANT**: Before starting any task, check if steering files exist in `steering/` directory:

- `steering/structure.md` - Architecture patterns, directory organization, naming conventions
- `steering/tech.md` - Technology stack, frameworks, development tools
- `steering/product.md` - Business context, product purpose, users

If these files exist, ALWAYS read them first to understand project context.

## SDD Workflow (8 Stages)

```
Research → Requirements → Design → Tasks → Implementation → Testing → Deployment → Monitoring
```

Each stage has:

- Dedicated skills
- Quality gates
- Traceability requirements
- Constitutional validation

## EARS Requirements Format

All requirements must use EARS patterns:

```markdown
### Requirement: User Login

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
```

## Constitutional Governance

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

## Bilingual Documentation

**All agent-generated documents are created in both English and Korean.**

### Language Policy

- **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

### Files Generated Bilingually

**Steering Context**:

- `steering/structure.md` + `steering/structure.ko.md`
- `steering/tech.md` + `steering/tech.ko.md`
- `steering/product.md` + `steering/product.ko.md`

**Specifications**:

- `storage/specs/[feature]-requirements.md` + `.ko.md`
- `storage/design/[feature]-design.md` + `.ko.md`
- `storage/tasks/[feature]-tasks.md` + `.ko.md`

## Quick Start

### First Time Setup

1. Generate project memory:

   ```
   /sdd-steering
   ```

2. Review steering context in `steering/` directory

3. Start development with skills

### For Complex Projects

```
@orchestrator [describe your complete task]
```

### For Specific Tasks

```
@requirements-analyst Create requirements for authentication
@system-architect Design architecture based on requirements.md
@software-developer Implement UserService following design.md
@test-engineer Generate tests from requirements.md
```

## Example Usage

### Greenfield Project (0→1)

```bash
# 1. Generate steering
/sdd-steering

# 2. Create requirements
/sdd-requirements user-authentication

# 3. Design architecture
/sdd-design user-authentication

# 4. Break into tasks
/sdd-tasks user-authentication

# 5. Implement
/sdd-implement user-authentication
```

### Brownfield Project (1→n)

```bash
# 1. Generate steering from existing code
/sdd-steering

# 2. Create change proposal
/sdd-change-init add-2fa

# 3. Impact analysis (automatic via change-impact-analyzer skill)

# 4. Implement change
/sdd-change-apply add-2fa

# 5. Archive change
/sdd-change-archive add-2fa
```

## CLI Commands (v3.5.0)

ITDA provides powerful CLI tools that can be used from any terminal. Install with:

```bash
npm install -g itda-sdd
# or use directly
npx itda-sdd <command>
```

### Core Commands

| Command               | Purpose                   | Example                                  |
| --------------------- | ------------------------- | ---------------------------------------- |
| `itda-workflow`     | Workflow state & metrics  | `npx itda-workflow status`             |
| `itda-requirements` | EARS requirements         | `npx itda-requirements init <feature>` |
| `itda-design`       | C4 + ADR design           | `npx itda-design init <feature>`       |
| `itda-tasks`        | Task breakdown            | `npx itda-tasks init <feature>`        |
| `itda-trace`        | Traceability              | `npx itda-trace matrix`                |
| `itda-validate`     | Constitutional validation | `npx itda-validate all`                |

### Advanced Commands (v3.5.0 NEW)

| Command              | Purpose                   | Example                                |
| -------------------- | ------------------------- | -------------------------------------- |
| `itda-orchestrate` | Multi-skill orchestration | `npx itda-orchestrate auto <task>`   |
| `itda-browser`     | Browser automation & E2E  | `npx itda-browser run "click login"` |
| `itda-gui`         | Web GUI dashboard         | `npx itda-gui start`                 |
| `itda-remember`    | Agent memory management   | `npx itda-remember extract`          |
| `itda-resolve`     | GitHub Issue resolution   | `npx itda-resolve <issue-number>`    |
| `itda-convert`     | Format conversion         | `npx itda-convert to-speckit`        |

### Replanning Commands (v3.6.0 NEW)

| Command                               | Purpose                      | Example                                                      |
| ------------------------------------- | ---------------------------- | ------------------------------------------------------------ |
| `itda-orchestrate replan`           | Execute dynamic replanning   | `npx itda-orchestrate replan <context-id>`                 |
| `itda-orchestrate goal register`    | Register a new goal          | `npx itda-orchestrate goal register --name "Deploy API"`   |
| `itda-orchestrate goal update`      | Update goal progress         | `npx itda-orchestrate goal update <goal-id> --progress 50` |
| `itda-orchestrate goal status`      | View goal status             | `npx itda-orchestrate goal status [goal-id]`               |
| `itda-orchestrate optimize run`     | Run path optimization        | `npx itda-orchestrate optimize run <path-id>`              |
| `itda-orchestrate optimize suggest` | Get optimization suggestions | `npx itda-orchestrate optimize suggest <path-id>`          |
| `itda-orchestrate path analyze`     | Analyze execution path       | `npx itda-orchestrate path analyze <path-id>`              |
| `itda-orchestrate path optimize`    | Optimize execution path      | `npx itda-orchestrate path optimize <path-id>`             |

### Guardrails Commands (v3.9.0 NEW)

| Command                                    | Purpose                           | Example                                                          |
| ------------------------------------------ | --------------------------------- | ---------------------------------------------------------------- |
| `itda-validate guardrails`               | Input/Output guardrail validation | `npx itda-validate guardrails --type input`                    |
| `itda-validate guardrails --type output` | Output content validation         | `echo "content" \| npx itda-validate guardrails --type output` |
| `itda-validate guardrails --type safety` | Safety check with constitutional  | `npx itda-validate guardrails --type safety --constitutional`  |
| `itda-validate guardrails-chain`         | Chain multiple guardrails         | `npx itda-validate guardrails-chain --parallel`                |

## Learn More

- [ITDA Documentation](https://github.com/gaebalai/itda-sdd)
- [Constitutional Governance](steering/rules/constitution.md)
- [8-Stage SDD Workflow](steering/rules/workflow.md)
- [EARS Format Guide](steering/rules/ears-format.md)

---

**ITDA for Claude Code** - 잇다 - Bringing specifications, design, and code together.