Kiro Project Scaffolder Skill

What This Skill Does

This skill enables Claude to automatically recognize when a user wants to create a spec-driven software project and scaffold it using kiro.dev methodology with typix, nickel contracts, and TDD workflows.

When It Activates

Claude autonomously activates this skill when the user mentions:

Direct triggers:

• •"create a new project with specifications"
• •"scaffold a spec-driven application"
• •"set up a kiro project"
• •"I want to build [something] with TDD and type safety"
• •"help me design a project with contracts"

Implicit triggers:

• •Describes a new project and mentions: specifications, contracts, type safety, TDD, nix
• •Asks about project structure best practices for testable code
• •Wants to start a project with clear documentation and requirements
• •Mentions needing both specifications and implementation

Context clues:

• •User is in an empty directory or wants to start fresh
• •Mentions team coordination or shared understanding
• •Wants to ensure quality from the start
• •Previous conversation about software architecture

How It Works

Phase 1: Recognition

Claude identifies that the user wants a spec-driven project and confirms:

I can help you create a spec-driven project using kiro.dev methodology. This will include:
- Complete project specifications (requirements, design, tasks)
- Typix integration for Nix-based development
- Nickel language contracts for type safety  
- TDD workflow setup with test templates
- Comprehensive documentation structure

Would you like to proceed with interactive Q&A to design your project, or provide a description for me to infer the structure?

Phase 2: Interactive or Headless

Interactive Mode (invokes Kiro Architect agent):

• •Conducts structured Q&A
• •Gathers requirements systematically
• •Validates understanding
• •Designs architecture collaboratively

Headless Mode (autonomous inference):

• •Analyzes user's project description
• •Infers requirements and tech stack
• •Proposes structure for confirmation
• •Generates scaffold

Phase 3: Scaffold Generation

Creates complete project structure:

Generating your kiro-scaffolded project...

✓ Created directory structure
✓ Initialized git repository
✓ Generated master specifications
  - .kiro/spec/requirements.md
  - .kiro/spec/design.md
  - .kiro/spec/tasks.md
✓ Set up documentation
  - CLAUDE.md
  - .aidocs/ with kiro, typix, nickel docs
✓ Created nickel contracts scaffold
  - .contracts/ mirroring planned structure
✓ Configured development environment
  - flake.nix with typix integration
✓ Set up TDD workflow
  - Test templates with assertions
  - RED-to-GREEN documentation

Your project is ready! Here's what to do next:
1. Review .kiro/spec/requirements.md
2. Run /kiro-scope <path> to create implementation areas
3. Start with TDD workflow in first scope

Initial commit created. Happy coding!

Phase 4: Guidance

Provides next steps and can:

• •Create first scoped implementation area
• •Write first failing test
• •Explain the workflow
• •Invoke TDD Coach for implementation

Integration with Other Components

This skill works with:

• •Kiro Architect Agent: For interactive design
• •TDD Coach Agent: For implementation guidance
• •Kiro Evaluator Agent: For quality validation
• •Commands: Uses /kiro-new, /kiro-scope internally

Technical Implementation

When activated, this skill:

1. •

   Analyzes Context

   code

   - Empty directory? → Fresh project
   - Existing code? → Migration to kiro
   - Monorepo? → Workspace setup
   

2. •

   Gathers Information

   code

   - Project type (API, CLI, library, etc.)
   - Language and framework preferences
   - Database requirements
   - Scale expectations
   - Team size and experience
   

3. •

   Generates Structure

   code

   - Creates directory hierarchy
   - Writes specification templates
   - Configures nix/typix
   - Sets up contracts scaffold
   - Initializes git with good .gitignore
   

4. •

   Provides Documentation

   code

   - CLAUDE.md with project context
   - .aidocs/ with kiro.dev documentation
   - README.md with getting started guide
   - CONTRIBUTING.md if team project
   

5. •

   Validates Quality

   code

   - Runs /kiro-eval to ensure scaffold is correct
   - Fixes any issues found
   - Confirms all required files present
   

Examples of Activation

Example 1: Explicit Request

User: I want to create a new API service with proper specifications and TDD

Claude: [Activates skill] I'll help you create a spec-driven API service using kiro.dev methodology...

Example 2: Implicit Context

User: I'm starting a new project. It needs to be well-documented, have type safety, and use TDD. How should I structure it?

Claude: [Activates skill] It sounds like you want a spec-driven project! I can scaffold this for you using kiro.dev methodology...

Example 3: Team Coordination Need

User: Our team is building a microservice and we need everyone on the same page about requirements and architecture

Claude: [Activates skill] Perfect use case for spec-driven development! I can create a kiro.dev project that includes...

Quality Assurance

After scaffolding, this skill:

• •Validates structure against kiro standards
• •Ensures all required files present
• •Confirms nickel contracts are valid
• •Checks CLAUDE.md completeness
• •Runs quick evaluation

Best Practices Encoded

This skill ensures:

• •Specifications written before implementation
• •Clear acceptance criteria for all features
• •Type safety through nickel contracts
• •TDD workflow is default approach
• •Documentation is comprehensive
• •Team alignment through shared specs

Customization

The skill adapts to:

• •Solo vs team projects
• •Startup vs enterprise contexts
• •MVP vs full product scope
• •Different programming languages
• •Various tech stacks
• •Organization-specific conventions

Success Indicators

The skill successfully completed when:

• •Project structure matches kiro.dev standards
• •All specifications are complete and clear
• •Development environment is reproducible
• •TDD workflow is documented and ready
• •User understands next steps

See Also

• •Kiro Architect Agent - For complex project design
• •TDD Coach Agent - For implementation guidance
• •Kiro Evaluator Agent - For quality checking