Processes, not benchmarks.
Every tool here makes an agent more useful. They differ in what happens when the agent is wrong: who notices, what stops it and what it costs you on a change that does not need the ceremony. Each row says where an approach is strong and where it leaves the work to you.
| Concern | Plain Claude Code | Spec Kit | Kiro | Cursor rules + hooks | AI-DLC | RiskRails |
|---|---|---|---|---|---|---|
| An edit outside the task is refused | hooks exist; you write the rule | tasks.md guides | steering guides | shell hook can deny; file scope is yours | rules ask the agent | a hook refuses, every call |
| The process scales with the change | plan mode, your call each time | one flow per feature | spec or chat, your call | not built in | adapts depth to the task | six-axis weight, three modes |
| "Done" is measured on the tree | the model reports | the agent reports | the agent reports | the agent reports | the agent reports | green suite + files in scope |
| A human gate before risky work | permission prompts | you review each artefact | you approve each spec file | per-command approval | approval at each phase | by mode, in the dialog |
| Starts on legacy code with no spec | yes | spec first | spec first, or chat | yes | inception first | survey once; light tasks need none |
| A spec for a new feature | plan mode only | its core | its core | not built in | its core | /rr-spec |
| Where it runs | Claude Code | many coding agents | Kiro IDE and CLI | Cursor | rule files for several tools | Claude Code and Codex |
| Setup | none | specify init | install the IDE | rule and hook files | copy the rule files | npx, then /rr-setup |
✓ the tool does it by design. ◐ possible, but left to you. ✕ not what the tool is for. Read from each tool's public documentation in October 2026; tools change fast, so check the current docs before you decide.
Strong at, weak at, and with RiskRails.
Plain Claude Code
CLAUDE.md, permissions, plan mode, hooks and subagents, with nothing on top.
Strong at
- No setup and nothing new to learn.
- The fastest path for a one-off change.
- Every building block is there if you write the rules.
Weak at
- A rule in CLAUDE.md is a request the model may skip.
- A typo and a payment change get the same process unless you choose.
- "Tests pass" is the model's word.
RiskRails is built on these same hooks, skills and subagents. It adds the rules, a state machine and the tests that prove both.
Spec Kit
GitHub's spec-driven toolkit: constitution, specify, plan, tasks, implement.
Strong at
- A clear path from intent to tasks for a new feature.
- A constitution that later specs are checked against.
- Works with many coding agents.
Weak at
- The same flow for every size of change.
- The task list guides the agent; nothing refuses a step outside it.
- Completion is what the agent reports.
/rr-setup --adopt moves .specify/ and specs/ into docs/sdlc/ and .ai/, checks that no line was lost and keeps the originals.
Kiro
An agentic IDE with specs (requirements, design, tasks), steering files and agent hooks.
Strong at
- Specs and their review inside one editor.
- Steering files give every session the project's context.
- Hooks start agent actions on file events.
Weak at
- Tied to its own IDE and CLI.
- Its hooks start work; they are not a refusal layer.
- No measured weight per change.
/rr-setup --adopt moves .kiro/ into this layout and keeps the originals; --mode coexist leaves them in place and only routes to them.
Cursor rules + hooks
Rules files scoped by glob, plus hooks such as beforeShellExecution.
Strong at
- Lives in the editor many teams already use.
- A shell hook can allow, deny or ask.
- Rules load only where their glob matches.
Weak at
- You write and maintain the whole policy and its tests.
- No task state, no weighing, no measured close.
- Cursor only.
/rr-setup --adopt moves .cursorrules and .cursor/rules/ into this layout and keeps the originals.
AI-DLC
AWS's AI-Driven Development Lifecycle: Inception, Construction and Operations, shipped as rule files.
Strong at
- A full methodology from intent to operations.
- Depth adapts: a small fix skips phases.
- Approval at each phase and an audit trail.
Weak at
- Rules in markdown; the model has to follow them.
- No hook stops an action between approvals.
- Built around team rituals more than one developer.
A different layer: AI-DLC tells the agent what to do; RiskRails adds what it cannot do. --adopt moves its files.
RiskRails
Weight, three modes, one guard hook, deterministic gates in state.py, a shared .ai/ tree.
Strong at
- A hook refuses scope creep, secrets, force pushes and deploys.
- Light work stays light; payments get a plan, a STRONG review and you.
- Close is measured on the tree, and the record keeps the why.
Weak at
- Setup costs a survey and three answers per project.
- Claude Code and Codex only; needs Node and Python.
- Guards are regex: a tripwire, not a sandbox.
- Full mode spends time and tokens on purpose.
Tuned for one developer who knows the codebase. Known risks lists what it does not protect.
Pick by what breaks if the agent is wrong.
A prototype or a new service
Nothing in production depends on it yet. Plain Claude Code, or Spec Kit or Kiro when you want the spec written down.
A team that runs a methodology
Rituals, phases and sign-offs across roles. AI-DLC gives the shape; add hooks where an approval alone is not enough.
Legacy code customers rely on
Undocumented rules, old workarounds, money and personal data. That is the case RiskRails is built for.