Learn Kiro CLI: From Zero to Agentic Master

Goal: Become fluent in Kiro CLI as an agentic runtime, not just a terminal chatbot. You will learn how to steer AI execution, control permissions, manage context, and build reliable automation that produces real, verifiable outcomes.

Agentic Runtime: The REVL Loop (Read, Evaluate, Verify, Loop)

Kiro is not a single-shot REPL. It is an execution loop with guardrails. The key is to separate intent, execution, and verification so the agent stays reliable.

User intent
    |
    v
Read context  -> Evaluate plan -> Execute tools -> Verify results -> Loop

Why this matters: AI output is probabilistic. Verification makes it deterministic. If the loop cannot verify, the task is not done.

Configuration and Scope: Global vs Project vs Agent

Kiro settings are layered. If you do not understand precedence, you will fight your own configuration.

Highest priority (most specific)
  .kiro/agents/*.json    (agent persona, tools, resources)
  .kiro/settings.json    (project defaults)
  ~/.kiro/settings.json  (global defaults)
Lowest priority (most general)

Practical consequences:

  • Global settings define your baseline model and permissions.
  • Project settings enforce repo-specific constraints.
  • Agent configs create specialist personas (security auditor, infra architect).

Steering and Specs: Constraints That Actually Work

Steering is how you encode invariants. The best steering is positive, specific, and testable.

Bad: “Do not write insecure code.” Good: “All input validation must use zod. All database calls must go through the query layer.”

Steering files should separate intent (what) from implementation (how) and live in .kiro/steering/.

Planning and Subagents: Split Thinking From Doing

Kiro can run a planning agent first, then an execution agent. This reduces logic errors and makes work auditable.

User request
  |
  v
Plan: steps + assumptions + risks
  |
  v
Approve plan -> Execute steps -> Verify

Subagents are parallel sessions. Use them to explore large codebases without flooding your primary context.

Context and Knowledge: RAM, Not Disk

Context is scarce and decays. Manage it like memory.

Tier 1: Session context  (chat + /context add)
Tier 2: Persistent files (agent resources, steering)
Tier 3: Knowledge index  (/knowledge, vector search)

Key tactics:

  • Use /context show to monitor size.
  • Use /compact to summarize long histories.
  • Use /context remove to prune irrelevant files.
  • Use knowledge indexing for large codebases.

Models and Routing: Choose the Right Brain

Kiro routes work by model. You should override when you know the tradeoff.

Haiku  -> fast, cheap, shallow tasks
Sonnet -> balanced default
Opus   -> deep reasoning, architecture
Auto   -> routes for you

Deep refactors and architecture want Opus. Repetitive edits and glue code can use Haiku or Auto.

Tools, Permissions, and Safety

Tools are real execution. Permission settings are your safety line.

Prompt -> Tool request -> Permission check -> Execute -> Verify

Rules of thumb:

  • Keep shell untrusted in risky repos.
  • Allow read tools by default; require approval for write/exec.
  • Use hooks to block dangerous commands.

Hooks and Guardrails: Enforce Reality

Hooks are automated gatekeepers. They run before or after tool use and can block or fix actions.

PreToolUse  -> validate and block risk
PostToolUse -> lint/format/tests/auto-fix
UserPromptSubmit -> inject context (git diff)

This is how you stop the AI from shipping broken code.

MCP (Model Context Protocol): Real Tools, Real Data

MCP is how Kiro calls external systems with typed schemas.

Kiro CLI <-> MCP Server <-> API/DB

MCP lets the agent query Postgres, GitHub, AWS, or custom tools without guessing. It is the bridge from text to systems.

Remote and Enterprise Workflows

Kiro is designed for headless environments:

  • Device flow auth solves no-browser servers.
  • SSH forwarding keeps the shell integration working.
  • Proxy variables and custom CAs are required in corporate networks.

If you ignore this, your automation will fail in production.

Multimodal and Experimental Features

These features make Kiro more than a chatbot:

  • Tangents: ask side questions without polluting context.
  • Checkpoints: snapshot and restore the repo instantly.
  • Delegate: run long tasks in the background.
  • Vision: turn sketches into code.

Testing and Verification

AI output is only useful if it passes real checks.

Change -> Lint/Format -> Unit/E2E/PBT -> Fix -> Re-run

Property-based testing is critical for AI-generated logic because it discovers edge cases you did not imagine.

Automation and Refactoring

Kiro is best at deterministic, repetitive work:

  • Scaffolding projects
  • Bulk refactors
  • SDK generation
  • Documentation upgrades

The trick is to constrain the task so the agent can verify every step.

Security and Secrets

AI can hallucinate secrets or suggest unsafe commands. You need guardrails.

  • PreToolUse hooks to block destructive shell commands.
  • PostToolUse hooks to scan for secrets.
  • Read-only agents for audits.

Concept Summary Table

Concept Cluster What You Need to Internalize
Agentic Workflow REVL loop, verification gates, and the difference between plan and execution.
Configuration & Scope Global vs project vs agent overrides and how precedence works.
Steering & Specs Positive constraints that enforce invariants across sessions.
Context & Knowledge Tiered context, compaction, and knowledge indexing.
Models & Routing Cost vs depth tradeoffs; when to force Opus or Haiku.
Tooling & Permissions Read vs write vs shell; trust only what you must.
Hooks & Guardrails Pre/Post hooks for safety, linting, and quality gates.
MCP & Custom Tools Typed tools that connect Kiro to real systems.
Remote & Enterprise Device flow, SSH, proxy, and CA trust.
Multimodal & Experiments Tangents, checkpoints, delegate, and vision workflows.
Testing & Verification Linting, E2E, and property-based testing.
Automation & Refactoring Safe scaffolding and mechanical refactors.
Security & Secrets Blocking dangerous commands and preventing secret leaks.

Deep Dive Reading by Concept

Concept Resource
Configuration & Context Kiro CLI Docs: “Configuration” and “Context management”
Planning & Subagents Kiro CLI Docs: “Planning agent” and “Subagents”
Steering & Specs Kiro CLI Docs: “Steering” and “Best practices”
MCP Architecture Kiro CLI Docs: “Model Context Protocol (MCP)” and “MCP examples”
Hooks & Permissions Kiro CLI Docs: “Hooks” and “Tool permissions”
Remote & Headless Kiro CLI Docs: “Device flow login” and “CLI commands”
Testing & Reliability “Release It!” by Michael T. Nygard - Stability patterns
CI/CD Automation “Continuous Delivery” by Jez Humble and David Farley - Foundations
Property-Based Testing “Property-Based Testing with PropEr, Erlang, and Elixir” by Fred Hebert
Data + RAG “Designing Data-Intensive Applications” by Martin Kleppmann

Project List

We progress from basic configuration to autonomous, self-healing systems.

Project 1: “The Personalized Kiro Config” — Configuration Management

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language JSON / Markdown
Coolness Level Level 2: Practical but Forgettable
Business Potential 1. The “Resume Gold” (Efficiency)
Difficulty Level 1: Beginner
Knowledge Area Configuration Management

What you’ll build: A robust, shareable global configuration system for Kiro that defines preferred models, telemetry, and your first global steering rules.

Why it teaches Config: You will understand precedence (global vs project vs agent) and how to persist your preferences across sessions.

Core challenges you’ll face:

  • Understanding the JSON schema for settings.json.
  • Defining global steering that applies to all projects.
  • Resolving conflicts between global and local settings.

Success criteria:

  • Kiro uses your chosen default model in new sessions.
  • A global steering rule is consistently applied.

Project 2: “The Steering Enforcer” — Prompt Engineering

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Markdown
Coolness Level Level 3: Genuinely Clever
Business Potential 3. Service & Support (Team Standardization)
Difficulty Level 1: Beginner
Knowledge Area Prompt Engineering / Context Management

What you’ll build: A set of hierarchical steering files (tech.md, product.md, style.md) for a dummy project. Verify that Kiro refuses output that violates these rules.

Why it teaches Steering: This is the foundation of enterprise AI: constrain creativity to adhere to strict invariants.

Core challenges you’ll face:

  • Writing positive constraints.
  • Structuring intent vs implementation.

Success criteria:

  • A test prompt fails until you align it with steering.

Project 3: “The Context Detective” — LLM Context Window

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Bash / Kiro Commands
Coolness Level Level 2: Practical
Difficulty Level 1: Beginner
Knowledge Area LLM Context Window

What you’ll build: Experiments to visualize token usage. Load a large file, use /context show, /compact, and /context remove.

Why it teaches Context: You learn to garbage collect AI memory to maintain performance and accuracy.

Core challenges you’ll face:

  • Distinguishing file context from chat history.
  • Detecting when instructions are being forgotten.

Success criteria:

  • You can reduce context size without losing key constraints.

Project 4: “The Subagent Researcher” — Agentic Architectures

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Natural Language
Coolness Level Level 3: Genuinely Clever
Difficulty Level 2: Intermediate
Knowledge Area Agentic Architectures

What you’ll build: Use subagents to map a complex repository. Aggregate findings into ARCHITECTURE.md.

Why it teaches Subagents: You break linear context limits using parallel research.

Core challenges you’ll face:

  • Writing clear delegation prompts.
  • Avoiding hallucinated summaries.

Success criteria:

  • ARCHITECTURE.md accurately reflects repo structure.

Project 5: “The Plan Architect” — Spec-Driven Development

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Natural Language
Coolness Level Level 3: Genuinely Clever
Difficulty Level 2: Intermediate
Knowledge Area Spec-Driven Development

What you’ll build: A small ToDo app built only after a /plan phase that outputs a tasks.md checklist.

Why it teaches Planning: Separates thinking from typing, reducing logic errors.

Success criteria:

  • A complete plan exists before execution starts.
  • Each task is checked off with verification notes.

Project 6: “The Custom Persona Generator” — Agent Configuration

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language JSON
Coolness Level Level 3: Genuinely Clever
Business Potential 2. Micro-SaaS (Specialized Agents)
Difficulty Level 2: Intermediate
Knowledge Area Agent Configuration

What you’ll build: A security-auditor.json agent with read-only permissions and OWASP Top 10 in its prompt.

Why it teaches Custom Agents: You build specialized personas for specific SDLC phases.

Core challenges you’ll face:

  • Configuring allowedTools.
  • Injecting static resources.

Success criteria:

  • The agent refuses to write files but can review code.

Project 7: “The Executable Spec with mdflow” — Literate Programming

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Markdown / Bash
Coolness Level Level 4: Hardcore Tech Flex
Difficulty Level 3: Advanced
Knowledge Area Literate Programming

What you’ll build: A Markdown spec whose code blocks are executed and validated, keeping docs in sync with reality.

Why it teaches Executable Specs: Documentation that executes cannot rot.

Success criteria:

  • The spec fails when code changes and passes after repair.

Project 8: “The Property Based Testing Suite” — Advanced Testing

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Python (Hypothesis) or TypeScript (fast-check)
Coolness Level Level 4: Hardcore Tech Flex
Difficulty Level 3: Advanced
Knowledge Area Advanced Testing

What you’ll build: A booking system tested with PBT to prove no overlapping bookings.

Why it teaches PBT: It exposes subtle edge cases AI might miss.

Success criteria:

  • PBT finds at least one real bug before you fix it.

Project 9: “The Postgres Analyst” — Model Context Protocol (MCP)

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language SQL / JSON (Config)
Coolness Level Level 3: Genuinely Clever
Business Potential 3. Service & Support (Data Ops)
Difficulty Level 2: Intermediate
Knowledge Area Model Context Protocol (MCP)

What you’ll build: Configure postgres-mcp in mcp.json and run queries via Kiro.

Why it teaches MCP: Kiro gains real, typed access to your database.

Core challenges you’ll face:

  • Correct connection strings.
  • Using read-only DB users.

Success criteria:

  • Kiro answers schema-based questions by executing real SQL.

Project 10: “The GitHub Project Manager” — Workflow Automation

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language JSON (Config)
Coolness Level Level 2: Practical
Difficulty Level 2: Intermediate
Knowledge Area Workflow Automation

What you’ll build: Integrate @modelcontextprotocol/server-github and generate issue summaries and PR drafts.

Why it teaches Tool Integration: Kiro bridges code and project management without context switching.

Success criteria:

  • Kiro can summarize open issues with a label filter.

Project 11: “The AWS Cloud Architect” — Cloud Infrastructure

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Terraform / AWS CLI
Coolness Level Level 3: Genuinely Clever
Difficulty Level 3: Advanced
Knowledge Area Cloud Infrastructure

What you’ll build: Use AWS MCP to audit S3 buckets and generate Terraform fixes.

Why it teaches Cloud Ops: Kiro becomes an infra reviewer with live state access.

Success criteria:

  • Generated Terraform closes at least one real misconfiguration.

Project 12: “The Documentation Librarian” — RAG

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Python (mcp-server-rag)
Coolness Level Level 3: Genuinely Clever
Difficulty Level 2: Intermediate
Knowledge Area RAG (Retrieval Augmented Generation)

What you’ll build: A custom MCP server that indexes PDFs or internal docs for question answering.

Why it teaches RAG: You extend Kiro with private knowledge beyond its training data.

Success criteria:

  • Kiro answers a question that is only in your private docs.

Project 13: “The Custom Tool Builder (Python)” — MCP Protocol Implementation

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Python
Coolness Level Level 4: Hardcore Tech Flex
Business Potential 5. Industry Disruptor (Ecosystem)
Difficulty Level 3: Advanced
Knowledge Area MCP Protocol Implementation

What you’ll build: A custom MCP server exposing fetch_stock_price(ticker).

Why it teaches Protocol: You learn MCP as JSON-RPC over stdio.

Success criteria:

  • Kiro calls your tool and parses real output.

Project 14: “The File System Guardian (Node.js)” — MCP Protocol Implementation

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language TypeScript / Node.js
Coolness Level Level 4: Hardcore Tech Flex
Difficulty Level 3: Advanced
Knowledge Area MCP Protocol Implementation

What you’ll build: A sandboxed MCP server with high-level tools like scaffold_react_component(name, props).

Why it teaches Abstraction: You encode best practices into single, safe tools.

Success criteria:

  • The tool generates consistent component structure every run.

Project 15: “The Chrome Puppeteer” — Browser Automation

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language JavaScript / HTML
Software or Tool chrome-devtools-mcp
Coolness Level Level 5: Pure Magic
Difficulty Level 3: Advanced
Knowledge Area Browser Automation

What you’ll build: Use Kiro to drive a real browser and assert UI behavior.

Why it teaches E2E: You get AI-driven QA on a live page.

Success criteria:

  • Kiro captures a screenshot and reports a UI state.

Project 16: “The Design to Code Converter” — Multimodal AI

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language CSS / React
Coolness Level Level 5: Pure Magic
Difficulty Level 2: Intermediate
Knowledge Area Multimodal AI

What you’ll build: Convert a hand-drawn layout into Tailwind CSS.

Why it teaches Vision: You learn how precise you must be when using sketches.

Success criteria:

  • The rendered UI matches the sketch’s layout hierarchy.

Project 17: “The Type-Safe Hook with Bun” — Kiro Hooks

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language TypeScript (Bun)
Coolness Level Level 4: Hardcore Tech Flex
Difficulty Level 3: Advanced
Knowledge Area Kiro Hooks

What you’ll build: A PostToolUse hook in Bun that parses JSON events with Zod and logs metrics.

Why it teaches Safe Automation: You replace fragile shell scripts with typed automation.

Success criteria:

  • Hook logs structured output on every tool use.

Project 18: “The Security Firewall Hook” — Security Governance

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Python or Rust
Coolness Level Level 4: Hardcore Tech Flex
Business Potential 3. Service & Support (Enterprise Security)
Difficulty Level 3: Advanced
Knowledge Area Security Governance

What you’ll build: A PreToolUse hook that blocks dangerous commands.

Why it teaches Governance: You enforce guardrails against hallucinated risk.

Success criteria:

  • A destructive command is blocked with a clear message.

Project 19: “The Auto-Fixer Loop” — Developer Experience (DX)

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Bash / JavaScript
Coolness Level Level 3: Genuinely Clever
Difficulty Level 2: Intermediate
Knowledge Area Developer Experience (DX)

What you’ll build: A PostToolUse hook that runs lint/format and forces retries on failure.

Why it teaches Feedback Loops: The AI cannot finish until the code is clean.

Success criteria:

  • Lint errors prevent completion until fixed.

Project 20: “The Git Context Injector” — Context Management

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Bash
Coolness Level Level 2: Practical
Difficulty Level 2: Intermediate
Knowledge Area Context Management

What you’ll build: A UserPromptSubmit hook that appends git diff --staged.

Why it teaches Dynamic Context: The AI always sees the current change set.

Success criteria:

  • Prompt includes diff content automatically.

Project 21: “The Headless Server Setup” — Remote Development

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Linux Shell
Coolness Level Level 3: Genuinely Clever
Difficulty Level 2: Intermediate
Knowledge Area Remote Development

What you’ll build: Install Kiro on a headless VM and authenticate via device flow.

Why it teaches Remote Dev: This is the standard pattern for server-based work.

Success criteria:

  • Headless login succeeds without a local browser.

Project 22: “The SSH Tunnel Agent” — Networking

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language SSH Config
Coolness Level Level 4: Hardcore Tech Flex
Difficulty Level 3: Advanced
Knowledge Area Networking

What you’ll build: Run Kiro locally but execute commands remotely via ssh.

Why it teaches Hybrid Workflows: Brain local, execution remote.

Success criteria:

  • A deploy task runs end-to-end on a remote host.

Project 23: “The Corporate Proxy Navigator” — Enterprise Networking

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Env Vars / Certs
Coolness Level Level 2: Practical
Difficulty Level 3: Advanced
Knowledge Area Enterprise Networking

What you’ll build: Configure Kiro to use HTTPS_PROXY and trust a custom root CA.

Why it teaches Enterprise Readiness: Most enterprise failures happen here.

Success criteria:

  • Kiro can reach LLM endpoints through the proxy.

Project 24: “The Secret Sanitizer Hook” — Secrets Management

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Python (TruffleHog / Gitleaks)
Coolness Level Level 3: Genuinely Clever
Business Potential 3. Service & Support (Security)
Difficulty Level 2: Intermediate
Knowledge Area Secrets Management

What you’ll build: A PostToolUse hook that scans modified files for secrets.

Why it teaches Safety: Prevents accidental secret leakage.

Success criteria:

  • A dummy key is detected and blocked.

Project 25: “The Tangent Explorer” — Context Management

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language N/A (Interaction)
Coolness Level Level 2: Practical
Difficulty Level 1: Beginner
Knowledge Area Context Management

What you’ll build: Simulate a debugging session, switch to a tangent, then return without polluting context.

Why it teaches Context Hygiene: Tangents keep the main thread clean.

Success criteria:

  • The main context summary ignores tangent content.

Project 26: “The Checkpoint Time Machine” — Safety Systems

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Git / Kiro
Coolness Level Level 3: Genuinely Clever
Difficulty Level 2: Intermediate
Knowledge Area Safety Systems

What you’ll build: Snapshot, perform risky edits, and restore instantly.

Why it teaches Fearless Coding: You can let the agent be aggressive without fear.

Success criteria:

  • A restore returns the repo to a known good state.

Project 27: “The Checklist Manager” — Task Management

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Markdown
Coolness Level Level 2: Practical
Difficulty Level 1: Beginner
Knowledge Area Task Management

What you’ll build: Use /todo to turn a brain dump into executable steps.

Why it teaches Structured Execution: It enforces a real work queue.

Success criteria:

  • Items are executed and checked off by Kiro.

Project 28: “The Semantic Search Engine” — Knowledge Management

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Python (RAG)
Coolness Level Level 4: Hardcore Tech Flex
Difficulty Level 3: Advanced
Knowledge Area Knowledge Management

What you’ll build: Enable /knowledge and ingest a folder of PDFs for semantic Q&A.

Why it teaches Retrieval: You learn how to use data larger than the context window.

Success criteria:

  • An answer is grounded in retrieved chunks.

Project 29: “The Delegate Background Worker” — Async Workflows

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Bash
Coolness Level Level 3: Genuinely Clever
Difficulty Level 2: Intermediate
Knowledge Area Async Workflows

What you’ll build: Use delegate to run tests and fix linting while you keep working.

Why it teaches Parallelism: The agent becomes non-blocking.

Success criteria:

  • A background task completes and reports its summary.

Project 30: “The Recursive Prompt Improver” — Metacognition

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Natural Language
Coolness Level Level 5: Pure Magic
Difficulty Level 3: Advanced
Knowledge Area Metacognition

What you’ll build: Ask Kiro to analyze its own steering and improve it based on mistakes.

Why it teaches Self-Correction: Your system gets smarter over time.

Success criteria:

  • A new steering rule prevents a repeated mistake.

Project 31: “The Legacy Code Archaeologist” — Code Understanding

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language C / Java (Legacy)
Coolness Level Level 3: Genuinely Clever
Difficulty Level 3: Advanced
Knowledge Area Code Understanding

What you’ll build: Map a legacy repo and generate a call-graph summary.

Why it teaches Exploration: The AI becomes a codebase cartographer.

Success criteria:

  • DIAGRAM.md matches real entry points and call flow.

Project 32: “The Reverse Documenter” — Documentation

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Markdown
Coolness Level Level 2: Practical
Difficulty Level 2: Intermediate
Knowledge Area Documentation

What you’ll build: Generate docs and tests from an undocumented function.

Why it teaches Verification: If the AI cannot explain it, the code is too complex.

Success criteria:

  • A new unit test covers the documented edge cases.

Project 33: “The Full Stack Scaffolder” — Rapid Prototyping

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language React / Node.js
Coolness Level Level 3: Genuinely Clever
Difficulty Level 2: Intermediate
Knowledge Area Rapid Prototyping

What you’ll build: From empty directory to working full stack app in one session.

Why it teaches Agency: The planner and executor must collaborate.

Success criteria:

  • App runs locally with a working UI and API.

Project 34: “The Cloud Native Deployer” — DevOps

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Docker / Kubernetes YAML
Coolness Level Level 2: Practical
Difficulty Level 3: Advanced
Knowledge Area DevOps

What you’ll build: Dockerize Project 33 and generate Kubernetes manifests.

Why it teaches Ops: Kiro removes boilerplate friction.

Success criteria:

  • Containers build and Kubernetes manifests apply cleanly.

Project 35: “The Deep Reasoner (Claude Code)” — Algorithmic Reasoning

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Python
Coolness Level Level 4: Hardcore Tech Flex
Difficulty Level 3: Advanced
Knowledge Area Algorithmic Reasoning

What you’ll build: Solve a complex algorithmic problem using a scratchpad file and Opus model.

Why it teaches Reasoning: You use high-end reasoning as a tool.

Success criteria:

  • The solution passes a non-trivial test set.

Project 36: “The Global Translator” — Internationalization

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language JSON (i18n)
Coolness Level Level 2: Practical
Difficulty Level 1: Beginner
Knowledge Area Internationalization

What you’ll build: Generate translations while preserving key structure.

Why it teaches Grunt Work: AI excels at high-volume, high-precision tasks.

Success criteria:

  • All keys match exactly across locales.

Project 37: “The SQL Optimizer” — Database Performance

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language SQL
Coolness Level Level 3: Genuinely Clever
Difficulty Level 3: Advanced
Knowledge Area Database Performance

What you’ll build: Analyze slow SQL and produce index/query improvements.

Why it teaches Analysis: Kiro acts like a senior DBA.

Success criteria:

  • EXPLAIN ANALYZE improves after the change.

Project 38: “The Refactoring Surgeon” — Software Architecture

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language TypeScript
Coolness Level Level 3: Genuinely Clever
Difficulty Level 3: Advanced
Knowledge Area Software Architecture

What you’ll build: Break up a God Class into services and utilities.

Why it teaches Safe Changes: Kiro is strong at mechanical refactors.

Success criteria:

  • Behavior is preserved and tests still pass.

Project 39: “The API Client Generator” — Integration

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language TypeScript / Python
Coolness Level Level 2: Practical
Difficulty Level 2: Intermediate
Knowledge Area Integration

What you’ll build: Generate a typed SDK from openapi.yaml.

Why it teaches Automation: No more boilerplate clients.

Success criteria:

  • Generated SDK compiles and can call one endpoint.

Project 40: “The Autonomous Developer (Capstone)” — Full Agentic Mastery

Attribute Value
File KIRO_CLI_LEARNING_PROJECTS.md
Main Programming Language Polyglot
Coolness Level Level 5: Pure Magic
Business Potential 5. Industry Disruptor (Agentic Workflow)
Difficulty Level 5: Master
Knowledge Area Full Agentic Mastery

What you’ll build: The self-healing CI/CD agent.

  1. Trigger: A GitHub Action fails.
  2. Action: Kiro reads the logs in headless mode.
  3. Diagnosis: It identifies the failure.
  4. Fix: It patches the code.
  5. Verify: It runs tests.
  6. Push: It opens a PR.

Why it teaches Mastery: This combines headless operation, hooks, MCP, shell tools, and reasoning.

Success criteria:

  • A real failing workflow is fixed and a PR is opened.

Project Comparison Table

Project Range Difficulty Focus Cool Factor
1-5 (Foundations) Beginner Config, Context, Planning 2/5
6-10 (Steering) Intermediate Personas, Specs, PBT 3/5
11-16 (MCP) Advanced DBs, Cloud, Tools 4/5
17-24 (Hooks/Remote) Advanced Security, SSH, Safety 4/5
25-32 (Workflows) Mixed Tangents, Checkpoints, Docs 3/5
33-40 (Capstone) Master Full Autonomy 5/5

Summary

This learning path covers Kiro CLI through 40 hands-on projects.

# Project Name Focus
1 Personalized Config Configuration
2 Steering Enforcer Prompt Engineering
3 Context Detective LLM Context
4 Subagent Researcher Agent Delegation
5 Plan Architect Spec-Driven Dev
6 Custom Persona Agent Config
7 Executable Spec Documentation
8 PBT Suite Testing
9 Postgres Analyst MCP (Database)
10 GitHub Manager MCP (Workflow)
11 AWS Architect MCP (Cloud)
12 Doc Librarian MCP (RAG)
13 Custom Tool (Py) MCP (Protocol)
14 FS Guardian (Node) MCP (Protocol)
15 Chrome Puppeteer Browser Automation
16 Design to Code Multimodal
17 Type-Safe Hook Bun / TypeScript
18 Security Firewall Policy / Governance
19 Auto-Fixer Loop Feedback Loops
20 Git Context Injector Context Automation
21 Headless Setup Remote Dev
22 SSH Tunnel Agent Networking
23 Corporate Proxy Enterprise Ops
24 Secret Sanitizer Security
25 Tangent Explorer Context Management
26 Checkpoint Time Machine Safety
27 Checklist Manager Task Execution
28 Semantic Search RAG
29 Delegate Worker Async Tasks
30 Recursive Improver Metacognition
31 Legacy Archaeologist Code Exploration
32 Reverse Documenter Documentation
33 Full Stack Scaffolder Prototyping
34 Cloud Native Deployer DevOps
35 Deep Reasoner Algorithms
36 Global Translator i18n
37 SQL Optimizer Performance
38 Refactoring Surgeon Architecture
39 API Client Generator Integration
40 Autonomous Developer Full Autonomy

For beginners: Start with Project 1, 2, 5. Get comfortable with steering first.

For system architects: Jump to Project 9 (MCP) and Project 17 (Hooks).

For DevOps/SRE: Focus on Project 21 (Headless) and Project 40 (Capstone).

You have moved from a terminal user to an agentic orchestrator.