---
title: "Everything Claude Code for Kiro"
description: "Bring [Everything Claude Code](https://github.com/anthropics/courses/tree/master/everything-claude-code) (ECC) workflows to [Kiro](https://kiro.dev). This repository provides custom agents, skills, hooks, steering files, and scripts that can be installed into any Kiro project with a single command."
type: skill
canonical_url: https://claudary.paisolsolutions.com/skills/readme-425
source: "Claudary"
difficulty: intermediate
author: "Claude Code Knowledge Pack"
date: 2026-07-10T11:36:31.089Z
license: CC-BY-4.0
attribution: "Everything Claude Code for Kiro — Claudary (https://claudary.paisolsolutions.com/skills/readme-425)"
---

# Everything Claude Code for Kiro
Bring [Everything Claude Code](https://github.com/anthropics/courses/tree/master/everything-claude-code) (ECC) workflows to [Kiro](https://kiro.dev). This repository provides custom agents, skills, hooks, steering files, and scripts that can be installed into any Kiro project with a single command.

## Overview

# Everything Claude Code for Kiro

Bring [Everything Claude Code](https://github.com/anthropics/courses/tree/master/everything-claude-code) (ECC) workflows to [Kiro](https://kiro.dev). This repository provides custom agents, skills, hooks, steering files, and scripts that can be installed into any Kiro project with a single command.

## Quick Start

```bash
# 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 ~
```

The installer uses non-destructive copy — it will not overwrite your existing files.

## Component Inventory

| Component | Count | Location |
|-----------|-------|----------|
| Agents (JSON) | 16 | `.kiro/agents/*.json` |
| Agents (MD) | 16 | `.kiro/agents/*.md` |
| Skills | 18 | `.kiro/skills/*/SKILL.md` |
| Steering Files | 16 | `.kiro/steering/*.md` |
| IDE Hooks | 10 | `.kiro/hooks/*.kiro.hook` |
| Scripts | 2 | `.kiro/scripts/*.sh` |
| MCP Examples | 1 | `.kiro/settings/mcp.json.example` |
| Documentation | 5 | `docs/*.md` |

## What's Included

### Agents

Agents are specialized AI assistants with specific tool configurations.

**Format:**
- **IDE**: Markdown files (`.md`) - Access via automatic selection or explicit invocation
- **CLI**: JSON files (`.json`) - Access via `/agent swap` command

Both formats are included for maximum compatibility.

> **Note:** Agent models are determined by your current model selection in Kiro, not by the agent configuration.

| Agent | Description |
|-------|-------------|
| `planner` | Expert planning specialist for complex features and refactoring. Read-only tools for safe analysis. |
| `code-reviewer` | Senior code reviewer ensuring quality and security. Reviews code for CRITICAL security issues, code quality, React/Next.js patterns, and performance. |
| `tdd-guide` | Test-Driven Development specialist enforcing write-tests-first methodology. Ensures 80%+ test coverage with comprehensive test suites. |
| `security-reviewer` | Security vulnerability detection and remediation specialist. Flags secrets, SSRF, injection, unsafe crypto, and OWASP Top 10 vulnerabilities. |
| `architect` | Software architecture specialist for system design, scalability, and technical decision-making. Read-only tools for safe analysis. |
| `build-error-resolver` | Build and TypeScript error resolution specialist. Fixes build/type errors with minimal diffs, no architectural changes. |
| `doc-updater` | Documentation and codemap specialist. Updates codemaps and documentation, generates docs/CODEMAPS/*, updates READMEs. |
| `refactor-cleaner` | Dead code cleanup and consolidation specialist. Removes unused code, duplicates, and refactors safely. |
| `go-reviewer` | Go code review specialist. Reviews Go code for idiomatic patterns, error handling, concurrency, and performance. |
| `python-reviewer` | Python code review specialist. Reviews Python code for PEP 8, type hints, error handling, and best practices. |
| `database-reviewer` | Database and SQL specialist. Reviews schema design, queries, migrations, and database security. |
| `e2e-runner` | End-to-end testing specialist. Creates and maintains E2E tests using Playwright or Cypress. |
| `harness-optimizer` | Test harness optimization specialist. Improves test performance, reliability, and maintainability. |
| `loop-operator` | Verification loop operator. Runs comprehensive checks and iterates until all pass. |
| `chief-of-staff` | Executive assistant for project management, coordination, and strategic planning. |
| `go-build-resolver` | Go build error resolution specialist. Fixes Go compilation errors, dependency issues, and build problems. |

**Usage in IDE:**
- You can run an agent in `/` in a Kiro session, e.g., `/code-reviewer`.
- Kiro's Spec session has native planner, designer, and architects that can be used instead of `planner` and `architect` agents.

**Usage in CLI:**
1. Start a chat session
2. Type `/agent swap` to see available agents
3. Select an agent to switch (e.g., `code-reviewer` after writing code)
4. Or start with a specific agent: `kiro-cli --agent planner`


### Skills

Skills are on-demand workflows invocable via the `/` menu in chat.

| Skill | Description |
|-------|-------------|
| `tdd-workflow` | Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests. Use when writing new features or fixing bugs. |
| `coding-standards` | Universal coding standards and best practices for TypeScript, JavaScript, React, and Node.js. Use when starting projects, reviewing code, or refactoring. |
| `security-review` | Comprehensive security checklist and patterns. Use when adding authentication, handling user input, creating API endpoints, or working with secrets. |
| `verification-loop` | Comprehensive verification system that runs build, type check, lint, tests, security scan, and diff review. Use after completing features or before creating PRs. |
| `api-design` | RESTful API design patterns and best practices. Use when designing new APIs or refactoring existing endpoints. |
| `frontend-patterns` | React, Next.js, and frontend architecture patterns. Use when building UI components or optimizing frontend performance. |
| `backend-patterns` | Node.js, Express, and backend architecture patterns. Use when building APIs, services, or backend infrastructure. |
| `e2e-testing` | End-to-end testing with Playwright or Cypress. Use when adding E2E tests or improving test coverage. |
| `golang-patterns` | Go idioms, concurrency patterns, and best practices. Use when writing Go code or reviewing Go projects. |
| `golang-testing` | Go testing patterns with table-driven tests and benchmarks. Use when writing Go tests or improving test coverage. |
| `python-patterns` | Python idioms, type hints, and best practices. Use when writing Python code or reviewing Python projects. |
| `python-testing` | Python testing with pytest and coverage. Use when writing Python tests or improving test coverage. |
| `database-migrations` | Database schema design and migration patterns. Use when creating migrations or refactoring database schemas. |
| `postgres-patterns` | PostgreSQL-specific patterns and optimizations. Use when working with PostgreSQL databases. |
| `docker-patterns` | Docker and containerization best practices. Use when creating Dockerfiles or optimizing container builds. |
| `deployment-patterns` | Deployment strategies and CI/CD patterns. Use when setting up deployments or improving CI/CD pipelines. |
| `search-first` | Search-first development methodology. Use when exploring unfamiliar codebases or debugging issues. |
| `agentic-engineering` | Agentic software engineering patterns and workflows. Use when working with AI agents or building agentic systems. |

**Usage:**

1. Type `/` in chat to open the skills menu
2. Select a skill (e.g., `tdd-workflow` when starting a new feature, `security-review` when adding auth)
3. The agent will guide you through the workflow with specific instructions and checklists

**Note:** For planning complex features, use the `planner` agent instead (see Agents section above).

### Steering Files

Steering files provide always-on rules and context that shape how the agent works with your code.

| File | Inclusion | Description |
|------|-----------|-------------|
| `coding-style.md` | auto | Core coding style rules: immutability, file organization, error handling, and code quality standards. Loaded in every conversation. |
| `security.md` | auto | Security best practices including mandatory checks, secret management, and security response protocol. Loaded in every conversation. |
| `testing.md` | auto | Testing requirements: 80% coverage minimum, TDD workflow, and test types (unit, integration, E2E). Loaded in every conversation. |
| `development-workflow.md` | auto | Development process, PR workflow, and collaboration patterns. Loaded in every conversation. |
| `git-workflow.md` | auto | Git commit conventions, branching strategies, and version control best practices. Loaded in every conversation. |
| `patterns.md` | auto | Common design patterns and architectural principles. Loaded in every conversation. |
| `performance.md` | auto | Performance optimization guidelines and profiling strategies. Loaded in every conversation. |
| `lessons-learned.md` | auto | Project-specific patterns and learnings. Edit this file to capture your team's conventions. Loaded in every conversation. |
| `typescript-patterns.md` | fileMatch: `*.ts,*.tsx` | TypeScript-specific patterns, type safety, and best practices. Loaded when editing TypeScript files. |
| `python-patterns.md` | fileMatch: `*.py` | Python-specific patterns, type hints, and best practices. Loaded when editing Python files. |
| `golang-patterns.md` | fileMatch: `*.go` | Go-specific patterns, concurrency, and best practices. Loaded when editing Go files. |
| `swift-patterns.md` | fileMatch: `*.swift` | Swift-specific patterns and best practices. Loaded when editing Swift files. |
| `dev-mode.md` | manual | Development context mode. Invoke with `#dev-mode` for focused development. |
| `review-mode.md` | manual | Code review context mode. Invoke with `#review-mode` for thorough reviews. |
| `research-mode.md` | manual | Research context mode. Invoke with `#research-mode` for exploration and learning. |

Steering files with `auto` inclusion are loaded automatically. No action needed — they apply as soon as you install them.

To create your own, add a markdown file to `.kiro/steering/` with YAML frontmatter:

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

Your rules here...
```

### Hooks

Kiro supports two types of hooks:

1. **IDE Hooks** - Standalone JSON files in `.kiro/hooks/` (for Kiro IDE)
2. **CLI Hooks** - Embedded in agent configurations (for `kiro-cli`)

#### IDE Hooks (Standalone Files)

These hooks appear in the Agent Hooks panel in the Kiro IDE and can be toggled on/off. Hook files use the `.kiro.hook` extension.

| Hook | Trigger | Action | Description |
|------|---------|--------|-------------|
| `quality-gate` | Manual (`userTriggered`) | `runCommand` | Runs build, type check, lint, and tests via `quality-gate.sh`. Click to trigger comprehensive quality checks. |
| `typecheck-on-edit` | File edited (`*.ts`, `*.tsx`) | `askAgent` | Checks for type errors when TypeScript files are edited to catch issues early. |
| `console-log-check` | File edited (`*.js`, `*.ts`, `*.tsx`) | `askAgent` | Checks for console.log statements to prevent debug code from being committed. |
| `tdd-reminder` | File created (`*.ts`, `*.tsx`) | `askAgent` | Reminds you to write tests first when creating new TypeScript files. |
| `git-push-review` | Before shell command | `askAgent` | Reviews git push commands to ensure code quality before pushing. |
| `code-review-on-write` | After write operation | `askAgent` | Triggers code review after file modifications. |
| `auto-format` | File edited (`*.ts`, `*.tsx`, `*.js`) | `askAgent` | Checks for formatting issues and fixes them inline without spawning a terminal. |
| `extract-patterns` | Agent stops | `askAgent` | Suggests patterns to add to lessons-learned.md after completing work. |
| `session-summary` | Agent stops | `askAgent` | Provides a summary of work completed in the session. |
| `doc-file-warning` | Before write operation | `askAgent` | Warns before modifying documentation files to ensure intentional changes. |

**IDE Hook Format:**

```json
{
  "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"
  }
}
```

**Required fields:** `version`, `enabled`, `name`, `description`, `when`, `then`

**Available trigger types:** `fileEdited`, `fileCreated`, `fileDeleted`, `userTriggered`, `promptSubmit`, `agentStop`, `preToolUse`, `postToolUse`

#### CLI Hooks (Embedded in Agents)

CLI hooks are embedded within agent configuration files for use with `kiro-cli`.

**Example:** See `.kiro/agents/tdd-guide-with-hooks.json` for an agent with embedded hooks.

**CLI Hook Format:**

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

**Available triggers:** `agentSpawn`, `userPromptSubmit`, `preToolUse`, `postToolUse`, `stop`

See `.kiro/hooks/README.md` for complete documentation on both hook types.

### Scripts

Shell scripts used by hooks to perform quality checks and formatting.

| Script | Description |
|--------|-------------|
| `quality-gate.sh` | Detects your package manager (pnpm/yarn/bun/npm) and runs build, type check, lint, and test commands. Skips checks gracefully if tools are missing. |
| `format.sh` | Detects your formatter (biome or prettier) and auto-formats the specified file. Used by formatting hooks. |

## Project Structure

```
.kiro/
├── agents/                       # 16 agents (JSON + MD formats)
│   ├── planner.json              # Planning specialist (CLI)
│   ├── planner.md                # Planning specialist (IDE)
│   ├── code-reviewer.json        # Code review specialist (CLI)
│   ├── code-reviewer.md          # Code review specialist (IDE)
│   ├── tdd-guide.json            # TDD specialist (CLI)
│   ├── tdd-guide.md              # TDD specialist (IDE)
│   ├── security-reviewer.json    # Security specialist (CLI)
│   ├── security-reviewer.md      # Security specialist (IDE)
│   ├── architect.json            # Architecture specialist (CLI)
│   ├── architect.md              # Architecture specialist (IDE)
│   ├── build-error-resolver.json # Build error specialist (CLI)
│   ├── build-error-resolver.md   # Build error specialist (IDE)
│   ├── doc-updater.json          # Documentation specialist (CLI)
│   ├── doc-updater.md            # Documentation specialist (IDE)
│   ├── refactor-cleaner.json     # Refactoring specialist (CLI)
│   ├── refactor-cleaner.md       # Refactoring specialist (IDE)
│   ├── go-reviewer.json          # Go review specialist (CLI)
│   ├── go-reviewer.md            # Go review specialist (IDE)
│   ├── python-reviewer.json      # Python review specialist (CLI)
│   ├── python-reviewer.md        # Python review specialist (IDE)
│   ├── database-reviewer.json    # Database specialist (CLI)
│   ├── database-reviewer.md      # Database specialist (IDE)
│   ├── e2e-runner.json           # E2E testing specialist (CLI)
│   ├── e2e-runner.md             # E2E testing specialist (IDE)
│   ├── harness-optimizer.json    # Test harness specialist (CLI)
│   ├── harness-optimizer.md      # Test harness specialist (IDE)
│   ├── loop-operator.json        # Verification lo

---

Source: [Claudary](https://claudary.paisolsolutions.com/skills/readme-425) · https://claudary.paisolsolutions.com