# Kiro > | - **Type:** Skill - **Install:** `agentstack add skill-jesamkim-oh-my-skills-kiro` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [jesamkim](https://agentstack.voostack.com/s/jesamkim) - **Installs:** 0 - **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills) - **Latest version:** 0.1.0 - **License:** MIT - **Upstream author:** [jesamkim](https://github.com/jesamkim) - **Source:** https://github.com/jesamkim/oh-my-skills/tree/main/my-skills/kiro ## Install ```sh agentstack add skill-jesamkim-oh-my-skills-kiro ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # Kiro Delegation via Orca Lanes Delegate work to **Kiro CLI** (`kiro-cli`, the rebranded Amazon Q Developer CLI) when Claude Code's context window is running low, when you need an independent session for isolated analysis, or when you want a cross-family **code review**. The delegation runs as a **lane**: an Orca-managed terminal that Kiro works in. This matters because a plain headless call blocks the caller for the whole task (measured: 2m38s for a one-file review), which means no parallelism, no progress visibility, and a dead orchestrator while it runs. A lane returns a handle in about a second, so you dispatch, do other work, and collect later — and because the lane is a real terminal in the Orca UI, a human can watch it or take over. Measured on this contract: three lanes dispatched in **5 s** total and all three finished in **76 s**; the same work sequentially would have blocked for minutes. ## Quick start ```bash LANE=/scripts/kiro_lane.sh # Blocking convenience (start + wait + read + close): bash $LANE run --tier deep "Summarize /abs/path/to/design.md in 5 bullets" # Non-blocking — the reason lanes exist: H=$(bash $LANE start --tier deep --title "analyze-auth" "Analyze /abs/path/auth.ts for authz gaps") # ... do other work, dispatch more lanes ... bash $LANE wait --handle $H --timeout 900 # exits with Kiro's own exit code bash $LANE read --handle $H # cleaned result bash $LANE close --handle $H bash $LANE status --handle $H # pending | done rc=N | gone ``` Run several at once by starting each lane, then waiting on each handle: ```bash H1=$(bash $LANE start --tier quick --title "sum-a" "Summarize /abs/a.md in 3 bullets") H2=$(bash $LANE start --tier quick --title "sum-b" "Summarize /abs/b.md in 3 bullets") for h in $H1 $H2; do bash $LANE wait --handle $h --timeout 600; bash $LANE read --handle $h; done ``` **Give each WRITING lane its own git worktree.** Parallel lanes writing one checkout will clobber each other, and telling a worker "only touch file X" is not isolation — the others still see its uncommitted changes, and one `git stash` or `commit -a` eats their work. Read-only lanes (the default) share a directory safely. ## Choosing the model: `--tier` Naming an exact model is a judgement call you usually don't want to make, and hardcoding one is how a skill rots — the previous version of this skill still listed `qwen3-coder-480b` and `gpt-5.5`, both since withdrawn. Describe the **work** instead; the tier resolves against `kiro-cli chat --list-models`, so a withdrawn model is skipped rather than trusted. | `--tier` | Leads with | Cost | Use for | |---|---|---|---| | `quick` | `gpt-5.6-luna` | 0.6x | summaries, extraction, mechanical checks | | `deep` | `gpt-5.6-terra` | 1.2x | routine multi-step analysis (good default) | | `hard` | `claude-opus-5` | 2.2x | hardest reasoning, large refactors | | `review` | `gpt-5.6-sol` | 2.4x | adversarial review — non-Claude first, on purpose | Omit `--tier` to let Kiro's own `auto` routing decide (1.0x). Pass `--model ` to pin one exactly; it overrides `--tier` and says so. `claude-fable-5` is in no default tier: at 4.4x it is the most expensive model offered, and the CLI's own catalogue marks it *"DEVELOPMENT USE CASES ONLY, NOT FOR CUSTOMER DATA, ITAR OR PII"* — so it is opt-in via `--model`, never a default for a customer's repository. ## Trust levels Pick the least privilege the task needs; `read` is the default because analysis and review only need to read. ```bash bash $LANE run --trust none "Explain the CAP theorem tradeoffs" # no file access bash $LANE run --trust read "Summarize /abs/path/doc.md" # fs_read (default) bash $LANE run --trust all "Refactor /abs/path/project/" # writes allowed bash $LANE run --trust "fs_read,execute_bash" "Run the tests and explain failures" ``` Note that `execute_bash` is **rejected in non-interactive mode** — there is no user to approve it. Kiro will try, be denied, and waste a turn, so prefer prompts that reason from files rather than ones that need to run commands. ## Code review `scripts/run_kiro_review.sh` builds the git scope, feeds an adversarial reviewer prompt (`assets/prompts/adversarial-review.md`), and returns findings with `file:line`, a severity, a concrete fix each, and `VERDICT: ship | no-ship`. ```bash REV=/scripts/run_kiro_review.sh bash $REV --lane # auto-detect scope, run as a lane bash $REV --lane --scope working-tree # staged + unstaged + untracked bash $REV --lane --scope branch --base origin/develop bash $REV --lane -- src/payments/ src/auth/handler.ts bash $REV --focus "concurrency and the retry path" # blocking (no --lane) bash $REV --lane --json # also emit a JSON findings block ``` `--lane` prints a handle plus the exact `wait`/`read`/`close` commands to collect it. Reviews are the strongest case for a lane: they take minutes, and blocking the orchestrator for one buys nothing. **Why the reviewer defaults to a non-Claude model.** In the normal flow Claude Code wrote the code and then delegates the review here. If the review also ran on a Claude model, the same family would sign off on its own work. So the chain leads with `gpt-5.6-sol` and falls through `gpt-5.6-terra → claude-opus-5 → qwen3-coder-next → deepseek-3.2`, and it warns when only a Claude model is left — a clean verdict from a same-family reviewer deserves matching skepticism. Other properties worth relying on: - **Review-only.** It reports; it does not fix, stage, or commit. Hand findings back to the user or the main agent. - **Read-only by construction.** The wrapper pre-computes the diff and runs Kiro with `fs_read` only, so it cannot modify anything while reviewing. - **Return findings verbatim.** Do not silently fix or paraphrase them. An optional persistent reviewer agent is bundled at `assets/agents/code-reviewer.json`; its own config restricts `execute_bash` to read-only `git`/`grep`. Copy it to `~/.kiro/agents/` and set `KIRO_REVIEW_AGENT=code-reviewer`. The default path needs no installation. ## When Orca is not available The scripts detect this and **explain which case it is**, because the two need opposite responses: an absent binary needs an install, whereas an installed but closed Orca just needs `orca open`. Either way the work still runs — it falls back to a direct blocking call rather than failing — but you lose parallelism and visibility, so the recommendation is worth acting on. On Linux the Stably binary installs as **`orca-ide`** (deb/rpm from github.com/stablyai/orca releases; headless servers run `orca serve` / `orca-ide serve` with Xvfb). The resolver probes `orca-ide` alongside the macOS paths, so a deb install is picked up with no configuration; `ORCA_BIN` still overrides everything when set. ## Writing the prompt Kiro starts with **zero context** — it has not seen your conversation. Put everything into the prompt: **absolute paths** (it may not share your working directory), what you want, and the output format you expect. For structured output, ask for a fenced JSON or Markdown block; there is no native JSON mode for chat. ``` Read /abs/path/to/file.py and identify: 1. Bugs or logic errors 2. Security vulnerabilities 3. Performance issues Report critical issues only, as a numbered list with file:line and a one-line fix each. ``` ## Known limits (verified, not guesses) - **Do not use Orca's `terminal wait` for lanes.** `--for tui-idle` fires *early* (on a 35 s task it reported done after 6.6 s, with one line of output), because headless Kiro paints no TUI for it to track. `--for exit` never fires, because the shell outlives the command. `kiro_lane.sh` polls its own completion sentinel instead, which carries Kiro's exit code and cannot fire early. - **Kiro v3 is unusable headless right now.** `--v3 --no-interactive` produced no output for over four minutes and had to be killed, while the default v2 engine answered the same prompt in 6 s. The v3-only features in the changelog (Introspect Subagent, global hooks, `/upgrade-agent`, `--mode spec`) are all documented for interactive `kiro-cli --v3`, and CLI 3.0 is still early access. Revisit when it leaves early access. - **Interactive slash commands don't work headless** (`/goal`, `/plan`, pickers). A human who wants the genuine interactive loop runs `kiro-cli chat` themselves. - **Lane output can lose the occasional space** between words (`usedin`, `는S`) — Orca pty rendering, not our filtering; the same prompt without a pty keeps every space. It is left unrepaired on purpose: every repair rule also splits `getUserName` or detaches Korean particles from identifiers (`userId를` → `userId 를`), and corrupting a `file:line` citation is worse than a missing space. Use `run_kiro.sh` when exact prose spacing matters. - **Lane tab titles drift** to the command or cwd; the pty always wins that race. Each lane therefore echoes a `=== kiro lane: ===` banner into its own scrollback, which is what actually identifies it in the UI. - Each call is stateless (no memory between lanes) unless you use Kiro's session resume, which is cwd-scoped. Requires Kiro CLI installed and authenticated. ## Files ``` kiro/ ├── SKILL.md ├── README.md ├── scripts/ │ ├── kiro_lane.sh # lane delegation: start|wait|read|status|close|run │ ├── run_kiro.sh # direct blocking call (no pty; exact spacing) │ └── run_kiro_review.sh # code-review specialization (--lane supported) └── assets/ ├── prompts/adversarial-review.md └── agents/code-reviewer.json ``` ## Source & license This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [jesamkim](https://github.com/jesamkim) - **Source:** [jesamkim/oh-my-skills](https://github.com/jesamkim/oh-my-skills) - **License:** MIT Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** no - **Filesystem access:** no - **Shell / process execution:** no - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/skill-jesamkim-oh-my-skills-kiro - Seller: https://agentstack.voostack.com/s/jesamkim - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.