← Back to all projects

KIRO CLI LEARNING PROJECTS

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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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 (MCP Intro)

  • 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

  • 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

  • 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

  • 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)

  • 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)

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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)

  • 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

  • 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

  • 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

  • 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

  • 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)

  • 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.