# Install Specify CLI
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

# Initialize a new project
specify init my-project --ai copilot

# Or in an existing project
specify init . --ai copilot

/speckit.constitution Create principles focused on code quality, 
testing standards, user experience consistency, and performance requirements

/speckit.specify Build an application that can help me organize my photos 
in separate photo albums. Albums are grouped by date and can be re-organized 
by dragging and dropping on the main page.

/speckit.plan The application uses Vite with minimal number of libraries. 
Use vanilla HTML, CSS, and JavaScript as much as possible.

/speckit.tasks

/speckit.implement

---
description: Create or update project governing principles
---

# Project Constitution

Create a comprehensive constitution document that includes:

1. **Code Quality Standards**
   - Naming conventions
   - Documentation requirements
   - Code review processes

2. **Testing Standards**
   - Unit test coverage requirements
   - Integration test strategies
   - Test documentation

3. **Architecture Principles**
   - Design patterns to follow
   - Technology stack constraints
   - Performance requirements

4. **User Experience Guidelines**
   - Accessibility standards
   - Responsive design requirements
   - Internationalization considerations

---
description: Define requirements and user stories
---

# Specification Template

## User Stories

**As a** [user type]
**I want** [goal]
**So that** [benefit]

### Acceptance Criteria
- [ ] Criterion 1
- [ ] Criterion 2

## Functional Requirements

### FR-001: [Requirement Name]
**Priority**: High/Medium/Low
**Description**: Detailed requirement description
**Dependencies**: [Other requirements]

---
description: Create technical implementation plans
---

# Implementation Plan

## Technology Stack
- Frontend: [Framework/Library]
- Backend: [Framework]
- Database: [Type]
- Deployment: [Platform]

## Architecture Overview
[System architecture diagrams, component diagrams]

## Data Model
[Entity relationship diagrams, table definitions]

## API Specifications
[Endpoint definitions, request/response formats]

## Implementation Phases
1. Phase 1: [Core features]
2. Phase 2: [Advanced features]

## Technical Considerations
- Security requirements
- Performance optimization
- Scalability concerns

---
description: Generate actionable task lists
---

# Task Breakdown

## User Story: [Story ID]

### Task 1: [Task Name]
**File**: `src/components/Feature.tsx`
**Type**: Implementation
**Dependencies**: None
**Parallel**: [P] (if parallelizable)
**Description**: Detailed task description
**Acceptance**: How to verify completion

### Task 2: [Task Name]
**File**: `tests/Feature.test.tsx`
**Type**: Testing
**Dependencies**: Task 1

---
description: Execute implementation plan
---

# Implementation Execution

1. **Validate Prerequisites**
   - Constitution exists
   - Spec is complete
   - Plan is approved
   - Tasks are defined

2. **Parse Tasks**
   - Read tasks.md
   - Build dependency graph
   - Identify parallel tasks

3. **Execute Tasks**
   For each task in order:
   - Create/modify specified files
   - Run tests (if TDD)
   - Validate against acceptance criteria
   - Update task status

4. **Progress Reporting**
   - Mark tasks as In Progress/Done
   - Report errors with context
   - Suggest next steps

---
description: Clarify underspecified areas
---

# Clarification Questions

## Coverage Analysis
[Identify areas not covered in the specification]

## Sequential Questions
1. **Question**: [Specific question]
   **Context**: [Why this is important]
   **Options**: [Possible answers]

[Answers are added to Clarifications section when recorded]

