# Go to .kiro folder
cd .kiro

# Install to your project
./install.sh /path/to/your/project

# Or install to the current directory
./install.sh

# Or install globally (applies to all Kiro projects)
./install.sh ~

---
inclusion: auto        # auto | fileMatch | manual
description: Brief explanation of what this steering file contains
fileMatchPattern: "*.ts"  # required if inclusion is fileMatch
---

Your rules here...

{
  "version": "1.0.0",
  "enabled": true,
  "name": "hook-name",
  "description": "What this hook does",
  "when": {
    "type": "fileEdited",
    "patterns": ["*.ts"]
  },
  "then": {
    "type": "runCommand",
    "command": "npx tsc --noEmit"
  }
}

{
  "name": "my-agent",
  "hooks": {
    "postToolUse": [
      {
        "matcher": "fs_write",
        "command": "npx tsc --noEmit"
      }
    ]
  }
}

.kiro/
├── agents/                       # 33 agents (JSON + MD formats)
│   ├── planner.json / .md        # Planning specialist
│   ├── code-reviewer.json / .md  # Code review specialist
│   ├── tdd-guide.json / .md      # TDD specialist
│   ├── security-reviewer.json / .md # Security specialist
│   ├── architect.json / .md      # Architecture specialist
│   ├── build-error-resolver.json / .md # Build error specialist
│   ├── typescript-reviewer.json / .md  # TypeScript/JS reviewer
│   ├── rust-reviewer.json / .md  # Rust reviewer
│   ├── kotlin-reviewer.json / .md # Kotlin/Android reviewer
│   ├── java-reviewer.json / .md  # Java/Spring Boot reviewer
│   ├── cpp-reviewer.json / .md   # C++ reviewer
│   ├── django-reviewer.json / .md # Django reviewer
│   ├── swift-reviewer.json / .md # Swift reviewer
│   ├── react-reviewer.json / .md # React reviewer
│   ├── mle-reviewer.json / .md   # ML engineering reviewer
│   ├── performance-optimizer.json / .md # Performance specialist
│   ├── ... and 17 more           # (build-resolvers, go, python, db, e2e, etc.)
│   └── (each agent has both .json for CLI and .md for IDE)
├── skills/                       # 43 skills
│   ├── tdd-workflow/             # TDD workflow
│   ├── coding-standards/         # Universal coding standards
│   ├── security-review/          # Security checklist
│   ├── verification-loop/        # Build/test/lint verification
│   ├── api-design/               # REST API patterns
│   ├── frontend-patterns/        # React/Next.js patterns
│   ├── backend-patterns/         # Node.js/Express patterns
│   ├── react-patterns/           # React 18/19 patterns
│   ├── react-testing/            # React Testing Library
│   ├── rust-patterns/            # Rust idioms and ownership
│   ├── kotlin-patterns/          # Kotlin coroutines and KMP
│   ├── springboot-patterns/      # Spring Boot architecture
│   ├── django-patterns/          # Django ORM and DRF
│   ├── fastapi-patterns/         # FastAPI async APIs
│   ├── nestjs-patterns/          # NestJS modules and DI
│   ├── mle-workflow/             # ML engineering workflow
│   ├── pytorch-patterns/         # PyTorch training pipelines
│   ├── ... and 26 more           # (testing, deployment, docker, etc.)
│   └── (each skill has a SKILL.md with YAML frontmatter)
├── steering/                     # 22 steering files
│   ├── coding-style.md           # Auto-loaded coding style rules
│   ├── security.md               # Auto-loaded security rules
│   ├── testing.md                # Auto-loaded testing rules
│   ├── development-workflow.md   # Auto-loaded dev workflow
│   ├── git-workflow.md           # Auto-loaded git workflow
│   ├── patterns.md               # Auto-loaded design patterns
│   ├── performance.md            # Auto-loaded performance rules
│   ├── lessons-learned.md        # Auto-loaded project patterns
│   ├── typescript-patterns.md    # Loaded for .ts/.tsx files
│   ├── typescript-security.md    # Loaded for .ts/.tsx files
│   ├── python-patterns.md        # Loaded for .py files
│   ├── golang-patterns.md        # Loaded for .go files
│   ├── swift-patterns.md         # Loaded for .swift files
│   ├── rust-patterns.md          # Loaded for .rs files
│   ├── kotlin-patterns.md        # Loaded for .kt files
│   ├── java-patterns.md          # Loaded for .java files
│   ├── cpp-patterns.md           # Loaded for .cpp/.hpp/.h files
│   ├── php-patterns.md           # Loaded for .php files
│   ├── ruby-patterns.md          # Loaded for .rb files
│   ├── dev-mode.md               # Manual: #dev-mode
│   ├── review-mode.md            # Manual: #review-mode
│   └── research-mode.md          # Manual: #research-mode
├── hooks/                        # 13 IDE hooks
│   ├── README.md                      # Documentation on IDE and CLI hooks
│   ├── quality-gate.kiro.hook         # Manual quality gate hook
│   ├── typecheck-on-edit.kiro.hook    # Auto typecheck on edit
│   ├── console-log-check.kiro.hook    # Check for console.log
│   ├── tdd-reminder.kiro.hook         # TDD reminder on file create
│   ├── git-push-review.kiro.hook      # Review before git push
│   ├── code-review-on-write.kiro.hook # Review after write
│   ├── auto-format.kiro.hook          # Auto-format on edit
│   ├── extract-patterns.kiro.hook     # Extract patterns on stop
│   ├── session-summary.kiro.hook      # Summary on stop
│   ├── doc-file-warning.kiro.hook     # Warn before doc changes
│   ├── rust-check-on-edit.kiro.hook   # Rust compilation check
│   ├── python-lint-on-edit.kiro.hook  # Python lint on edit
│   └── security-check-on-create.kiro.hook # Security check on sensitive dirs
├── scripts/                      # 2 shell scripts
│   ├── quality-gate.sh           # Quality gate shell script
│   └── format.sh                 # Auto-format shell script
└── settings/                     # MCP configuration
    └── mcp.json.example          # Example MCP server configs

