name	kiro-project-scaffolder
description	Automatically scaffolds spec-driven projects when user mentions creating new projects with specifications, type safety, or TDD requirements.

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:

Analyzes Context

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

Gathers Information

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

Generates Structure

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

Provides Documentation

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

Validates Quality

- 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

kiro-project-scaffolder

Install Skill

SKILL.md