my-project/
├── .specify/
│   ├── memory/
│   │   └── constitution.md          # Project principles
│   ├── specs/
│   │   └── 001-photo-albums/
│   │       ├── spec.md               # Feature specifications
│   │       ├── plan.md               # Implementation plan
│   │       ├── tasks.md              # Task list
│   │       ├── data-model.md         # Data model
│   │       ├── contracts/
│   │       │   └── api-spec.json    # API specifications
│   │       └── research.md           # Technical research
│   ├── scripts/
│   │   ├── create-new-feature.sh
│   │   └── setup-plan.sh
│   └── templates/
│       ├── spec-template.md
│       ├── plan-template.md
│       └── tasks-template.md
├── .github/
│   └── prompts/
│       ├── speckit.constitution.prompt.md
│       ├── speckit.specify.prompt.md
│       ├── speckit.plan.prompt.md
│       ├── speckit.tasks.prompt.md
│       ├── speckit.implement.prompt.md
│       ├── speckit.clarify.prompt.md
│       └── speckit.analyze.prompt.md
└── src/
    └── [Implementation files]

WHEN [condition/event]
THE SYSTEM SHALL [expected behavior]

{
  "hooks": [
    {
      "trigger": "onFileSave",
      "pattern": "**/*.tsx",
      "action": "generateTests"
    }
  ]
}

my-project/
├── .kiro/
│   ├── steering/
│   │   ├── tech-stack.md
│   │   ├── coding-standards.md
│   │   └── workflows.md
│   └── specs/
│       └── photo-albums/
│           ├── requirements.md    # EARS format requirements
│           ├── design.md          # Architecture design
│           └── tasks.md           # Implementation tasks
└── src/
    └── [Implementation files]

# spec.md

## User Stories
As a user, I want to...

## Functional Requirements
FR-001: Feature description

## Review Checklist
- [ ] Requirements are clear
- [ ] Acceptance criteria defined

# requirements.md (EARS format)

WHEN user clicks upload button
THE SYSTEM SHALL display file selection dialog

WHEN file size exceeds 10MB
THE SYSTEM SHALL display error message

# plan.md

## Architecture
- Frontend: React
- Backend: Node.js

## Implementation Details
[Detailed implementation guide]

# data-model.md
[Database schema]

# contracts/api-spec.json
{OpenAPI specification}

# design.md

## Component Architecture
[System architecture diagram]

## Sequence Diagrams
[Flow diagrams]

## Technical Considerations
[Performance, security, etc.]

# tasks.md

## User Story: US-001

### Task 1: Setup database schema
File: src/db/schema.sql
Dependencies: None
[P] Parallel: Yes

### Task 2: Create API endpoint
File: src/api/upload.ts
Dependencies: Task 1

# tasks.md

## Phase 1: Core Implementation

- [ ] Task 1: Database setup
  Status: Not Started
  Assignee: [Auto]
  
- [ ] Task 2: API development
  Status: Not Started
  Dependencies: Task 1

---
description: Custom quality checklist generator
---

# /speckit.custom-checklist

Generate a quality checklist for:

1. **Security Review**
   - Authentication check
   - Authorization verification
   - Input validation

2. **Performance Review**
   - Database query optimization
   - Caching strategy
   - Load testing results

[Output format: Markdown checklist in spec directory]

# Feature 1
specify init . --ai copilot
/speckit.specify Build user authentication system

# Feature 2 (on new branch)
git checkout -b feature/002-payment
/speckit.specify Integrate payment gateway

graph TD
    A[Product Manager] -->|Define requirements| B["speckit.specify"]
    B --> C["Generate spec.md"]
    C --> D[Tech Lead]
    D -->|Technology selection| E["speckit.plan"]
    E --> F["Generate plan.md, data-model.md"]
    F --> G[Developer]
    G -->|Review tasks| H["speckit.tasks"]
    H --> I["Generate tasks.md"]
    I --> J["speckit.implement"]
    J --> K["Generate code"]
    K --> L[Pull Request]
    L --> M[Code Review]
    M -->|Approve| N[Merge]

graph TD
    A[Idea] --> B[Spec Chat]
    B --> C[Generate Requirements]
    C --> D[Generate Design]
    D --> E[Generate Tasks]
    E --> F[Code with #spec reference]
    F --> G[Save file]
    G --> H[Trigger Hooks]
    H --> I[Auto-generate tests]
    I --> J[Run in background]