Claude Code Spec-Driven Development

This project implements Kiro-style Spec-Driven Development for Claude Code using hooks and slash commands.

Project Context

Project Steering

Product overview:
```
.kiro/steering/product.md
```
Technology stack:
```
.kiro/steering/tech.md
```
Project structure:
```
.kiro/steering/structure.md
```
Custom steering docs for specialized contexts

Active Specifications

ai-auto-slug-plugin: WordPress AI-powered slug generator (initialized)
Use
```
/spec-status [feature-name]
```
to check progress

Development Guidelines

Think in English, but generate responses in Traditional Chinese (使用英文思考，繁體中文回答)

Spec-Driven Development Workflow

Phase 0: Steering Generation (Recommended)

Kiro Steering (

.kiro/steering/

)

/steering-init          # Generate initial steering documents
/steering-update        # Update steering after changes
/steering-custom        # Create custom steering for specialized contexts

Note: For new features or empty projects, steering is recommended but not required. You can proceed directly to spec-requirements if needed.

Phase 1: Specification Creation

New Clarification Phase

Immediately after
```
/spec-init
```
, AI must:
1. Analyze project description for unclear or missing details
2. Ask 5–10 clarification questions
3. Wait for user responses
4. Merge responses into
```
requirements.md
```
  under Clarification Responses
5. Mark
```
clarifications_collected: true
```
  in
```
spec.json
```

If user refuses or skips, record as

"No additional input provided"

in Clarification Responses.

/spec-init [feature-name]           # Initialize spec structure only
/spec-requirements [feature-name]   # Generate requirements → Review → Edit if needed
/spec-design [feature-name]         # Generate technical design → Review → Edit if needed
/spec-tasks [feature-name]          # Generate implementation tasks → Review → Edit if needed

Phase 2: Progress Tracking

/spec-status [feature-name]         # Check current progress and phases

Spec-Driven Development Workflow

Kiro's spec-driven development follows a strict 3-phase approval workflow:

Phase 1: Requirements Generation & Approval

Generate:
```
/spec-requirements [feature-name]
```
- Generate requirements document
Review: Human reviews
```
requirements.md
```
and edits if needed
Approve: Manually update
```
spec.json
```
to set
```
"requirements": true
```

Phase 2: Design Generation & Approval

Generate:
```
/spec-design [feature-name]
```
- Generate technical design (requires requirements approval)
Review: Human reviews
```
design.md
```
and edits if needed
Approve: Manually update
```
spec.json
```
to set
```
"design": true
```

Phase 3: Tasks Generation & Approval

Generate:
```
/spec-tasks [feature-name]
```
- Generate implementation tasks (requires design approval)
Review: Human reviews
```
tasks.md
```
and edits if needed
Approve: Manually update
```
spec.json
```
to set
```
"tasks": true
```

Implementation

Only after all three phases are approved can implementation begin.

Key Principle: Each phase requires explicit human approval before proceeding to the next phase, ensuring quality and accuracy throughout the development process.

Development Rules

Consider steering: Run
```
/steering-init
```
before major development (optional for new features)
Follow the 3-phase approval workflow: Requirements → Design → Tasks → Implementation
Manual approval required: Each phase must be explicitly approved by human review
No skipping phases: Design requires approved requirements; Tasks require approved design
Update task status: Mark tasks as completed when working on them
Keep steering current: Run
```
/steering-update
```
after significant changes
Check spec compliance: Use
```
/spec-status
```
to verify alignment

Automation

This project uses Claude Code hooks to:

Automatically track task progress in tasks.md
Check spec compliance
Preserve context during compaction
Detect steering drift

Task Progress Tracking

When working on implementation:

Manual tracking: Update tasks.md checkboxes manually as you complete tasks
Progress monitoring: Use
```
/spec-status
```
to view current completion status
TodoWrite integration: Use TodoWrite tool to track active work items
Status visibility: Checkbox parsing shows completion percentage

Getting Started

Initialize steering documents:
```
/steering-init
```
Create your first spec:
```
/spec-init [your-feature-name]
```
Follow the workflow through requirements, design, and tasks

Kiro Steering Details

Kiro-style steering provides persistent project knowledge through markdown files:

Core Steering Documents

product.md: Product overview, features, use cases, value proposition
tech.md: Architecture, tech stack, dev environment, commands, ports
structure.md: Directory organization, code patterns, naming conventions

