• Generate

  .specify/specs/###-feature-name/spec.md

  for all features
• Constitution and folder structure
• Ready for manual planning with

  /speckit.plan

• Everything from Option 1
• PLUS: Auto-generate

  plan.md

  for PARTIAL/MISSING features
• Ready for manual task breakdown with

  /speckit.tasks

• Everything from Option 2
• PLUS: Auto-generate comprehensive

  tasks.md

  (300-500 lines each)
• Ready for immediate implementation
• No additional planning needed

.stackshift-state.json

• You've completed Step 2 (Reverse Engineer)
• Have comprehensive documentation in

  docs/reverse-engineering/

• Ready to create formal specifications in GitHub Spec Kit format
• Want to leverage

  /speckit

  slash commands for implementation

• "Create specifications from documentation"
• "Transform docs into Spec Kit format"
• "Set up GitHub Spec Kit"
• "Initialize Spec Kit for this project"

1. Read reverse engineering docs - Parse

   docs/reverse-engineering/functional-specification.md

2. Extract ALL features - Identify every feature (complete, partial, missing)
3. Generate constitution - Create

   .specify/memory/constitution.md

   with project principles
4. Create feature specs - Generate

   .specify/specs/###-feature-name/spec.md

   for EVERY feature
5. Implementation plans - Create

   plan.md

   for PARTIAL and MISSING features only
6. Enable slash commands - Set up

   /speckit.*

   commands