docs/                             # 5 documentation files
├── longform-guide.md             # Deep dive on agentic workflows
├── shortform-guide.md            # Quick reference guide
├── security-guide.md             # Security best practices
├── migration-from-ecc.md         # Migration guide from ECC
└── ECC-KIRO-INTEGRATION-PLAN.md  # Integration plan and analysis

# 1. Start with the planner agent to break down the feature
kiro-cli --agent planner
> "I need to add user authentication with JWT tokens"

# 2. Invoke the TDD workflow skill
> /tdd-workflow

# 3. Follow the TDD cycle: write tests first, then implementation
# The tdd-workflow skill will guide you through:
# - Writing unit tests for auth logic
# - Writing integration tests for API endpoints
# - Writing E2E tests for login flow

# 4. Switch to code-reviewer after implementation
> /agent swap code-reviewer
> "Review the authentication implementation"

# 5. Run security review for auth-related code
> /agent swap security-reviewer
> "Check for security vulnerabilities in the auth system"

# 6. Trigger quality gate before committing
# (In IDE: Click the quality-gate hook in Agent Hooks panel)

# 1. Switch to code-reviewer agent
kiro-cli --agent code-reviewer

# 2. Review specific files or directories
> "Review the changes in src/api/users.ts"

# 3. Use the verification-loop skill for comprehensive checks
> /verification-loop

# 4. The verification loop will:
# - Run build and type checks
# - Run linter
# - Run all tests
# - Perform security scan
# - Review git diff
# - Iterate until all checks pass

# 1. Invoke security-review skill when working on sensitive features
> /security-review

