Comparing Kiro with Cursor after a Month of Heavy Use
I got into the Kiro Hackathon and was lucky to have access during the free preview this past month. I compared it heavily to Cursor to learn the features, quirks, what worked for me, and what didn’t.
TLDR;
Kiro has promise (Hooks are genuinely amazing), but right now it struggles with context control, scope discipline, and transparency. It often reads too much, acts beyond the task, and gives me no visibility into token/context usage. My best results came from pasting minimal snippets and using my own guardrail rules.md—not Kiro’s auto-generated steering files. I completely built a project from scratch in Kiro without any external AI tools this month and I’m pretty proud of the project.
What Kiro Does Well
Customization, it’s small but it’s impact is high, hooks and controlling when rules are included are such a great improvement over Cursor’s Rules for me.
Hooks are fantastic
I love Kiro Hooks. I was initially most excited about Spec Mode, but that cooled fast (more below). Hooks scratched an itch I’ve had in Cursor: lightweight, reusable “memory.” I’ve been doing a manual version of this in Cursor with markdown tasks I reference. Hooks just work better.
They save a ton of time because so much of agentic IDE work is repetitive. With Hooks, I can focus on a task (say, function implementations) without policing style preferences. After Kiro implements the functions to my satisfaction, I start a new chat, add the style Hook, and Kiro updates everything. Same for creating caches across lots of API endpoints or rolling out a performance tweak across multiple files. You can edit and tune a Hook until it’s basically perfect.
Steering (Rules) with Conditional Inclusion
I couldn’t find the auto-generated steering files useful. They feel inspired by Cline’s Memory Bank, but clicking a button to let Kiro write steering is (imho) a token sink.
I think there is a reason why Cline asked users to describe the file first and built it the way they did.
However, treating steering like Cursor “rules” works better: I create my own files and rules. Conditional inclusion is the nice twist here.
Cursor doesn’t have that, and it pairs well with Hooks.
Caveat: like Cursor, Kiro sometimes ignores these rules. I suspect the system prompts are feeding it too much context and occasionally conflicting.
Where Kiro Can Improve
Over-eagerness (and Autopilot)
My biggest complaint: Kiro is over-eager, and Autopilot makes that risky. I keep basic guardrails: stay within the task, propose a plan, justify, only edit after approval. When tasks are fuzzy, that’s on me. But I had a simple one“Remove all debug console.log statements in file #xy.” Kiro did that… and then started “fixing” TypeScript, Tailwind, and Svelte syntax it thought was wrong. (It wasn’t. Weirdly, Claude 4 outside Kiro struggles less with “outdated” syntax.)
Missing token and context visibility
Kiro doesn’t show current token usage. I can’t see how “full” the context is, so I can’t reason about costs or performance. I started hitting chat-context limits almost immediately, and exclusively in Spec Mode.
The annoying part: Kiro often asks me to summarize a chat when it’s already beyond the limit to be able to summarize, the chat itself is short, but it must have included and read so much unnecessary context that it just can’t.
Some tasks become non-completable because it keeps running into the same ceiling, even in new chats. The only workaround I found, without starting fresh, is deleting content from requirements.md and design.md.
Frustrating, especially when it’s the first task after going through building the requirements, design and task list that is supposed to break it down into smaller contexts.
Tab Completion
Cursor has a fantastic best in class tab completion model.
It is fast and it accurately guesses boilerplate code changes.
Kiro’s tab coompletion was slow and gave weird suggestions at times. I haven’t used it at all and it erased most productivity gains by manually having to do tasks like; type a class=”bg-black” 10 times or add typing to a python function signature.
Context control (Spec Mode)
I think I have gotten pretty good at Context Control through my use with Cursor and CC.
In Spec Mode, I was not able to control context reliably. Kiro goes hunting for references and reads a lot of unnecessary files.
Selection-only chat (Ctrl+L vs copy/paste)
In Cursor, you can highlight a section and pass only that to the model. In Kiro, I have to copy/paste the snippet into chat. That works often, but Kiro just as often reads the entire file (and others) anyway without being asked.
I found myself using inline edits Ctrl + I much more in Kiro.
Caching
That brings me to caching.
If the agent is running or sometimes even if it does not.
You can’t edit a file or update it. Kiro Caches heavily, I very often found myself having made edits, just to have them vanish. If the Agent is running, this happens more often that not, so I’m forced to wait for it to finish. Even if it’s editing completely unrelated files.
Claude Code + Kiro vs Claude Code + Cursor
Caching conflicts between Claude Code (CC) and Kiro happen more often than between CC and Cursor. CC and Cursor clash occasionally too, just a lot less. And I think it’s Kiros’ Caching.
Search
Odd quirk: find-in-file on very large JSON sometimes fails in Kiro. Exact matches don’t show up. I tested this a few times. If you work with data-heavy projects, it’s frustrating—and it probably limits what Kiro itself can do unless it shells out to grep/CLI.
I suspect this is a bug.
Documentation lacks search
Kiro lacks good documentation in my opinion, but I have sympathy for this, it’s a new tool, things change and maybe it’s a small time.
There is one thing though, at the very least, the docs need a search box.
I went through the docs diligently, and I kept feeling I miss things, features I assume exist, settings I could tweak. A simple search would make it a lot easier to confirm what’s possible.
What Made Kiro Work for Me
Manual snippet mode: Copy/paste the exact lines Kiro needs. Avoid “open the whole file” unless necessary.
My own steering files: Treat them like Cursor rules.
“Do only the requested change”: Propose a plan, justify, only then implement.
“If you see related issues, list them, don’t fix them.”
File allowlist: Name the one file (or line range) it’s allowed to touch. Everything else: read-only or off-limits.
Tiny tasks > big tasks: Break jobs into micro-steps and paste only what’s needed for that step.
Avoid auto steering docs: Skip the auto-generated trio; they nudged Kiro into “I’ll do all the things” mode.
Wishlist for Kiro
Context meter: Live view of context remaining within a chat, ideally in tokens, more detailed view on what calls Kiro decided to make and how much of that limit that used.
Token usage: Show overhead to help steer prompting and estimate costs.
Scoped context controls: Choose file + line ranges (e.g.,
utils.py:10-45) and prevent full-file ingestion without copy/paste. Or at the very least, improve the context search so it doesn’t look through everything and all files again.Workspace scan settings: Off / on-demand / changed-files-only with include/exclude globs and cached indexing.
Better steering: Less internal steering or more fine grained control and more customization to the user so I can truly change behavior and use Kiro in the way I want and how it works for me, without being limited by conflicting system prompts.