• ✅ Complete features get specs (for future spec-driven changes)
• ⚠️ Partial features get specs + plans (show what exists + what's missing)
• ❌ Missing features get specs + plans (ready to implement)

Download directly if script not available

**Why this is needed:**
- `/speckit.analyze` requires `scripts/bash/check-prerequisites.sh`
- `/speckit.implement` requires `scripts/bash/check-prerequisites.sh`
- `/speckit.plan` requires `scripts/bash/setup-plan.sh`
- `/speckit.specify` requires `scripts/bash/create-new-feature.sh`

**Without these scripts, Gear 4 (Gap Analysis) will fail when trying to run `/speckit.analyze`!**

1. .specify/memory/constitution.md

   exists

2. .specify/specs/###-feature-name/

   directories created for ALL features
3. Each feature has

   spec.md

4. PARTIAL/MISSING features have

   plan.md

specify init

• .specify/memory/constitution.md

  (from templates)

• .specify/specs/###-feature-name/spec.md

  (all features)

• .specify/specs/###-feature-name/plan.md

  (for incomplete features)

• .claude/commands/speckit.*.md

  (slash commands)

undefined

docs/reverse-engineering/functional-specification.md

.specify/memory/constitution.md

• Purpose & Values - Why this project exists, core principles
• Technical Decisions - Architecture choices with rationale
• Development Standards - Code style, testing requirements, review process
• Quality Standards - Performance, security, reliability requirements
• Governance - How decisions are made

/speckit.constitution

After generating initial constitution, user can run:
> /speckit.constitution

To refine and update the constitution interactively

• As a user, I want to register an account so that I can save my data
• As a user, I want to log in so that I can access my dashboard

• User can register with email and password
• User can log in with credentials
• User can reset forgotten password
• JWT tokens issued on successful login

• Authentication method: JWT
• Password hashing: bcrypt
• Session duration: 24 hours
• API endpoints:
  • POST /api/auth/register
  • POST /api/auth/login
  • POST /api/auth/reset-password

• ✅ Backend API endpoints (all 3)
• ✅ Database user model
• ✅ JWT token generation

• ❌ Frontend login page
• ❌ Frontend registration page
• ❌ Password reset UI
• ❌ Token refresh mechanism

• user-profile.md (depends on authentication)
• authorization.md (extends authentication)

**Use `/speckit.specify` command:**

/speckit.specify

undefined

• Backend API fully functional
• No frontend UI components exist
• User lands on placeholder page

• Complete login page with form validation
• Registration page with email verification
• Password reset flow (email + new password)
• Responsive design for mobile/desktop

1. Create React components using existing UI library
2. Integrate with backend API endpoints
3. Add form validation with Zod
4. Implement JWT token storage (localStorage)
5. Add route protection for authenticated pages

• Create LoginPage component
• Create RegistrationPage component
• Create PasswordResetPage component
• Add form validation
• Integrate with API endpoints
• Add loading and error states
• Write component tests
• Update routing configuration

• Risk: Token storage in localStorage (XSS vulnerability)
  • Mitigation: Consider httpOnly cookies instead
• Risk: No rate limiting on frontend
  • Mitigation: Add rate limiting to API endpoints

• Unit tests for form validation logic
• Integration tests for API calls
• E2E tests for complete auth flow

• All acceptance criteria from specification met
• No security vulnerabilities
• Pass all tests
• UI matches design system

**Use `/speckit.plan` command:**

/speckit.plan

undefined

• ✅ COMPLETE - Fully implemented and tested
• ⚠️ PARTIAL - Partially implemented (note what exists vs what's missing)
• ❌ MISSING - Not started

/speckit.analyze

/speckit.analyze

/speckit.tasks

/speckit.implement <specification-name>

/speckit.clarify

greenfield_location

~/git/my-new-app

~/git/my-app/
├── [original code]
├── .specify/           # Created here first
└── docs/

~/git/my-new-app/
├── .specify/           # COPIED from original repo
├── README.md
└── .gitignore

• New repo needs specs for

  /speckit.*

  commands
• New repo is self-contained and spec-driven
• Can develop independently going forward
• Original repo keeps specs for reference

.specify/memory/

.specify/specs/

.specify/memory/constitution.md

.specify/specs/

• docs/reverse-engineering/

  - Comprehensive reference docs

• .specify/memory/

  - Spec Kit format for

  /speckit

  commands

1. Scan specs directory:
   bash

   find .specify/specs -name "spec.md" -type f | sort

2. Identify incomplete features:
   • Parse status from each spec.md
   • Filter for ⚠️ PARTIAL and ❌ MISSING
   • Skip ✅ COMPLETE features (no plan needed)
3. Generate plans in parallel (5 at a time):
   javascript

   // For each PARTIAL/MISSING feature
   Task({
     subagent_type: 'general-purpose',
     model: 'sonnet',
     description: `Create plan for ${featureName}`,
     prompt: `
       Read: .specify/specs/${featureId}/spec.md
   
       Generate implementation plan following /speckit.plan template:
       - Assess current state (what exists vs missing)
       - Define target state (all acceptance criteria)
       - Determine technical approach
       - Break into implementation phases
       - Identify risks and mitigations
       - Define success criteria
   
       Save to: .specify/specs/${featureId}/plan.md
   
       Target: 300-500 lines, detailed but not prescriptive
     `
   });

4. Verify coverage:
   • Check every PARTIAL/MISSING spec has plan.md
   • Report summary (e.g., "8 plans generated for 8 incomplete features")

1. Scan for plans:
   bash

   find .specify/specs -name "plan.md" -type f | sort

2. Generate tasks in parallel (3 at a time - slower due to length):
   javascript

   // For each plan
   Task({
     subagent_type: 'general-purpose',
     model: 'sonnet',
     description: `Create tasks for ${featureName}`,
     prompt: `
       Read: .specify/specs/${featureId}/spec.md
       Read: .specify/specs/${featureId}/plan.md
   
       Generate COMPREHENSIVE task breakdown:
       - Break into 5-10 logical phases
       - Each task has: status, file path, acceptance criteria, code examples
       - Include Testing phase (unit, integration, E2E)
       - Include Documentation phase
       - Include Edge Cases section
       - Include Dependencies section
       - Include Acceptance Checklist
       - Include Priority Actions
   
       Target: 300-500 lines (be thorough!)
   
       Save to: .specify/specs/${featureId}/tasks.md
     `
   });

3. Verify quality:
   • Check each tasks.md is > 200 lines
   • Flag if too short (< 200 lines)
   • Report summary (e.g., "8 task files generated, avg 427 lines")

• ✅

  .specify/

  directory initialized
• ✅

  constitution.md

  created with project principles
• ✅ Individual feature specifications in

  .specify/specs/

• ✅ Implementation status clearly marked (✅/⚠️/❌)
• ✅

  /speckit.*

  slash commands available

• ✅ Everything from Level 1
• ✅

  plan.md

  for every PARTIAL/MISSING feature
• ✅ 100% plan coverage for incomplete features
• ✅ Ready for manual task breakdown or

  /speckit.tasks

• ✅ Everything from Level 2
• ✅

  tasks.md

  for every planned feature
• ✅ Comprehensive task lists (300-500 lines each)
• ✅ Complete roadmap ready for implementation
• ✅ No additional planning needed

1. specify init my-app
2. Generate constitution.md from functional-specification.md
3. Create individual feature specs from functional requirements
4. Mark implementation status (✅/⚠️/❌)
5. Generate implementation plans for gaps

/speckit.analyze

/speckit.implement user-authentication

/speckit.specify

• Spec Kit uses

  .specify/

  directory (not

  specs/

  )
• Specifications are markdown files, not JSON/YAML
• Implementation status uses emoji markers: ✅ ⚠️ ❌

• /speckit

  commands are slash commands in Claude Code, not CLI
• Constitution is a living document, update as project evolves
• Keep reverse-engineering docs as comprehensive reference
• Use

  stackshift:technical-writer

  agent for efficient parallel spec generation
• Always use

  --ai claude

  flag with

  specify init

  for non-interactive mode

/speckit.*