# 2. The skill provides a comprehensive checklist:
# - Input validation and sanitization
# - Authentication and authorization
# - Secret management
# - SQL injection prevention
# - XSS prevention
# - CSRF protection

# 3. Switch to security-reviewer agent for deep analysis
> /agent swap security-reviewer
> "Analyze the API endpoints for security vulnerabilities"

# 4. The security.md steering file is auto-loaded, ensuring:
# - No hardcoded secrets
# - Proper error handling
# - Secure crypto usage
# - OWASP Top 10 compliance

# For Go projects:
kiro-cli --agent go-reviewer
> "Review the concurrency patterns in this service"
> /golang-patterns  # Invoke Go-specific patterns skill

# For Python projects:
kiro-cli --agent python-reviewer
> "Review the type hints and error handling"
> /python-patterns  # Invoke Python-specific patterns skill

# Language-specific steering files are auto-loaded:
# - golang-patterns.md loads when editing .go files
# - python-patterns.md loads when editing .py files
# - typescript-patterns.md loads when editing .ts/.tsx files

# Hooks run automatically based on triggers:

# 1. typecheck-on-edit hook
# - Triggers when you save .ts or .tsx files
# - Agent checks for type errors inline, no terminal spawned

# 2. console-log-check hook
# - Triggers when you save .js, .ts, or .tsx files
# - Agent flags console.log statements and offers to remove them

# 3. tdd-reminder hook
# - Triggers when you create a new .ts or .tsx file
# - Reminds you to write tests first
# - Reinforces TDD discipline

# 4. extract-patterns hook
# - Runs when agent stops working
# - Suggests patterns to add to lessons-learned.md
# - Builds your team's knowledge base over time

# Toggle hooks on/off in the Agent Hooks panel (IDE)
# or disable them in the hook JSON files

# Use manual steering files for specific contexts:

# Development mode - focused on implementation
> #dev-mode
> "Implement the user registration endpoint"

# Review mode - thorough code review
> #review-mode
> "Review all changes in the current PR"

# Research mode - exploration and learning
> #research-mode
> "Explain how the authentication system works"

# Manual steering files provide context-specific instructions
# without cluttering every conversation

# 1. Use database-reviewer agent for schema work
kiro-cli --agent database-reviewer
> "Review the database schema for the users table"

# 2. Invoke database-migrations skill
> /database-migrations

# 3. For PostgreSQL-specific work
> /postgres-patterns
> "Optimize this query for better performance"

# 4. The database-reviewer checks:
# - Schema design and normalization
# - Index usage and performance
# - Migration safety
# - SQL injection vulnerabilities

# 1. Fix build errors with build-error-resolver
kiro-cli --agent build-error-resolver
> "Fix the TypeScript compilation errors"

# 2. Use docker-patterns skill for containerization
> /docker-patterns
> "Create a production-ready Dockerfile"

# 3. Use deployment-patterns skill for CI/CD
> /deployment-patterns
> "Set up a GitHub Actions workflow for deployment"

# 4. Run quality gate before deployment
# (Trigger quality-gate hook to run all checks)

# 1. Use refactor-cleaner agent for safe refactoring
kiro-cli --agent refactor-cleaner
> "Remove unused code and consolidate duplicate functions"

# 2. The agent will:
# - Identify dead code
# - Find duplicate implementations
# - Suggest consolidation opportunities
# - Refactor safely without breaking changes

# 3. Use verification-loop after refactoring
> /verification-loop
# Ensures all tests still pass after refactoring

# 1. Use doc-updater agent for documentation work
kiro-cli --agent doc-updater
> "Update the README with the new API endpoints"

# 2. The agent will:
# - Update codemaps in docs/CODEMAPS/
# - Update README files
# - Generate API documentation
# - Keep docs in sync with code

# 3. doc-file-warning hook prevents accidental doc changes
# - Triggers before writing to documentation files
# - Asks for confirmation
# - Prevents unintentional modifications