Custom Steering

Create specialized steering documents for:

API standards
Testing approaches
Code style guidelines
Security policies
Database conventions
Performance standards
Deployment workflows

Inclusion Modes

Always Included: Loaded in every interaction (default)
Conditional: Loaded for specific file patterns (e.g.,
```
"*.test.js"
```
)
Manual: Loaded on-demand with
```
#filename
```
reference

Claude Code Spec-Driven Development

This project implements Kiro-style Spec-Driven Development for Claude Code using hooks and slash commands.

Project Context

Project Steering

Product overview:
```
.kiro/steering/product.md
```
Technology stack:
```
.kiro/steering/tech.md
```
Project structure:
```
.kiro/steering/structure.md
```
Custom steering docs for specialized contexts

Active Specifications

ai-auto-slug-plugin: WordPress AI-powered slug generator (initialized)
Use
```
/spec-status [feature-name]
```
to check progress

Development Guidelines

Think in English, but generate responses in Traditional Chinese (使用英文思考，繁體中文回答)

Spec-Driven Development Workflow

Phase 0: Steering Generation (Recommended)

Kiro Steering (

.kiro/steering/

)

/steering-init          # Generate initial steering documents
/steering-update        # Update steering after changes
/steering-custom        # Create custom steering for specialized contexts

Note: For new features or empty projects, steering is recommended but not required. You can proceed directly to spec-requirements if needed.

Phase 1: Specification Creation

New Clarification Phase

Immediately after
```
/spec-init
```
, AI must:
1. Analyze project description for unclear or missing details
2. Ask 5–10 clarification questions
3. Wait for user responses
4. Merge responses into
```
requirements.md
```
  under Clarification Responses
5. Mark
```
clarifications_collected: true
```
  in
```
spec.json
```

If user refuses or skips, record as

"No additional input provided"

in Clarification Responses.

/spec-init [feature-name]           # Initialize spec structure only
/spec-requirements [feature-name]   # Generate requirements → Review → Edit if needed
/spec-design [feature-name]         # Generate technical design → Review → Edit if needed
/spec-tasks [feature-name]          # Generate implementation tasks → Review → Edit if needed

Phase 2: Progress Tracking

/spec-status [feature-name]         # Check current progress and phases

Spec-Driven Development Workflow

Kiro's spec-driven development follows a strict 3-phase approval workflow:

Phase 1: Requirements Generation & Approval

Generate:
```
/spec-requirements [feature-name]
```
- Generate requirements document
Review: Human reviews
```
requirements.md
```
and edits if needed
Approve: Manually update
```
spec.json
```
to set
```
"requirements": true
```

Phase 2: Design Generation & Approval

Generate:
```
/spec-design [feature-name]
```
- Generate technical design (requires requirements approval)
Review: Human reviews
```
design.md
```
and edits if needed
Approve: Manually update
```
spec.json
```
to set
```
"design": true
```

Phase 3: Tasks Generation & Approval

Generate:
```
/spec-tasks [feature-name]
```
- Generate implementation tasks (requires design approval)
Review: Human reviews
```
tasks.md
```
and edits if needed
Approve: Manually update
```
spec.json
```
to set
```
"tasks": true
```

Implementation

Only after all three phases are approved can implementation begin.

Key Principle: Each phase requires explicit human approval before proceeding to the next phase, ensuring quality and accuracy throughout the development process.

Development Rules

Consider steering: Run
```
/steering-init
```
before major development (optional for new features)
Follow the 3-phase approval workflow: Requirements → Design → Tasks → Implementation
Manual approval required: Each phase must be explicitly approved by human review
No skipping phases: Design requires approved requirements; Tasks require approved design
Update task status: Mark tasks as completed when working on them
Keep steering current: Run
```
/steering-update
```
after significant changes
Check spec compliance: Use
```
/spec-status
```
to verify alignment

Automation

This project uses Claude Code hooks to:

Automatically track task progress in tasks.md
Check spec compliance
Preserve context during compaction
Detect steering drift

Task Progress Tracking

When working on implementation:

Manual tracking: Update tasks.md checkboxes manually as you complete tasks
Progress monitoring: Use
```
/spec-status
```
to view current completion status
TodoWrite integration: Use TodoWrite tool to track active work items
Status visibility: Checkbox parsing shows completion percentage