hckrnws

Important details from the FAQ, emphasis mine:

> For users who access Kiro with Pro or Pro+ tiers once they are available, your content is not used to train any underlying foundation models (FMs). AWS might collect and use client-side telemetry and usage metrics for service improvement purposes. You can opt out of this data collection by adjusting your settings in the IDE. For the Kiro Free tier and during preview, your content, including code snippets, conversations, and file contents open in the IDE, unless explicitly opted out, may be used to enhance and improve the quality of FMs. Your content will not be used if you use the opt-out mechanism described in the documentation. If you have an Amazon Q Developer Pro subscription and access Kiro through your AWS account with the Amazon Q Developer Pro subscription, then Kiro will not use your content for service improvement. For more information, see Service Improvement.

https://kiro.dev/faq/

To opt out of sharing your telemetry data in Kiro, use this procedure:

1. Open Settings in Kiro.

2. Switch to the User sub-tab.

3. Choose Application, and from the drop-down choose Telemetry and Content.

4. In the Telemetry and Content drop-down field, select Disabled to disable all product telemetry and user data collection.

source: https://kiro.dev/docs/reference/privacy-and-security/#opt-ou...

Is there a way to confirm this works or do we just have to trust that settings will be honored?

Just like using an AI model, you can’t actually know for sure that it won’t do anything malicious with what interfaces you give it access to. You just have to trust it.

Well, you can at least check if there is network traffic to AWS or something similar.

But wouldn't that look the same as actually querying the model? Or am I missing the joke?

There’s always ways to mitigate malicious behaviour once it’s already happening.

As for everything else: trust, possibly enhanced by the fear of consequences for the other party.

How do we know if random internet service sells our email / password pair? They probably store the hashed password because it's easier (libraries) than writing their own code, but they get it as cleartext every time we type it in.

> How do we know if random internet service sells our email / password pair? They probably store the hashed password because it's easier (libraries) than writing their own code, but they get it as cleartext every time we type it in.

For that, we can just use a unique password per service. That's not really a thing for code.

> How do we know if random internet service

Audits. Obviously not every service is going to be in a jurisdiction that proactively audits data processors and controllers. Another thing to consider before you hand over your data.

You could place some unique strings in your code, and test it to see if they appear as completions in future foundation models? Maybe?

I am nowhere near being a lawyer, but I believe the promise would be more legally binding, and more likely to be adhered to, if money was exchanged. Maybe?

The "Amazon Q Developer Pro" sub they mention appears to be very inexpensive. https://aws.amazon.com/q/pricing/

This brings up a tangential question for me.

Clearly, companies view the context fed to these tools as valuable. And it certainly has value in the abstract, as information about how they're being used or could be improved.

But is it really useful as training data? Sure, some new codebases might be fed in... but after that, the way context works and the way people are "vibe coding", 95% of the novelty being input is just the output of previous LLMs.

While the utility of synthetic data proves that context collapse is not inevitable, it does seem to be a real concern... and I can say definitively based on my own experience that the _median_ quality of LLM-generated code is much worse than the _median_ quality of human-generated code. Especially since this would include all the code that was rejected during the development process.

Without substantial post-processing to filter out the bad input code, I question how valuable the context from coding agents is for training data. Again, it's probably quite useful for other things.

The human/computer interaction is probably more valuable than any code they could slurp up. Its basically CCTV of people using your product and live-correcting it, in a format you can feed back into the thing to tell it to improve. Maybe one day they will even learn to stop disabling tests to get them to pass.

[dead]

I think it's less about the code output, but about the process of humans iterating and adjusting the LLM-drafted requirements and design. Claude Code et al. are good enough, the bottleneck is IMO usually the context and prompt by now. So further improving that by optimizing for and collecting data about the human interaction seems like a good strategy to me.

Essentially, the user labels (accept/edit) data (design documents) for the agent (amazon)

There is company, maybe even a YC company, which I saw posting about wanting to pay people for private repos that died on the vine, and were never released as products. I believe they were asking for pre-2022 code to avoid LLM taint. This was to be used as training data.

This is all a fuzzy memory, I could have multiple details wrong.

I suspect the product telemetry would be more useful - things like success of interaction vs requiring subsequent editing, success from tool use, success from context & prompt tuning parameters would be for valuable to the product than just feeding more bits into the core model.

This is the inevitable decline where we all eventually don't care about the source code instructions anymore, just like the transition from assembly to C. Sorry in advance, I'm a privacy holdout too, but this isn't the interesting part of what's happening. I tried Kiro and it is on par with Claude or Crystal, nothing special at all.

Within the next couple of years there's going to be a 4-for-1 discount on software engineers. Welcome to The Matrix. You'd best find Morpheus.

Check out the comments on https://news.ycombinator.com/item?id=44567857 and tell me what the alternative future is. Best wishes and good luck.

> your content is not used to train any underlying foundation models (FMs).

This implies your "content" may be used for anything else, including training non-foundation LLMs. Frankly, even if their disclaimer were broader, I'd still probably not trust them.

As you shouldn't! Only a rube trusts a rule for which there is no real enforcement or punishment is a mere fine. If the erosion of consumer privacy has not taught us that simply stating "we won't use/sell your data" is the biggest lie of the 21st century, then I don't know what will.

The well-poisoning effect is especially strong in the AI space based on how blatant the big players have been in disregarding intellectual property law and how their crawlers behave like DDOS bot farms.

Hello folks! I've been working on Kiro for nearly a year now. Happy to chat about some of the things that make it unique in the IDE space. We've added a few powerful things that I think make it a bit different from other similar AI editors.

In specific, I'm really proud of "spec driven development", which is based on the internal processes that software development teams at Amazon use to build very large technical projects. Kiro can take your basic "vibe coding" prompt, and expand it into deep technical requirements, a design document (with diagrams), and a task list to break down large projects into smaller, more realistic chunks of work.

I've had a ton of fun not just working on Kiro, but also coding with Kiro. I've also published a sample project I built while working on Kiro. It's a fairly extensive codebase for an infinite crafting game, almost 95% AI coded, thanks to the power of Kiro: https://github.com/kirodotdev/spirit-of-kiro

> It's a fairly extensive codebase for an infinite crafting game, almost 95% AI coded, thanks to the power of Kiro: https://github.com/kirodotdev/spirit-of-kiro

This, along with the "CHALLENGE.md" and "ROADMAP.md" document, is an incredibly cool way to show off your project and to give people a playground to use to try it out. The game idea itself is pretty interesting too.

It would be awesome if I ... didn't have to deal with AWS to use it. I guess maybe that might be a good use case for agentic coding: "Hey, Kiro - can you make this thing just use a local database and my Anthropic API key?"

Complaining aside though, I think that's just such a cool framework for a demo. Nice idea.

Thanks a lot! I plan to fork the project and make a generic version that runs entirely locally using your GPU to do everything. My early tests ran pretty well on NVIDIA 5070. So that's next on my project list to open source in my free time. The only thing more fun that building an AI agent, is using it to build your own ideas!

5070Ti user here: We are 150 people in a SME and most of our projects NDA for gov & defense clients absolutely forbid us to use any cloud based IDE tools like GitHub Copilot etc. Would love for this project to provide a BYOK and even Bring Your Own Inference Endpoint. You can still create licensing terms for business clients.

What models do you use that you've found to be powerful enough to be helpful?

I have the same question, do you use already an on prem RAG system?

I don't know if this is feedback for Kiro per se or more feedback for this category of applications as a whole, but I've personally noticed that the biggest barrier holding me back from giving an earnest look at new coding agents are the custom rules I've set up w/ my existing agents. I have extensively used Copilot, Continue, Cursor, Cline, Aider, Roo Code, and Claude Code. I've just finished porting my rules over to Claude Code and this is something I do not want to do again [even if it's as simple as dragging and dropping files].

Companies would benefit a lot by creating better onboarding flows that migrate users from other applications. It should either bring in the rules 1:1 or have an llm agent transform them into a format that works better for the agent.

You will be happy to find out that Kiro is quite good at this! One of my favorite features is "Steering Rules". Kiro can help you write steering rules for your projects, and the steering rules that it auto generates are actually super great for large projects. You can see some examples of auto generated steering files here in one of my open source projects: https://github.com/kirodotdev/spirit-of-kiro/tree/main/.kiro...

Also these steering rules are just markdown files, so you can just drop your other rules files from other tools into the `.kiro/steering` directory, and they work as is.

“I really don’t want to do X”

“Kirk is actually quite good at this: you just have to do X”

“…”

At the prompt: "I have extensively used Copilot, Continue, Cursor, Cline, Aider, Roo Code, and Claude Code. I do not want to move my files over again for Kiro [even if it's as simple as dragging and dropping files]. Do it for me"

Kiro will do it for you automatically.

And then you have two separate specifications of your intent, with the ongoing problems that causes. It’s not the same thing.

Porting rules is one of the responsibilities of keeping them.

Yeah it would be nice if there was one way to specify the rules and intent, but you know how these things go: https://xkcd.com/927/

In all seriousness, I'm sure this will become more standardized over time, in the same way that MCP has standardized tool use.

I've long been interested in something that can gather lightweight rules files from all your subdirectories as well, like a grandparent rule file that inherits and absorbs the rules of children modules that you have imported. Something kind of like this: https://github.com/ash-project/usage_rules

I think over time there will be more and more sources and entities that desire to preemptively provide some lightweight instructive steering content to guide their own use. But in the meantime we just have to deal with the standard proliferation until someone creates something amazing enough to suck everyone else in.

There should be a standard rule format in a standard place, like ~/.config/llms/rules.md

> There should be a standard rule format

We are a few months into widespread use of this class of technology. Now is a terrible time to introduce standards. Would be a small short term gain delivering huge long term pain.

.vibecodingrc sounds better?

this. We need a common file for all these tools. It's not like they can not read the format of each other.

This comment gets downvoted a lot and I can not figure why. Is the idea that agentic AI solutions could use single common file for the directions misguided or did I put the message together wrong?

It would sure be nice to have some standardized conventions around this. AGENTS.md etc. It seems insane to have to have multiple files/rules for essentially the same goals just for different tools.

Thats the convention I am using.

My CLAUDE.md and GEMINI.md both just say "See AGENTS.md".

Have you heard about symlinks yet?

The idea of having a bunch of A100 GPU cycles needed to process the natural language equivalent of a file pointer makes me deeply sad about the current state of software development.

This take reminds me of the pain I experience when I watch people type website addresses into the google search box

Are you implying frontier models are running on a100s? Certainly not

Same

How about:

Creating a MCP server that all the agents are configured to retrieve the rules from?

Then you have to add a rule to every agent to tell it to use this tool.

symlinks

Good coding and #prompting hack for coding. Imagine you have a large codebase and you work with other people and you want version control your .cursor folder. Just symlink it to another folder and version control that folder.

I just have a “neutral” guidance markdown setup written in a repo.

Then I add it as a git submodule to my projects and tell whatever agents to look at @llm-shared/ and update its own rule file(s) accordingly

I don't add them as submodule but just symlink and ignore them globally so they never find their way into codebase; I have colleagues that frown upon using LLMs, and. I am not going to start a war over their preferences.

Or a proper standard like MCP was for agentic tool use, this time for context setup...

Problems w auth / security in MCP skeeve me out. For that reason, I really don't want to invest in workflows that depend on MCP and have steered clear. But I'd be grateful for well-informed comments / advice on that front.

As for a hypothetical new "context setup" protocol like you posit, I suspect it'd benefit from the "cognitive tools" ideas in this awesome paper / project: <https://github.com/davidkimai/Context-Engineering>

^ inspiring stuff

Agents.md is at least used by both codex and GitHub copilot. VSCode has its own thing for instruction files and Claude.md is also its own thing :(

My Claude.md is a symlink to agents.md.

and opencode

and cline (.clinerules)

I mean opencode reads AGENTS.md

Not Kiro related, but do your Claude Code version of rules end up as CLAUDE.md files in various locations?

so I started off by doing this - having a single claude.md file but in it putting references to paths to other instruction files.

I found this approach to be quite poor from the standpoint of cloud seems to treat user instructions very differently than other agentic code assistants and I think it’s because their system prompt is so long. As a result, I’m getting some pretty poor adherence to my claude.md file and I’ve noticed that very rarely if ever have I seen it reverse the file to any of the nested paths.

So.. im going to try to refactor my files to keep it all in the same file, with some heavy “LOOK AT ME” prompt engineering.

How about you?

in the early days of building something like that, would love to talk for 10 minutes and get your advice if you have the time? I couldn't find your email but mine is in my profile.

> have an llm agent transform them into a format that works better for the agent.

you can do this today though.

AFAICT there is no “format” to agent rule files; it’s just text describing how you’d like the LLM to behave. Typically I’ve seen bullet lists.

Some agents have multiple prompts that are used for different modes; I’ve typically seen this stored as JSON that is agent specific and wouldn’t necessarily apply to different agents.

The only agent specific thing I’ve ever included in a context file is referring to a specific tool. I probably could have abstracted that by describing it as “the tool that does X” or by just telling it to do the function that the tool does.

Is it something similar to Harper Reed's "My LLM codegen workflow atm"?

https://harper.blog/2025/02/16/my-llm-codegen-workflow-atm/

Actually yes! I saw this post some months ago, and thought to myself: "Wow this is really close to what we've been building". Kiro uses three files though: requirements, design, and then tasks. The requirements doc is a bunch of statements that define all the edge cases you might not have originally thought of. Design looks at what is currently in the code, how the code implementation differs from the requirements, and what technical changes need to happen to resolve the difference. Then tasks breaks the very large end to end development flow up into smaller pieces that an LLM can realistically tackle. The agent then keeps track of it's work in the tasks file.

Realistically, I don't think that Harper's statement of "I get to play cookie clicker" is achievable, at least not for nontrivial tasks. Current LLM's still need a skilled human SDE in the loop. But Kiro does help that loop run a lot smoother and on much larger tasks than a traditional AI agent can tackle.

Thank you, I will certainly check this out because this is something I've been sort of doing, manually, but I am still struggling to get the right workflow.

This recent OpenAI presentation might resonate too then:

Prompt Engineering is dead (everything is a spec)

In an era where AI transforms software development, the most valuable skill isn't writing code - it's communicating intent with precision. This talk reveals how specifications, not prompts or code, are becoming the fundamental unit of programming, and why spec-writing is the new superpower.

Drawing from production experience, we demonstrate how rigorous, versioned specifications serve as the source of truth that compiles to documentation, evaluations, model behaviors, and maybe even code.

Just as the US Constitution acts as a versioned spec with judicial review as its grader, AI systems need executable specifications that align both human teams and machine intelligence. We'll look at OpenAI's Model Spec as a real-world example.

https://youtu.be/8rABwKRsec4?si=waiZj9CnqsX9TXrM

You know what an executable spec is? Source code.

That's a compelling three file format.

Have you considered a fourth file for Implemented such that Spec = Implemented + Design?

It would serve both as a check that nothing is missing from Design, and can also be an index for where to find things in the code, what architecture / patterns exist that should be reused where possible.

And what about coding standards / style guide? Where does that go?

That is interesting. So far we are just using the task list to keep track of the list of implemented tasks. In the long run I expect there will be an even more rigorous mapping between the actual requirements and the specific lines of code that implement the requirements. So there might be a fourth file one day!

Coding standards / style guide are both part of the "steering" files: https://kiro.dev/docs/steering/index

Why build an editor and not a CLI. VS code is really slow for me and I would have preferred a CLI.

They already have a CLI that is similar to Claude Code: Amazon Q CLI, you can download it here: https://github.com/aws/amazon-q-developer-cli

It actually has a pretty decent free tier, and maybe the subscription is better value than Claude Code, but hard to tell.

It uses the same models as Claude Code. I've been using Q CLI a lot and love it, but I'm amazed by what Claude Code can do.

There are still people not even using an editor, but rather using vibe-coding apps like lovable.

Also,I don't mean to be rude to cursor but the fact that they are literally just a vscode wrapper still, to this day makes me really crazy thinking that the value of an AI editor could be so high..

I think it was the lack of competition really, Cursor (IMO) always felt like the biggest player, I think there was continue.dev before that, but that's all I know before Cursor.

After Cursor became a hit, there are lot more things now like (Void editor?) etc.

Also, if you Find Vscode editor slow, try zed. But like my brother said to me when I was shilling zed, Vscode is just for manipulating texts and using LSP. He personally didn't feel like it was there any meaningful slowness to Vscode even though he had tried zed. Zed has Ai stuff too iirc

Now Sure, they could've created CLI, but there are a lot of really decent CLI like SST/opencode and even gemini cli. Though I have heard good things about claude code too.

Honestly, I just think that any efforts in anything is cool. I just like it when there are a lot of options and so things stay a little competitive I guess.

> just a vscode wrapper

Isn't that like all software. Before Claude 4 and Copilot agent mode, Cursor/Cline did a lot of work under the hood to achieve the same agentic capabilities, that stuff has nothing to do with VSCode.

Stay tuned! I think there is definitely room for a CLI version as well. That said, IDE's have a significant advantage over CLI because of the features available to them. For example, the reason why IDE's feel "slow" is often because they just come with more features: automatic linters and code formatters, type checkers, LSP servers.

An agent running in the IDE can make use of all this context to provide better results. So, for example, you will see Kiro automatically notice and attempt to resolve problems from the "Problems" tab in the IDE. Kiro will look at what files you have open and attempt to use that info to jump to the right context faster.

The way I describe it is that the ceiling for an IDE agent is a lot higher than a CLI agent, just because the IDE agent has more context info to work with. CLI agents are great too, but I think the IDE can go a lot further because it has more tools available, and more info about what you are doing, where you are working, etc

> For example, the reason why IDE's feel "slow" is often because they just come with more features:

IDEs don't feel slow, they ARE slow

because written in HTML and Javascript

go and try Delphi from 2005, it's blazing fast (and more functional...)

Confidently wrong are we? I use VSCode daily with a couple of extensions and it's fast, never stutters and I never have to wait for anything, so I'm not sure where you pulled that one from.

It's not an IDE, and it's actually pretty sluggish.

I'm surprised none of them have built on Zed yet

Rust is too hard when you can quickly fork vscode and hack together enough JavaScript to hopefully get acquired before the moat evaporates.

That's all old news. Claude Code and even Amazon Q CLI can leverage all this context through MCP as well, with connecting to LSP servers, computing repo-maps or code indexes, integrating with linters, etc.

In my opinion, CLIs have a higher ceiling, and then they are easy to integrate into CI/CD, run them in parallel, etc.

MCP is great, but it adds a lot of extra latency. The MCP servers themselves will stuff your context full of tool details, taking up valuable tokens that could be spent on code context. Then at runtime the LLM has to decide to call a tool, the tool call has to come back to your machine, the data is gathered and sent back to the LLM, then the LLM can act on that data. Multiply this by however many rounds of tool use the LLM decides it needs prior to taking action. If you are lucky the LLM will do a single round of parallel tool use, but not always.

The advantage of something more purpose built for gathering context from the IDE is that you can skip a lot of roundtrips. Knowing the user's intent upfront, the IDE can gather all the necessary context data preemptively, filter it down to a token efficient representation of just the relevant stuff, add it in the context preemptively along with the user's prompt, and there is a single trip to the LLM before the LLM gets to work.

But yeah I agree with your point about CLI capabilities for running in parallel, integrating in other places. There is totally room for both, I just think that when it comes to authoring code in the flow, the IDE approach feels a bit smoother to me.

I feel what you say is true only for auto-complete, which is no longer the ideal workflow for agentic coding. Otherwise the IDE doesn't know what it should include or not in the context, and you need an AI model to determine that.

What people do to avoid what you discussed, is multi-agents. The main agent can build up context, plan, than delegate execution to other agents, etc.

In my opinion, the benefit of the IDE is really just in the possibility of an improved UI/UX over a TUI.

It’s so much easier for me to prompt by:

- cmd-t fuzzy finding files of cmd-p finding symbols to open the various files that are relevant

- selecting a few lines in each file using fast IDE shortcuts to move and add

- drag and drop an image or other json files into prompt

- not leave the editor im already working on

Not to mention:

- viewing the agents edits as a diff in the editor and all the benefits of easily switching between tabs and one click rejecting parts etc

- seeing the sidebar of the agents thoughts and progress async alongside the code as I keep looking at things

- pausing the agent and reversing back steps visually with the sidebar

- not having to reconfig or setup my entire dev environment for some CLI - for example the biome v2 lsp just works since it’s already working in code which has the best support for these things

And really the list of reasons an editor is far better just never ends. Claude is ok, but I’m way way faster with Cursor when I do need AI.

To each their own, and I absolutely agree with the prior poster about both existing making a lot of sense. It comes down to personal preference. I just wanted to point out the CLI has no less support for feature and context, just a different UX to them.

The next level of features I want from Claude Code is LSPs built right into it, rather that something I have to configure with some random MCP server I download from some random place.

What kind of toaster are you running vscode on, it runs about as fast as any basic text editor even in VMs for me.

Have you documented how you built this project using Kiro? Your learnings may help us get the best out of Kiro as we experiment with it for our medium+ size projects.

I've got a longer personal blogpost coming soon!

But in the meantime I'm also the author of the "Learn by Playing" guide in the Kiro docs. It goes step by step through using Kiro on this codebase, in the `challenge` branch. You can see how Kiro performs on a series of tasks starting with light things like basic vibe coding to update an HTML page, then slightly deeper things like fixing some bugs that I deliberately left in the code, then even deeper to a full fledged project to add email verification and password reset across client, server, and infrastructure as code. There is also an intro to using hooks, MCP, and steering files to completely customize the behavior of Kiro.

Guide link here: https://kiro.dev/docs/guides/learn-by-playing/

Nicely done. I particularly like the emphasis on writing specs which really is something new in the space and makes Kirk not just “Cursor clone”. This is something missing in Claude Code… the user needs to remember to ask Claude to update the specs.

How does Kirk deal with changes to the requirements? Are all the specs updated?

Currently specifications are mostly static documents. While they can be refreshed this is a more manual process, and if you do "vibe coding" via Kiro it can make code changes without updating the specs at all.

I find the best way to use specs is to progressively commit them into the repo as an append only "history" showing the gradual change of the project over time. You can use Kiro to modify an existing spec and update it to match the new intended state of the project, but this somehow feels a bit less valuable compared to having a historical record of all the design choices that led from where you started to where you now are.

I think in the long run Kiro will be able to serve both types of use: keeping a single authoritative library of specs for each feature, and keeping a historical record of mutations over time.

Is this being powered by any specific model?

>overage charges for agentic interactions will be $0.04 per interaction, and if enabled, will begin consuming overages once your included amounts are used (1,000 interactions for Pro tier, 3,000 for Pro+ tier). Limits are applied at the user level. For example, if you are a Pro tier customer who uses 1,200 requests, your bill would show an overage charge of $8 (200 × $0.04). Overages for agentic interactions must be enabled prior to use.

What is defined as an interaction?

EDIT: RTFM

>Whenever you ask Kiro something, it consumes an agentic interaction. This includes chat, a single spec execution, and/or every time an agent hook executes. However, the work Kiro does to complete your request—such as calling other tools, or taking multiple attempts—does not count towards your interactions.

There is a model picker that currently allows you to switch between Claude Sonnet 4.0 and Claude Sonnet 3.7

And yes, Kiro is agentic, so it can (and often does) execute a long running multi-turn workflow in response to your interactions, however, the billing model is based on your manual interaction that kicks off the workflow (via chat, spec, or hook), even if that agent workflow takes many turns for Kiro to complete

Ah yes the classic Cline setup, you can choose any model as long as it's Claude. Anthropic has to be really making API bank these days.

Hello! What is the connection with AWS? Do you work for AWS? Is this going to be some official AWS product, backed by Amazon Q or Bedrock?

Kiro is created by an AWS team, and originates from AWS expertise. We are using Kiro internally as one of our recommended tools for development within AWS (and Amazon). So Kiro is an official AWS product, however, we are also keeping it slightly separated from the rest of core AWS.

For example, you can use Kiro without having any AWS account at all. Kiro has social login through Google and GitHub. Basically, Kiro is backed by AWS, but is it's own standalone product, and we hope to see it grow and appeal to a broader audience than just AWS customers.

This is a really interesting setup. If it's not too forward to ask, how is the team structured in terms of incentives? Is Kiro fully within the AMZN comp / RSUs structure, or does it operate more like a spinout with potential for more direct upside? I’m always curious how teams balance the tradeoff between the support of a big org vs having more control over your fate by going fully independent.

this kinda speak about how anti-DX AWS is

Seems like social login isn't working for me on OSX. Just downloaded Kiro, clicked the Google option, allowed the app, and then get redirected back to http://localhost:3128/oauth/callback with an error "Error: AuthSSOServer: missing state".

Can you please report an issue on our GitHub Issue tracker: https://github.com/kirodotdev/Kiro/issues?

Or can you join the Discord and message me directly @swaminator

Thanks for the report! I'll keep an eye on it. So far we aren't seeing any other reported issues, so it's possible that a browser extension, or something else in your setup is messing with the SSO flow.

Redirect back to localhost:3128 is normal, that's where Kiro is watching for a callback, but the missing state is not normal. Something may have stripped the info out of the callback before it occurred, which is why I suspect an extension in your browser.

Will keep an eye on this though!

It is also not working for me, this opens http://localhost:3128/oauth/callback?code=... but on Kiro interface I see "There was an error signing you in. Please try again"

Same error as the others. Looks like auth is successful in popup window: "You can close this window".

Then in Kiro I see "There was an error signing you in. Please try again.".

FWIW, I've tried GitHub & Google, in different browsers, on different networks.

For me, it was Little Snitch blocking the request..

FWIW Github login worked, only extensions I run is a password manager and Kagi.

After you said that google login didn't work, since I had also used github login, I wanted to tell that github login had worked for me, but you beat me to it!

I think Auth can be a bit of mess, but yes Its still absolutely great that I can just login with github and it just works, I am trying out Kiro right as we speak!

Thanks for the additional info!

[dead]

FYI: I'm trying Kiro out now, and the IDE keeps popping open the integrated terminal window of its own accord. Has done it multiple times, including when I don't even have the IDE window focussed on my desktop. Every 5-10 minutes it seems.

Neither VSCode nor Cursor do this, so even if it's an extension triggering it somehow, the behaviour in Kiro is different to those other two.

Hi Nathan, this is awesome. I also discovered similar workflows and built SpecLinter: https://github.com/orangebread/speclinter-mcp

Will be trying Kiro, excited to see how you approached implementing a similar idea!

While I like the product, implementation could be better. Kiro is sitting idle with Helper Plugin using a shitload of CPU for no reason.

A few things:

1) It's normal for Kiro (and almost every AI editor) to use a lot more CPU when you first start it up, because it is indexing your codebase in the background, for faster and more accurate results when you prompt. That indexing should complete at some point

2) On initial setup of Kiro it will import and install your plugins from VS Code. If you have a large number of plugins this continues in the background, and can be quite CPU heavy as it extracts and runs the installs for each plugin. This is a one time performance hit though.

3) If your computer is truly idle, most modern CPU's get throttled back to save power. When the CPU is throttled, even a tiny amount of CPU utilization can show up as a large percentage of the CPU, but that's just because the CPU has been throttled back to a very slow clock speed.

In my setup (minimal plugins, medium sized codebase, computer set to never idle the processor clock) I rarely see Kiro helper go above .4% CPU utilization, so if you are seeing high CPU it is likely for one of the above reasons.

Thanks for the reply. It was the indexing.

Is there any way to control this? I have my files.watcherExclude setting, does it respect that?

I believe that the file indexing exclusion is based on .gitignore, not files.watcherExclude, but let me check on that and confirm.

I tried with a small project, it worked fine, no high CPU usage.

However with a large project, it seems that it indexed, then dropped CPU, then I started opening up files and working with them, then the CPU spiked again.

I'll look into this. Kiro is supposed to be doing progressive reindexing. When you make a change it should only have to reindex the files that changed. If you have any logs or other data you are willing to share, to help the team investigate you can use the "report a bug / suggest an idea" link at the bottom, or open an issue at: https://github.com/kirodotdev/Kiro/issues

I ironically don't have a github account (use my own personal gittea). However I don't think its the indexing. I left Kiro open for a day, and CPU usage is still high.

Having ten "Electron Helper (Plugin)" eat a GB of RAM each on idle is the premier desktop experience nowadays. We can't have native apps any more: we don't know how to build them.

It's not that people don't know how to build a native application, it's rather a native application that runs across Windows, Mac and Linux is still really hard. Trying to add in a web version of the same application is impossible.

ActiveX and Java Web Start, etc all tried to do this, and all of them ended up deprecated and out of favor for native web solutions.

Java IDEs did a lot of this for many years (Eclipse, IntelliJ, NetBeans, JDeveloper, etc) and they worked reasonably well on the desktop, but had no path to offering a web hosted solution (like gitpod or codespaces)

There are not a lot of options here, compiling down a native solution to wasm and running it in the browser would work, I'm not sure if the performance would be substantially better or more consistent across all OS'es and web unfortunately.

So we are where we are :)

>it's rather a native application that runs across Windows, Mac and Linux is still really hard.

Not really. Electron is basically web browser.

The issue is that a cornerstone of modern development is basically "don't rewrite what already has been written", however the problem is that you always get optimization creep because of this - people just build shit on top of other shit continuously and never go back and optimize.

> It's not that people don't know how to build a native application, it's rather a native application that runs across Windows, Mac and Linux is still really hard. Trying to add in a web version of the same application is impossible.

Qt is pretty good at this actually. I don’t have a Mac, but building the same codebase for windows, linux, and a wasm target was pretty neat the first time I did it.

I use VSCode with Continue. It has a Code Helper Plugin, which peaks during use, but when idle it doesn't use any resource. Something is up with the Kiro version where some background task is running.

See the NathanKP comment on the (grand parent post?), It was the indexing which was causing the resource utiliazation.

For a large project, it seems to still be using high CPU (maybe continuously indexing)

Fortunately the next generation seems to be CLI based! Maybe we'll go back to native apps in the next generation.

Zed exists.

I genuinely thought we have enough RAM since the 16GB era. Nope, they figured out a way to consume it all plus a dozen of GB in swap.

Does it work for Swift development and can it compile to test for compilation errors?

Hello Nathan,

I integrated[1] the recently released Apple Container (instead of shell) to run codes generated by Kiro. It works great!

1. CodeRunner: https://github.com/BandarLabs/coderunner

Can you please stop shilling for this?

HN comments aren't an ad network...

Is this supposed to be a demo of how wide-ranging Kiro is or how accurate it is? Because the very first item in the screenshots is in a superposition of conflicting states from various parts of its description.

That said, thanks for being willing to demo what kinds of things it can do!

nice! Can't agree more on Vibe Speccing.

I wrote more about Spec Driven AI development here: https://lukebechtel.com/blog/vibe-speccing

Can you comment on how the IDE performs on large codebases? Does the spec based approach help with it? Any examples you can give from experience at Amazon?

It works great in really large codebases!

I've published a sample project that is medium sized, about 20k lines encompassing a game client, game server, and background service: https://github.com/kirodotdev/spirit-of-kiro This has been all developed by Kiro. The way Kiro is able to work in these larger projects is thanks to steering files like these:

- Structure, helps Kiro navigate the large project: https://github.com/kirodotdev/spirit-of-kiro/blob/main/.kiro...

- Tech, helps Kiro stay consistent with the tech it uses in a large project: https://github.com/kirodotdev/spirit-of-kiro/blob/main/.kiro...

And yes, the specs do help a lot. They help Kiro spend more time gathering context before getting to work, which helps the new features integrate into the existing codebase better, with less duplication, and more accuracy.

why it required forking vscode? what prevents this from being just extension? from article I do not see any obvious functionality that would prevent such implementation

Maybe the fact that MSFT has been break extensions for fork is enough?

Love the game! would be interesting to see an example of prompts used to do this.

Unfortunately, midway through the project I lost the file where I was keeping track of all the prompts I used as I built. I do have some of them, plan to publish a wrap up analysis of those at some point.

If you were referring to the prompts inside of the game, you might find those fun and interesting. This one in particular is the heart of the game: https://github.com/kirodotdev/spirit-of-kiro/blob/main/serve...

Are there plans to let AWS customers hook this up to Bedrock / use models through that?

At this time Kiro is a standalone product that does not require an AWS account at all. Kiro is powered by Bedrock behind the scenes, but it has a layer of abstraction between Kiro and Bedrock, which includes system prompts and additional functionality. I can definitely take this as a feature request though!

If this integrated with AWS for billing, usage, and IAM purposes it would be a no brainer to have my team trying this out today.

You can do that!

There is an AWS IAM Identity Center option for login as well: https://kiro.dev/docs/reference/auth-methods/#aws-iam-identi...

We really need to add some more step by step docs for setting this up, but it's very similar to the Amazon Q Developer integration with AWS IAM Identity Center if you are familiar with that: https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/sec...

Nice, I’ll have to put my (employer’s) money where my mouth is and try it out tomorrow. Thanks!

Why not deploy the game? I'd love to try it

I have a personal deployment of the game, but it costs money to run the LLM so I'm not sharing that with all of Hacker News haha. I've got an appsec ticket open to host an "official AWS" version where AWS pays the LLM bill, but that might take a while longer to get approved. For now the best way to experiment is playing with it locally.

I'm also thinking of creating a fork of the project that is designed to run entirely locally using your GPU. I believe with current quantized models, and a decent GPU, you can have an adequate enough fully local experience with this game, even the dynamic image generation part.

How much are you using Kiro to improve itself? 100% of the time? 10% of the time? Never?

It has grown over time as Kiro has developed. Many of the most recent features in Kiro were developed using Kiro specifications. We have a Twitch stream scheduled with some engineers from the Kiro team where we plan to take live Q&A about this in specific, how they are using Kiro to build Kiro, etc. I don't have the schedule setup yet, but we've got the channel setup here: https://www.twitch.tv/kirodotdev

Will the pricing include consideration for if someone if an Amazon Prime subscriber?

> almost 95% AI coded

I think its because you didn't have hard expectations for the output. You were ok with anything that kind of looked ok.

False. In order to maintain high quality I often rejected the first result and regenerated the code with a more precise prompt, rather than taking the first result. I also regularly used "refactor prompts" to ask Kiro to change the code to match my high expectations.

Just because you use AI does not mean that you need to be careless about quality, nor is AI an excuse to turn off your brain and just hit accept on the first result.

There is still a skill and craft to coding with AI, it's just that you will find yourself discarding, regenerating, and rebuilding things much faster than you did before.

In this project I deliberately avoided manual typing as much as possible, and instead found ways to prompt Kiro to get the results I wanted, and that's why 95% of it has been written by Kiro, rather than by hand. In the process, I got better at prompting, faster at it, and reached a much higher success rate at approving the initial pass. Early on I often regenerated a segment of code with more precise instructions three or four times, but this was also early in Kiro's development, with a dumber model, and with myself having less prompting skill.

> precise prompt

If there was such a thing you would just check in your prompts into your repo and CI would build your final application from prompts and deploy it.

So it follows that if you are accepting 95% of what random output is being given to you. you are either doing something really mundane and straightforward or you don't care much about the shape of the output ( not to be confused with quality) .

Like in this case you were also the Product Owner who had the final say about what's acceptable.

> if you are accepting 95% of what random output is being given to you

I am not, and don't expect to be able to do that for many years yet. The models aren't that good yet.

I would estimate that I accepted perhaps 25% of the initial code output from the LLM. The other 75% of output I wasn't satisfied with I just unapplied and retried with a different prompt, or I refactored or mutated it using a followup prompt.

In the final project 95% of the committed lines of code in the published version were written by AI, however there was probably 4x as much discarded AI generated code along the way that was also written by AI. Often the first take wasn't good enough so I modified it or refactored it, also using AI. Over the course of using the project I got better at providing more precise prompts that generated good code the first time, however, I rarely accepted the first draft of code back from Kiro without making followup prompts.

A lot of people have a misguided thought that using AI means you just accept the first draft that AI returns. That's not the case. You absolutely should be reading the code, and iterating on it using followup prompts.

The above is saying more precise not completely precise. The overall point they're making is you still are responsible for the code you commit.

If they are saying the code in this project was in line with what they would have written, I lean towards trusting their assessment.

I am not doubting 95% acceptance rate all. I've pure vibecoded many toy projects myself.

> in line with what they would have written,

point i am making is that they didn't know what they would've written. they had a rough overall idea but details were being accepted on the fly. They were trying out bunch of things and see what looks good based on a rough idea of what output should be.

In a real world project you are not both product owner and coder.

To be clear I did not have a 95% acceptance rate. I'm saying that in the final published repo, 95% of the lines of code were written by AI, not by me. I discarded and refactored code along the way many times, but I did that by also using the AI. My end goal was to keep my hands off the code as much as possible and get better at describing exactly what I wanted from the AI.

[dead]

[flagged]

The original submission to HN stated that it was from Amazon / AWS in the title of the submission, however that has since been edited by a moderator to match the title of the blogpost, which does not mention Amazon / AWS.

To be clear, we have no intent to hide that Kiro is from Amazon / AWS, that's why you'll see Matt Garman, for example, posting about Kiro: https://www.linkedin.com/feed/update/urn:li:activity:7350558...

However, the long term goal is for Kiro to have it's own unique identity outside of AWS, backed by Amazon / AWS, but more friendly to folks who aren't all in on AWS. I'll admit that AWS hasn't been known in recent years for having the best new user or best developer experience. Kiro is making a fresh start from an outsider perspective of what's possible, not just what's the AWS tradition. So, for example, you can use Kiro without ever having an AWS account. That makes it somewhat unique, and we aim to keep it that way for now.

I was at AWS for half a decade. I think a simple, from AWS or Sponsored by AWS, would have been good.

It's in the page footer fwiw. I agree it should be more prominent tho.

[flagged]

Mean and uncalled for. He (they) made a valid observation.

Looks like YC founders bully people coming over to HN for commenting.

since the original comment was _flagged_, i think you're overreacting a bit.

not sure why you brought up YC, not relevant at all

[flagged]

[flagged]

[dead]

Here my problem with this: I don't want to be jumping an editor/IDE every 6 months, learning new key bindings and even more importantly, getting used to a completely new look.

In a space that moves as quickly as "AI" does, it is inevitable that a better and cheaper solution will pop up at some point. We kinda already see it with Cursor and Windsurf. I guess Claude Code is all the rage now and I personally think CLI/TUI is the way to go for anyone that has a similar view.

That said, I'm sure there's a very big user base (probably bigger than terminal group) that will enjoy using this and other GUI apps.

They're all based vscode, so the switching costs are fairly minimal? It'll get worse over time as they diverge, but at the moment they're all fairly similar AFAICT. It's starting to become noticeable that Cursor isn't picking up VSCode enhancements and fixes, but it's still quite minor.

Them all being based on VS Code makes it all the more frustrating to have to switch IDEs to use them.

I just use VSCode with copilot and don't worry about these re-skins. I don't get a lot of time to write code so I certainly don't have time to learn a new IDE for a small boost to my productivity when vscode gets me most of the way already.

If these re-skinned vscode IDEs have any good ideas I'm sure Microsoft will steal them anyway.

only if you use vscode, I think TUIs are a better option since a lot of us use other ides than vscode

Seems like Amazon started making this when Cursor was hot in the market, but now that CLI agents like Claude Code are taking over, Kiro will have an uphill battle.

It’s also not free or unlimited (though throttled) like Cursor and Claude Code using max plan.

I think IDE-based tools like Cursor, VS Code, etc, will win out in the long term, especially as the younger generation grows up.

In the short term though, I think CLI-based tools like Claude Code are taking off because hardcore developers see them as the last "vestige" they have in separating themselves from the "noobs." They know there's still a good portion of the public who don't know how to use the terminal, install packages, or even know what Linux is.

I think what is going to win is a tool independent to your ide to run your agents, it could be a cli or a gui.

You dreaming. The ui is gonna be like google for code. A voice chat and an instruction/search bar that is it. The model is the product

[dead]

Which is kind of ironic since the Amazon Q Developer CLI (which is essentially Claude Code with a slightly different wrapper) was released long before Claude Code and seems to mostly be flying under the radar.

Claude Code really was at the right place at the right time. Cursor started putting new models under their MAX plan that charges per use and I started getting worse results with Cursor over time as they optimized costs. I started looking into Cline/RooCode when Cursor did this because I knew they were in the squeezing customers stage now. I used those for a while with Sonnet thru OpenRouter, but Anthropic had the genius plan of bundling Claude Code with their Max plan. That made a lot of users jump ship from Cursor and the difference is night and day for me. Yes I pay 5 times more than I did with cursor, but still less than using API credits and the results for me have been superior.

Claude Code is what it is because of Claude, TUI or not isn't really the point. What makes IDEs lose to TUIs is that the agentic models can really do more than coding and is evolving toward a hands-off kind of workflow. A clunky IDE is too much for that, but TUI is not the way either. When has TUI ever been mainstream?

Agentic tools of the future will be rich notebook/chat interface that's available in all form factors, which is to say, most likely web/cross platform apps.

You can have an agent loop in your IDE, I don't see why anything makes "IDEs lose to TUIs" there.

If anything, TUIs are the awkward in-between of "human in the loop, but with poor tools" where one side is fully automatic, agents suggesting fixes on issue tracker, and the other is holding-AI's-hand where you review every step one at a time.

I hate trying to copy paste in/out of Claude Code's unnecessarily-cute boxed text input.

Zed's implementation of the agent feedback loop isn't yet as good as Claude Code, but there's nothing inherently IDE-related in the parts that are lacking.

https://zed.dev/docs/ai/agent-panel

I use the TUI for a lot of agentic stuff that is not necessarily coding, from performing some cloud management commands or just dumb things like "where the hell did I alias vim to nvim?". For those things, having to reach out to the IDE is annoying.

And the way I see the future of coding is that should should be able to code from anywhere, mobile, web, your computer. You already have your code on the cloud (most of the time). Neither TUI or IDE works well currently for that.

Not really, even at work I got to test couple different AI solutions and the experience is always slightly different, even if the editor is the same, for the most part. It's the tiny things like using the prompt template, or opening the panel. (I could, of course, make an attempt to customize the keybindings, but why bother when it changes so quickly.)

The entire idea that “I’m too cool to use an IDE” I find kind of dumb. I was using a Turbo C IDE in college in 1994, Visual Studio until 2019 and since then VSCode.

I don’t think “I’m too cool to use an IDE” was the point being made. The point is that having to switch IDEs every time the number one AI coding tool changes would be annoying.

YUP! This is why I've settled on Aider and it's "IDE integration" (watches all files for comments that end in "AI!", which then invokes the AI). I can then use it with whatever editor I prefer. I view the vscode mono-culture as a bad thing. I also like I can use any AI backend I like, which is really how it should be: Vendor lock-in tools are bad, remember?

I guess you lose tab-completion suggestions, but I am not a fan of those compared to 'normal' tab-complete (if backed by an lang server). If I want AI, I'll write a short comment and invoke the tool explicitly.

EDIT: Of course, it really depends an your usecase. I maintain/upgrade C code libs and utils; I really cannot speak to what works best for your env! Webdev is truly a different world.

EDIT2: Can't leave this alone for some reason, the backend thing is a big deal. Switching between Claude/Gemini/Deekseek and even rando models like Qwen or Kimi is awesome, they can fill in each other's holes or unblock a model which is 'stuck'.

This is why you will have to pry vim and my own brain out of my cold dead hands.

It’s not just the IDE but the ML model you are selling yourself to. I see my colleagues atrophy before me. I see their tools melt in their hands. I am rapidly becoming the only person functionally capable of reason on my own. It’s very very weird.

When the model money dries up what’s going to happen?

I dunno. There's also a good chance that you just end up being left behind like graybeards that only wanted to code in C and assembler.

I too am old enough to have seen a lot of unnecessary tech change cycles, and one thing I've noticed about this industry is no matter how foolish a trend was, we almost never unwind it.

> I dunno. There's also a good chance that you just end up being left behind like graybeards that only wanted to code in C and assembler.

All the people I know in the US with those skills make huge amounts of money- at least, the ones who haven't already retired rich.

Yes. The ones who maintain high risk system software that allows all these machines to be able to train LLMs, compile the systems software or maintaining systems that ingest 2% of the worlds traffic are the ones who are making a lot of money out of this.

Not the ones maintaining frontend web apps or "vibe coding".

I get paid a fuck load of money to write C. Your point is?

As for trends, I've been around long enough to have seen this cycle a couple of times...

> I get paid a fuck load of money to write C. Your point is?

My point is there aren't many of you, are there?

All things considered, keeping up with the industry trends is generally a more reliable career path.

Correct but we are never fungible. That’s the trick for a reliable career.

I’ve survived every single layoff season since 1995.

Ironically, Claude Code has me working in lower-level languages with more low-level tools than ever before, simply because of how powerful it is, particularly as a terminal tool. I've always been more of a GUI person, but now the editor I use most often is Helix.

If I've atrophied in certain aspects of my thinking, I honestly think I've more than made up for it in learning how to engineer the context and requirements for Claude Code more effectively and to quickly dive in to fix things without taking my hands off the keyboard and leaving the terminal.

[dead]

Remaining skilled while those around you atrophy is never a bad decision

Every 6 months? It's turning into every two weeks. Sticking with claude code. Its working beautifully for us.

I love Claude Code too, and it definitely has it's place. I think that IDE's have a few advantages over CLI tools though. In specific the IDE has a lot more contextual information such as what files you have open, warnings from linters or type checkers, information from LSP, etc.

I think it is entirely possible to build a fantastic CLI tool for coding, and the CLI tools for coding already work well enough, but there is just more context info available inside of an IDE, therefore the ceiling is higher when working with an agent that runs inside of the IDE. Context is king for LLM results, and IDE's just have more context.

Over time I'm sure we'll see tools like Claude Code support everything that an IDE can do, but for now if you want to reach the same ceiling you still have to glue together a very custom setup with MCP tool use, and that has the downside of introducing additional tool use latency, compared to an IDE that is able to source context directly from the IDE's internal API, and provide that to the LLM nearly instantly.

I use claude code in vscode. Cmd-Esc opens a claude code tab. Then /ide conects to the vscode and it's all like cursor at that point.

Same here - in fact, I just recently cancelled my Cursor subscription because Claude Code + VSCode seems just as good. I think Cursor is a decent product and some of the UX it puts around LLM interaction is helpful - but I just can't really justifying paying Cursor to middleman my requests to LLM providers when Claude Pro is $20 / month.

I have a question. I do not like the concept of "agent mode" for AI. I'm a control freak and I want to control every line that gets committed because I am responsible for it and need to understand/visualize/memorize every part of codebases I work on.

Is Claude Code good for the "ask" flow? No, right?

The old flow before agent mode got added. Select some code, ask questions about it or give an instruction on editing it and then choose to accept the change.

As I understand (I could be wrong), with agent mode, it edits the file for you, no way for you to accept before it does, so you have to manually check the diff, roll back parts you don't want, etc.

Am I right?

Claude Code is definitely more agentic, but you can use it in a variety of ways. In Plan Mode it won't touch the code, and by default it asks you to accept every single diff. With IDE integration you can definitely just highlight some code and ask questions, I don't see why that workflow wouldn't work.

I like aider's solution of encapsulating each edit in a git commit; I hope that gets widely adopted.

Unfortunately aider is showing its age. It is great for what it does, but better LLMs + "agentic" have shown that you can get more in the swe domain.

There was a paper recently where they had an LLM evolve tool harnesses and got ~20% more than w/ aider on the benchmark they used, so it's pretty clear that the models + tools (+better harness) are better than just aider.

1) You can plug in any model into aider 2) It can be quite agentic

> evolve tool harnesses

Claude code & Gemini cli etc. don't do this either

Don't get me wrong, I love aider and I've been using it since the early days. I'm just commenting on the overall "gains" and imo they are higher with the latest tools (claude code, gemini, etc).

As for 1), I agree but you force the model to work within aider's constraints. Claude4 for example excels at the agentic flow and it's better at that than providing the diffs that aider expects.

As for the last sentence, I disagree. They are evolving the stack, and more importantly they are evolving both at the same time, stack + LLM. That's the main reason they all subsidise use atm, they are gathering data to improve both. If I were to place a bet right now, I'd say that provider_tool + provider_LLM > 3rd party tool + same model in the short, medium and long term.

Oh, that's a good point, I misunderstood you to mean: The LLM writes it's own harnesses etc.

Add two lines to CLAUDE.md and claude code can do this as well :)

Each edit as in every little change?

Yes. Then you squash to make real commits.

We tend to allow this. But you can review the diff before you allow it. It seems easier to say "roll that back" or hit esc if you see it doing things you dont like and then correcting it. I have to say the velocity is insane of coding this way. We also commit a LOT and explicitly dont allow claude to push code ever. That way we can roll back if needed, but honestly it's pretty rare to need to. The MAX plan is a must to work this way though.

> As I understand (I could be wrong), with agent mode, it edits the file for you, no way for you to accept before it does, so you have to manually check the diff, roll back parts you don't want, etc.

> Am I right?

With cursor you get reasonably flexible control at many levels. You can have it only suggest changes that you have to apply manually or you can have it make automatic changes with various ways to review, change, reject or accept. I usually have the changes made automatically but don’t accept the changes automatically. Cursor has a UI that lets you review each edit individually, for the whole file or all files. Depending on the situation I will use whichever level is appropriate. The UI also allows you to revert changes or you can ask the AI to undo or rework a change that you just approved so there’s plenty of ways to do large changes without giving up control. There’s also a stop button you can use to interrupt mid-stream if the work it’s doing isn’t what you want. It isn’t flawless but I haven’t found myself in a corner where I couldn’t get back to a happy path.

It could be better. I think the PMs and investors and decision makers at these companies are running with a "we want to replace / automate developers" philosophy, while these tools are actually best at augmenting developers. And so they're sorta builing with this "I'll do everything and ask you for confirmation" (and basically encourage you to give me blanket permission).

In reality these tools would be best if they took a more socratic method, a more interactive pair programming approach. So instead of giving you a blanket diff to accept or refuse or "No, and here's some changes" -- it should be more dialog oriented.

Of all of them so far though, I think Claude Code is closest to this. IF you prompt it right you can have a much more interactive workflow, and I find that most productive.

> As I understand (I could be wrong), with agent mode, it edits the file for you, no way for you to accept before it does, so you have to manually check the diff, roll back parts you don't want, etc.

You’re sort of technically correct but I wouldn’t really describe it this way exactly. You have to proactively accept or reject all changes to your files in some way.

It is almost impossible to accidentally commit code you don’t want.

It’s not really an edit in the same sense as an unstated change. It doesn’t even really do that until you accept the result.

It’s basically saving you a UI step compared to ask mode with basically no downside.

All of these agentic IDEs could just be visual studio code plugins. They’re likely not because how do you secure VC funding for a plugin?

But Continue and a bunch of others literally did that.

The better question is why is there this horrible monoculture in SW startups around raising money through VCs? We need more regular businesses who build something useful and charge a fair price. Period.

More importantly - how do you monetize a plugin?

There are lots of ecosystems where pro users pay for plugins to get extra features. See the ecommerce domain, jetbrains, even ms teams has plugins that are paid.

VSCode has some popular paid plugins like LSPs or some for git.

I dont see why it wouldnt be possible to monetize a VSCode plugin.

I've been thinking about developing a VSIX for Visual Studio 2022 that wraps my typical ChatGPT flow in the intellisense UX.

I don't mind that everyone is all-in with VSCode now, but I already paid $500 for the big-boy version and I've got 20k hours on it.

They have a CLI similar to Claude Code already: https://github.com/aws/amazon-q-developer-cli

Try kilocode - https://kilocode.ai/ Its a VScode extension and allows different LLMs to be used.

people are trying to find a moat that will bind their userbase. Browsers, editors, apps etc. There must be a format that locks users in so they will try them all one after another

Totally agreed, which is why I'm sticking with my editor (neovim) regardless of whatever AI thing is hot and using tools outside/analogous to it, currently claude code

The nice thing about CLI/TUI is that you can keep using your editor or IDE of choice and chat with the AI on the side.

> Here my problem with this: I don't want to be jumping an editor/IDE every 6 months, learning new key bindings and even more importantly, getting used to a completely new look.

You're basically advocating for GNU Emacs: https://github.com/karthink/gptel

Thanks for the link. I'm not an emacs user and I'm more in the search of something like opencode [1], but I think it's not polished enough yet. I actually want to contribute to open source, so maybe I should create my own thing, heh.

[1]: https://github.com/sst/opencode

gptel is great, its one of the must have packages for Emacs and I'm pretty sure that with time it will be one of the reasons to use Emacs like org-mode has been for a long time.

For people wanting to get up and running with vanilla Emacs (instead of a distribution) so that they can try out gptel sometime this week, I recommend emacs-bedrock: https://codeberg.org/ashton314/emacs-bedrock

And for a gptel backend Gemini is the fastest route (excluding something local) from generating an API key to using a LLM in Emacs (for free).

Bonus points because Emacs is useful for things other than coding you can use gptel on your notes or any buffer really to ask/talk about stuff.

CLI -> Voice & Gesture UI

What I like about OpenAI's codex is that it's not an IDE but a web based product that does things asynchronously from your normal workflow. It creates branches and pull requests. And you can iterate with it via git instead of working in the same tool.

So, I can use the tools I use anyway and have AIs adapt to me instead of me having to adapt to new AI powered tools. I'm using a proper IDE (intellij). Me switching to cursor, kiro, or whatever would be an enormously massive downgrade for me. These tools don't come close to the utility and features of what I am used to and depend on. And those new AI tools trying to catch up with Intellij is not their focus or roadmap. I'm not going to wait for that to happen. I need stuff that works now. Not some years after they figure it out. And that includes AI features.

There's a difference between vibe coding where you are sitting on your hands and admiring all the crazy clever stuff the AI does for you that you wouldn't be able to do yourself and working on a system that you've spent years building from scratch with AI to assist you. I do the latter. I'm constantly intervening, dismissing poor results from AI, getting frustrated with LLMs misunderstanding things, ignoring my directions, not getting the full context, etc. But I'm also getting a lot of value out of AIS with dealing with tedious/repetitive stuff, figuring out weird bugs, pointing out my mistakes, or generating perfectly usable solutions for TODOs and FIXMEs I leave in my code. About 50-60% of the PRs codex creates for me are pretty usable.

I use ChatGPT for the small stuff (it can look at intellij and apply diffs) and codex for the bigger stuff "implement foo, add some tests, and tell me when I can look at the PR". And maybe I'll check out the branch and fix a few things myself. That's something my IDE supports very well. It's not a big deal. It doesn't need to be fixed.

I find that increasingly, model quality is not the main blocker for this stuff but the developer/user experience is. Claude might be better. But chat gpt has the far better UX. And I don't even use o3 most of the time. I prefer the more rapid responses other faster models give me. It's not a cost thing but a speed thing. I only escalate to slower models when I don't like the response I'm getting. Codex is nice but slooooooow. But at least I can work on other stuff while it is doing its thing. ChatGPT gives me instant gratification. Select line, Option+shift+1, "Fix this", "....", "apply fix". That's so nice and I do that a lot. And I didn't have to replace my tools. In the same way, Claude code might be marginally better at some stuff. But the Codex developer experience is superior.

So, Kiro sounds like a nice tool for people who don't need or use IDEs. But it's not for me.

IDEs are here to stay, I built an AI plugin for IntelliJ for that reason (https://sweep.dev/)

> learning new key bindings

Why are they shipping them with different key bindings? Seems like the opposite of what you do to encourage product adoption.

this project was conceived when cursor was the king of vibecoding. Everyone thought being an IDE would give you so much more power.

I love the emphasis on specs here; this is something I do with Claude Code (maintain a set of specs in text as we work).

I always keep the readme and some basic architecture docs (using markdown/mermaid) updated as I go, and I often just work on those rather than on code with Claude, because I find the value it offers is less in code generation and more in helping me document the rubber ducking process into useful schematics and architecture.

What can Kiro offer that's meaningfully better than what I'm already doing? I can take my system anywhere Claude Code and my repos can go, using whatever editor I like. Does Kiro have some special sauce for making this approach work better? Maybe some DSL it uses for more succinct and actionable diagrams and plans?

As much as I like the idea, I find it so hard to abandon a process I've been working on for months, using tools I'm already productive with.

Also, will pricing essentially be bedrock pricing, or will there be a value-add margin tacked on?

> Does Kiro have some special sauce for making this approach work better?

I'd like to think so, but you'd have to compare the results to what you are currently doing to see how you feel about it. I personally love the format that it uses to define requirements, and the details of the software design docs that it writes (including mermaid diagrams)

> will pricing essentially be bedrock pricing, or will there be a value-add margin tacked on?

The pricing is a flat rate, with a cap on number of interactions per month. Each human driven "push" for Kiro to do something is an interaction toward your limit, but Kiro may work autonomously for many turns based on an interaction, and will produce significant amounts of code from a single interaction.

More details here: https://kiro.dev/pricing/

Ah, thanks for the pricing link. I saw 'Kiro is free to use during preview' or similar and assumed pricing is hidden.

At $39/month, is 3000 interactions a high limit? I use Claude Code on the $30 plan (I think), and routinely hit limits. I'm not ready to jump to the next tier, though. I think it's $200/month, and the NGO I work for isn't prepared to throw that kind of cash at developers (I'm second-rate here; the science comes first)

It's hard to directly compare, but 3000 interactions should be very, very high. Think of each of these 3000 interactions as you supplying a prompt that potentially runs for 3-5 minutes of Kiro iterating away on writing code. With appropriately sized prompts (most likely aided by spec mode), you could write a ridiculous amount of code.

For reference 3000 interactions * assumed 3 mins of AI work per interaction / 60 mins per hour / 8 working hours per day equals 18.75 working days of nonstop back to back AI coding. Typical month has 20-23 working days. But realistically you likely won't be using Kiro nonstop all day back to back, so 3000 interactions per month should more than cover your work month.

Thanks, this is exactly what I wondered. In practical terms I can’t imagine hitting that limit.

It’s a bit more than I pay in CAD, but I’d pay quite a bit more just to stop hitting the limits I have with Claude, even if the rest of the service was identical. It’s a pain. My usage is also very bursty so I spend several days getting no usage, then repeatedly hit limits while I brainstorm and spec things out.

I’m thinking out loud here in case it’s useful feedback. It seems like a great pricing schemes for my use case.

CC have $20 and $100 and a $200 tiers

Right, thank you. I pay ~$30 CAD, but the other tier is $200 USD. I should just sick to USD.

I love all of this experimentation in how to effectively use AIs to co-create output with human steering. This pattern, of the human human focusing on the high-level and the AI focusing on the low level feels like a big win.

In some sense, we are starting with a very high-level and gradually refining the idea to a lower and lower levels of detail. It is structured hierarchical thinking. Right now we are at 3 levels: requirement -> spec -> code. Exposing each of these layers as structured text documents (mostly Markdown right now it seems) is powerful since each level can be independently reviewed. You can review the spec before the code is written, then review the code before it gets checked in.

My intuition is that this pattern will be highly effective for coding. And if we prove that out at scale, we should start asking: how does this pattern translate to other activities? How will this affect law, medicine, insurance, etc. Software is the tip of the iceberg and if this works then there are many possible avenues to expand this approach, and many potential startups to serve a growing market.

The key will be managing all of the documents, the levels of abstraction and the review processes. This is a totally tractable problem.

> Exposing each of these layers as structured text documents

If we take it far enough, we could end up with a well structured syntax with a defined vocabulary for specifying what the computer should do that is rigorously followed in the implemented code. You could think of it as some kind of a ... language for .... programming the computer. Mind blowing.

I get you are being sarcastic, but lets actually consider your idea more broadly.

- Machine code

- Assembly code

- LLVM

- C code (high level)

- VM IR (byte code)

- VHLL (e.g. Python/Javascript/etc)

So, we already have hierarchical stacks of structured text. The fact that we are extending this to higher tiers is in some sense inevitable. Instead of snark, we could genuinely explore this phenomenon.

LLMs are allowing us to extend this pattern to domains other than specifying instructions to processors.

And we re-invent the wheel basically. You have to use very specific prompts to make the computer do what you want, so why not just, you know... program it? It's not that hard.

Natural language is trying to be a new programming language, one of many, but it's the least precise one imho.

> Natural language is trying to be a new programming language, one of many, but it's the least precise one imho.

I disagree that natural language is trying to be a programming language. I disagree that being less precise is a flaw.

Consider:

- https://www.ietf.org/rfc/rfc793.txt

- https://datatracker.ietf.org/doc/html/rfc2616

I think we can agree these are both documents written in natural language. They underpin the very technology we are using to have this discussion. It doesn't matter to either of us what platform we are on, or what programming language was used to implement them. That is not a flaw.

Biological evolution shows us how far you can get with "good enough". Perfection and precision are highly overrated.

Let's imagine a wild future, one where you copy-and-paste the HTML spec (a natural language doc) into a coding agent and it writes a complete implementation of an HTML agent. Can you say with 100% certainty that this will not happen within your own lifetime?

In such a world, I would prefer to be an expert in writing specs rather than to be an expert in implementing them in a particular programming language.

In this world where the LLM implementation has a bug in it that impacts a human negatively (the app could calculate a person's credit score for example)

Who is accountable?

I couldn't even tell you who is liable right now for bugs that impact human's negatively. Can you? If I was an IC at an airplane manufacturer and a bug I wrote caused an airplane crash - who is legally responsible? Is it me? The QA team? The management team? Some 3rd party auditor? Some insurance underwriter? I have a strong suspicion it is very complicated as it is without considering LLMs.

What I can tell you is that the last time I checked: laws are written in natural language, they are argued for/against and interpreted in natural language. I'm pretty confident that there is applicable precedent and the court system is well equipped to deal with autonomous systems already.

I agree with this. There's so much snake oil at the moment. Coding isn't the hard part of software development and we already have unambiguous language for describing computation. Human language is a bad choice for it, and we already find that when writing specs for other humans. Adding more humaness to the loop isn't a good thing IMHO.

At best an LLM is a new UI model for data. The push to get them writing code is bizarre.

Many companies are considering IDEs the way to reach developers. Atom started the trend of next generation IDEs and VSCode consolidated most of the market. With the AI raising, people are looking to get usage, gathering data, and positioning models. An IDE provides you all of that.

AI seems to be a way to engage happy users to try new things. Kiro joins a growing list of projects:

- Kiro (AWS)

- VSCode + Copilot (Microsoft)

- Windsurf (OpenAI tried to get it)

- Cursor

- Trae (Alibaba)

- Zed

- etc.

I put Zed in a separate category in the past. Now with assistants / agents, it's playing on the same space.

The market is a bit saturated and tools like Claude Code gave some flexibility and an alternative for users. I tried Cursor in the past, and now I'm back to Helix / VSCode + Claude Code.

I love Zed as an editor/IDE without ANY AI/LLM features. I think the AI support in Zed is actually pretty decent and I'm still using it out of habit (actively trying to use more TUI for AI).

But at the same time, it's my biggest worry that they will continue on the AI and pollute the project with too much junk. I gotta trust the smart minds behind it will find a way to balance this trend.

Totally. I think Zed has its own value proposition. That's why I never put them close to other editors like Cursor at the beginning.

Lately, I started putting it together due to all the AI excitement. People try it because of the AI capabilities to find an IDE that works for them.

I hope Zed continues providing new amazing features in all the areas.

It makes we attracted to Vim/Emacs. They'll be the same until I die.

> Windsurf (OpenAI tried to get it)

And Google killed it.

I got to play with this for the past week, and it's surprisingly good from an angle of "does a lot of the context engineering work for you." It enforces a rigor that I don't usually bring to vibe coding...

Thanks so much for your feedback Corey! That's one of the big goals of Kiro: to add a bit more of the rigor required to keep your code projects sane as they grow over time. I think Kiro hits the best of both worlds: the easy fun of "vibe coding" at first but then when its time to do some software engineering, Kiro is there to help dig deep into the technical requirements, write the architectural design, and break the big project up into reasonable tasks.

Can it sort out AWS bills yet?

(I initially started writing this as a joke upon recognizing your name, but now I think I'm serious..)

I’ve yet to see a GenAI system that comes even slightly close. They’re dangerously inaccurate in this space.

You probably need an ad hoc MCP for this kind of things.

You need far more than that. Beyond the basic resource sizing / misconfiguration issues, it’s highly contextually dependent to an environment / institution. A change that’s great for one customer could be ruinous for another.

That's been my experience as well. Makes sense, there's little training data available and the (public) docs and (first-party) tooling remain dreadful.

Unless it offers me something substantially better than VSCode, I am not gonna switch and it has a lot to do with unsupported extensions. For now, I think UX preference has to be CLI with web gui wrapper where you can pick models, agents, requirements, etc and let that run anywhere, even headless. I don’t like how these guys (as in all the VSCode wrappers) are trying to sucker people onto their platform to lock you in.

Edit: I know there’s manual VSIX route.

what are the unsupported extensions? i thought the support had to do with marketplace access (search / download / update) but if you already have the vsix it can be installed in any vscode fork

Some of Microsoft's extensions are licensed such that they may only be used with their own products (i.e. the official VS Code they offer for download, etc.). This already affects Cursor for example:

https://github.com/microsoft/vscode-dotnettools/issues/1909

Kiro is Vscode (forked from the open source version). I imported all the settings and extensions into it from VSCode, worked fine.

For anyone wondering, Amazon already offers an Agentic coding CLI similar to Claude Code: https://github.com/aws/amazon-q-developer-cli

It has a pretty decent free tier, and maybe the subscription is better value than Claude Code, but hard to tell.

It supports MCP as well.

Amazon Q also has a VC Code and IntelliJ Idea plugin too, Kiro goes beyond what you can do as a plugin in VS Code though, similar to why Cursor had to fork VS Code.

Q CLI is great. It’s basically Claude models but pretty much unlimited and only for $20

Not as polished as Claude Code but also a bit price difference

That sounds too good to be true, and it seems like they are indeed introducing a usage system similar to their competitors next month?

> Starting August 1, 2025, we’re introducing a new pricing plan for Amazon Q Developer designed to make things simpler and more valuable for developers.

> Pro Tier: Expanded limits $19/mo. per user

> 1,000 agentic requests per month included (starting 8/1/2025)

- https://aws.amazon.com/q/developer/pricing/

Previously agentic use was apparently "free", but with a set deadline in June, so it seems like this was just for a testing phase?

50 request per month? Am I reading that correctly? If that's the case it is pityful.

Q CLI has so many issues though, injects so much junk into you shell profiles it can slow down your terminal invocations by seconds, and it doesn't support standard streamableHttp / SSE MCP servers.

just turn those off, it's just 2 includes one at the top and one at the bottom of your shell... file a ticket about making it optional or not. I believe that the shell integration / autocomplete is where they started the product so it's probably one of those core features in the product team's minds.

I generally like the integration but in some cases it's getting in the way of other ai that is runnin q to quit and all of a sudden its in q... I renamed it to amazonq and removed it from my zshrc and added it as a command to integrate, amazonqinit

I'm the one that logged this: https://github.com/aws/amazon-q-developer-cli/issues/844 Amazon really have dropped the ball with fixing it.

I turn that stuff off and just use `q chat` for everything, which actually works very well in my experience.

That's for the shell auto-complete feature which I turn off.

It's not that simple: https://github.com/aws/amazon-q-developer-cli/issues/844

Is this an Amazon product? When I click on "Legal" at the bottom of the page, I'm sent to AWS.

The docs state at https://kiro.dev/docs/reference/privacy-and-security/#servic... that "Kiro is an AWS application that works as a standalone agentic IDE."

But nowhere on the landing page or other pages it states that this is an Amazon product.

What is going on?

Edit: I see that @nathanpeck is the "author" and he works for Amazon, why are they trying to hide that fact?

This was launched on twitter by Amazon CEO Andy himself.

My original title did mention that this was an AWS product, but Hacker News made the editorial decision to reduce clarity.

I didn't realize either until I saw this comment. The tone of the blog post also felt like it was coming from an individual rather than an organisation, which is not typical of Amazon. I don't know if this was a recent acquisition, otherwise diverting from your primary brand is strange. Unless they feel an association with Amazon would only be negative.

How are they hiding it?

Click about, says its made by a team within AWS.

Click on any of the legal links in footer, get sent to AWS

Look at the footer, has AWS logo

Look at the license, clearly says "Amazon.com, Inc. or its affiliates"

On the download page "By downloading and using Kiro, you agree to the AWS Customer Agreement"

I don’t think they are trying to hide that.

From the about page.

> Kiro is built and operated by a small, opinionated team within AWS.

Disclaimer: I work at AWS, different org though.

Isn't AWS Amazon Web Services??

Yes, why are you asking?

Source code analysis [and dump] of Kiro at https://ghuntley.com/amazon-kiro-source-code/

- Uses ripgrep under the hood

- VSCode fork (thus suffers from the https://ghuntley.com/fracture problem)

- There are 14 different ways defined to edit a file due to its multi-modal design. Tuning this is going to be a constant source of headaches for the team.

- Kiro utilises a https://ghuntley.com/specs based workflow.

Not sure why you are being downvoted. I appreciate this!

Caylent has been testing this for quite some time and I have to say it's an interesting take. With claude code you can shift between planning and coding modes and this offers a similar approach. The speed is quite good and the results are solid. The spec approach is solid but it takes a learning curve. Some of the tooling and autojumps take a bit to get used to because they differ from the other IDE approaches.

Overall I do believe this has accelerated our development and I'm interested to see where it goes. I don't think it's a direct comparison to claude code or cursor - its a different approach with some overlap.

1000 interactions ($20/month) will run out in a 1-2 hours. Do the math for 3000 interactions.

Kiro has the same problem as many LLM coding tools has: it's not economically sustainable for the company producing the tool (bubble will burst at some point), or it's not worth it for the developer.

Tried to use this to create a minimal bootloader and kernel that prints hello world in x86

There was never a point in which it successfully did anything.

1. Tried to use macOS’s toolchain (m2 laptop so this is not going to work to build x86 binary)

2. It tried to fix that and failed multiple times.

3. Eventually I gave up on it trying to fix itself and told it to just use a container with Fedora Linux on it to work around the issue.

4. It created Dockefile for Fedora 39 (current is 42)

3. It still fails to recognize that we are on aarch64 and we need x86 so the container it built was not correct anyway lol

I imagine “minimal bootloader + printing hello” is quite represented in the training set as there’s thousands of projects like this on GitHub.

If it cannot deal with basic things like this, I legitimately don’t get all the comments here praising it

You're using a slop tool and expect it to produce anything but slop?

I use Roo code with orchestrator(Boomerang) mode which pretty much has similar workflow. The orchestrator calls the architect to design the specs, and after iterating and agreeing on the approach, it is handed over to Code mode to execute the tasks. Google Gemini 2.5 pro is pretty good at orchestration due to its 1M context and I use claude sonnet 4 for code mode.

What else does Kiro do differently?

Edit: The hooks feature looks nifty. How is the memory management handled? Any codebase indexing etc? Support to add external MCP servers like context7 etc?

Interesting. Do you have a write up on this setup I (we) could follow?

I'm already burnt from amazon Q which was forced onto us in an alpha state in my workplace - was miles behind competitors for a full year, before we finally won the battle to move back to co-pilot.

Going to take a while before I trust any AWS AI related tooling won't just be abandoned / mis-managed after my prior experience.

Important: it's another fork of VSCode.

I thought AI was ushering in the age of innovation so why is the only innovation anyone seems capable of copying something that already exists...?

In all actuality, AI seems to be ushering out the age of innovation since people now consider it foolish to spend their time trying to innovate instead of clone

I believe most projects use VSCode because it is hard to build a cross platform code editor with plugin system.

And if you're going to copy, might as well be the most popular editor to reduce user friction.

It does show that they're not limited to just greenfield projects, which is a common perspective. That said, IDK if a fork that is never planned to be merged back in really constitutes a non-greenfield project. It's more like a greenfield with a head start.

I am a heavy Jetbrains user, I never liked the idea of Cursor. I embraced Claude Code immediately when it came out.

Are you using the Claude Code plugin, or switching back and forth between Claude Code and the Jetbrains IDE?

With the plugin. CC runs in a terminal on the sidebar. The plugin does not only provide diff view for CC edits, it also gives CC access to diagnosis and all other IDE capabilities through MCP.

VSCode is way worse for large codebases and also much worse for Ruby, Golang, etc.

> 2. Technical design based on requirements > Kiro then generates a design document by analyzing your codebase and approved spec requirements. It creates data flow diagrams, TypeScript interfaces, database schemas, and API endpoints—like the Review interfaces for our review system. This eliminates the lengthy back-and-forth on requirements clarity that typically slows development.

This is nice for documentation but really having a design document after-the-fact doesn't really help much. Designing is a decision-making process before the code is written.

I slightly disagree. Plans are really useful for enhancements. If we stick to original plans & patterns as we extend & add new features, we can slow down the decay process.

Kiro takes the requirements and the existing code to create a spec.

Otherwise the spec may cover requirements that are already met in the existing code and needs to understand integration points it needs to include in the spec.

Having used Kiro myself I think it does what you expect.

I read it as after requirements and before code. This is how I would expect it to work too. It reads the existing codebase, which also makes sense for non greenfield projects as in the example.

The Eisenhower quote comes to mind: "Plans are worthless, but planning is everything."

If you don't start with approximately the right destination, you're definitely never going to end up there, even if you have to take some detours and compromise on some choices.

It gets really frustrating reviewing people's designs at times, when it's crystal clear they're a) working backwards and b) haven't really considered the customer experience at all.

One of my favourite tell tale signs of a) is when the chosen option 100% fits the specifications, doubly so if there's no cons associated with the pros. Sometimes it's genuine, but very rarely.

As a side note, Kiro is a diminutive of Kiril (Кирил) in Slavic-speaking countries and in Greek. A quick web search also reveals that it can mean "a curse".

How your comment contributes to the discussion I have no idea, but thanks for this factoid nonetheless.

This doesn't support development containers (https://containers.dev), which means I can't insulate my machine from AI tooling. Not keen on this unless it's somehow earth-shattering.

why doesn't it support them?

The remote containers extension on VSCode is proprietary. Cursor had to write their remote extension suite.

This looks really cool except for having to learn a new syntax (is gherkin that bad?) however, something has been bothering me with all of these Agent AI based workflows.

At what point do you actually do engineering? This was a great demo for a project manager. Lead your “team” through feature development. But without proper architecture, development really does become spaghetti.

There’s vibe coding - and then there’s this, where I feel like I’m a PM, not an engineer.

Yeah, I hear you. Vibe coding is good for a POC style thing as long as you can (somewhat) ignore architecture.

For any real-world application that is even slightly more complex than these demos it will start to fail.

At least that has been my experience

It depends. A lot of projects / features really don't require a ton of engineering thought. Add a new table that has some foreign keys with existing tables, add a new page that lets you modify that table, add a new set of REST CRUD handlers that do some validation and store the data, add a new message queue that does whatever needs to happen when the data gets changed.

If AI can handle things like that, then let AI do it: it's not really engineering work anyway; it's copy-and-paste from a previous design, just change the handler logic and the names of things. If 90% of incoming features are like that, then that gives you a lot more time to work on the 10% that are more complex.

Eventually, you'll end up with spaghetti code no matter how well you plan out the architecture, whether human or AI is doing designs. But it'll move that direction even faster with AI, and eventually AI won't be able to understand it well enough to reliably design things anymore. That's where the real engineering will come in. As the system evolves, how do we re-architect things so that AI (and humans) can understand the patterns again and make future changes more reliably?

Right now, it seems like services go through major refactors/rewrites like that every five years or so. And those rewrites tend to be slow and often unsuccessful: even though the existing system is complex, engineers are used to it and it's easier to add one more bandaid than to wait for the full rewrite. Then such rewrites can get stuck in navel-gazing as there's no "perfect" way to do them, and it's lower effort just to go back to the system you already know.

As AI creates more churn though, the architecture will need to be rethought much more frequently. Additionally there will be more urgency to deliver the cleanup because AI will be completely blocked by the existing spaghetti, which brings all product dev to a halt, and you don't have time for navel-gazing because there's no fallback option.

So I think the engineering work post-AI is really going to be this kind of infrastructural planning and rearchitecting, such that AI can deliver features on top of it without friction. And in a way, as an engineer, that's what I want to be doing anyway. We've always had this ideal of continuous refactoring and continuous improvement, that always gets pushed to the backburner when compared to feature development. "Sure this refactor will help future velocity, but we need to make our quarterly goals!" But now, AI will compress those timelines so that maintaining clean architectures has a direct effect on the deliverables of the current quarter.

I personally think this is great. If, in the future, PMs can launch whole features without engineers writing a line of code, that's awesome. It's our job to maintain a system where such an ideal is possible. Which sounds like the job I wanted when I originally signed up to be an engineer.

>And in a way, as an engineer, that's what I want to be doing anyway…

Yuk. That’s pure project management.

> If, in the future, PMs can launch whole features without engineers writing a line of code, that's awesome.

No it’s not! Because then, there is no incentive to engineer anything anymore. Just let the AI do it, Yey! Need new features? Let the AI do it! Need to fix your infrastructure, AI has your back! Has your product gotten so unwieldy that you have context rot and AI can’t do it anymore? Pivot, throw it away, rebuild with AI, who needs engineers.

That's the thing though. I think we're pretty close to AI being able to add fairly vanilla features that fit into the existing architecture fairly autonomously. But I think we're a long way away from AI being able to do major refactors by itself, or even determine what needs refactoring and when. Maybe someday it will, and it can already be useful in implementing pieces of a refactor, but it's nowhere near close on being able to design a major platform shift at the moment. That's entirely a human domain.

So while we're in the middle of those two pivot points, I think most of our work will be on the architecture side. Continuously clean up the platform so the LLM agents can keep humming along on it.

Eventually we'll perhaps get to the point where AI can automate 100% of this as well, and I have no clue what will become of engineers then. But I don't see that happening in the next ten years, and even when it does happen, I'm sure the changes will create whole new industries, workflows, and sets of problems for human engineers to solve. (SciFi me expects a whole new field of extracting the most value out of AI without letting it run amock. As fast as it goes, and as intelligent as it will be, we won't be able to just let it take over. We'll need to design guardrails for it so that it does the things you want, and doesn't make decisions that you don't want. This, by definition, has to be a human driven process. So I think there'll be work for human engineers to do for a long long time.)

I think the interesting part here is not so much the IDE/coding aspect, but LLM-assisted:

* requirements doc

* design doc

* plan doc

These alone make an interesting product. Give me a thing that asks me the right, thought provoking questions (ideally let me answer by just choosing from a list of relevant options) and produces these docs in a structured and highly detailed way, and I’m set.

I think the code is just a distraction. There are plenty of tools for that.

True for greenfield projects, but once a project moves beyond greenfield, the assistant will need to understand the existing codebase in order to plan anything correctly. Once it has functionality to understand a codebase, and understand the requirements, plan, and architecture direction, then it's going to have the most context to make edits, so may as well make it an editor too.

I've been testing Kiro for a few months, and yes, it's an agentic IDE like many others. However, a lot of the features are different - the spec driven development is a game changer. It feels like you're truly software engineering versus vibing - you break a problem into small, solvable steps using specs. So are agent hooks - there are great use cases like updating Asana statuses or syncing your design system with Figma.

Tried with one of my older projects to test it out. The problem statement was to upgrade the Java spring boot version from 2.7 to latest. I have done it in the past so exactly knew what had to be done there. All the requirement docs, design specs, and tasks look verbose and ok on high level. Interestingly I had some idea where the language in those docs was coming from. 1. It created about 40+ tasks (I have my own curated list of 5 tasks based on past experience)

2. At every task it tried to compile the code but failed for dependency errors

3. It still marked the task being complete and passed the onus of failures on the downstream tasks

4. Kept moving with the tasks where the original error were still not fixed but the tasks were being marked as done

5. After some point of time I got tired to a degree that I stopped reading the exact commands being executed, the fatigue of doing something that you are not involved in is for real 6. I made a naive assumption that I can sandbox it by giving permissions to the project folder only. It executed some CLI commands for java that looked simple enough in the beginning.

7. Turns out my environment variables got messed up and other simple things related to git, gradle stopped working

Ended my experiment, reverted the code changes, fixed my environment

Key takeaways:

1. Its giving a sense of work being executed, the quality and concreteness of work is hard to measure unless you have already done that in past. Its creating classes, tests which are not needed instead of focussing on the actual use case.

2. Sandboxes are MUST, there is a real risk of corruption, environment commands are not just simple file changes which could be easily reverted.

Interesting. How large is the project?

It was relatively pretty small project, about 5ish controllers and same number of service classes. The experiment lasted for about 2.5 hours where I was active for the first 45 minutes and then just pressing the buttons to move next in passive mode.

I really like that the testimonials are linked directly to the Github accounts of the contributors. I've seen a lot of websites where it's questionable at best whether the people reviewing the product even exist.

It's also interesting that the pricing is in terms of "interactions" rather than tokens. I don't believe I've seen that before.

Hey, a cute logo! I didn't know AWS allowed cute things.

Is there a way to use your Claude Max plan? I checked my token usage (ccusage) if I wasn't on a plan, and last month it would have been over $2000. This constraint prevents me from realistically considering alternatives to Claude Code.

Title should be: "Introducing Kiro"

Sonnet 4 seems like the sweet spot for every ai provider now. I wonder why oai couldn't match it

So I am pretty sure that there is some aws/amazon service which can provide gpu's / model inference too.

I read it (I think) in one of the comment that There is a model picker that currently allows you to switch between Claude Sonnet 4.0 and Claude Sonnet 3.7

So is this just using Claude?

I really thought that the advantages of using Kiro might really be that of the leverage that Amazon Gpu's infrastructure could provide, maybe even some discounts to lure people to Kiro.

I am pretty sure that a lot of people will ask you the same question, But I would really appreciate it if you could answer me this question in preferably simple terms: "Why Kiro? Why not all the other stuff that has come before it and the stuff that will come after it"

Also I am really having some dejavu but while writing this comment, has the title of this post changed, I swear I saw something written in the header with Amazon and now I don't see it. honestly, I am really being so off-topic but after seeing this name change of the post, I really wish if that there was some website that could track all the name changes of posts that happen in HN, because I was completely baffled by this name change or I am being totally paranoid.

The previous title stated Kiro as being "Amazon's Cursor clone", which I agree was not adequate.

My suspicions were right that the name had something to do with amazon because I went into this thread thinking about Amazon's unique position in this market.

It does use AWS infrastructure, ie Bedrock which supports many different models.

Ohh I forgot that anthropic uses AWS Bedrock (I think?, right?) That checks out. This is really cool project!

From my understanding Anthropic is independent but they offer Claude as an offering through Bedrock

What is really the benefit of this if you are stuck paying Claude API rates anyway?

We really need a new (and cheaper!) SOTA for agentic models.

This post is downloading >100MB in gifs like it's not a thing...

Very impressed. As a programming impostor (never formally trained, and not working as programmer) I find the program 1) helped me to understand the basics of a full blown IDE dev cycle end to end 2) helped me to refine an app on the making. Perhaps the one thing that surprised me vs standard Claude is that it didn't ask me about the tech stack to build my app. It went nuclear with a complex react-based stack when my app's needs are less demanding (a simple html+css+js could do it)

People are lapping up vibe coding as a way a way to avoid deep work, and spec-driven development is in opposition to that.

Looking at the brief for this, it likely involves painstaking work to review and refine the specs produced. Not that there is anything wrong with that; as I said before in a comment on another story, coding assistants may reduce quite a bit of drudgery, but to get the best out of them you still need to do lots of work.

The more I use agentic coding tools, the more I come to the realization that speccing is where you add value as an experienced skilled engineer. And I think this bodes well for software engineering, as a bifurcation emerges between the vibe coders (who will probably merge with the mythical end-user programmers) and serious engineers whose are skilled at using LLMs via high quality specs to create software of higher quality and maintainability.

So the vibe coders would probably not take to this tool that much, but that's fine.

I have to say, I'm a little bit proud of myself that their approach comes close to what I consider a good method for building software with LLMs: https://markus.oberlehner.net/blog/ai-enhanced-development-b...

It seems that many in the field are converging to similar ideas. With AI the emphasis seems to be more on defining clearly what to build rather than how. I made a similar experiment [1] recently where I setup "rules" between code and spec and have the LLM check that they are the same, I think similar to how Kiro uses hooks.

[1]: https://news.ycombinator.com/item?id=44432215

How does it compare to Claude Code? Can't that do this sort of thinking ahead and writing specifically? It may need some prompting to do the specifically writing specifically though.

I feel like this might be nicer as an MCP and I bring my own AI assistant to it.

I know Cursor seems to work best using Anthropic’s models, is this similar or does it use a model from Amazon?

They did not even spend time to put up a credible demo. The web app they demo has missing images, images that do not correspond to the text. Why would I or anyone else be convinced to spend much more time learning a new IDE and switching to it, when they did not spend enough time for a proper demo.

It's not open source. Why bother?

OSS option will be there soon and will outsmart Kiro.

Is model choice a core design consideration. Or will Kiro not let developers chose the underlying model?

What if I want to set preferences for the underlying LLM for different usage scenarios? For example, for a quick and snappy understanding of a single file id want to use a fast model that doesn't cost me an arm and a leg. Recent research on preference-aligned LLM routing here: https://arxiv.org/abs/2506.16655

first impressions:

1. autopilot should be off by default. this is the norm for claude code and cline (plan mode)

2. my sidebar is on the right. that was imported correctly from vs code, but the kiro window is still on the left. why can't it be on the same side as my sidebar like a usual extension (e.g. cline)?

3. the textbox is super busy. for some reason the "Hold Shift to drop image" is stuck there

The ghost icon confused me at first, given ghostty use of a similar icon.

https://ghostty.org/

Hopefully better then the hell that is trying to use Amazon Q for development.

Vscode again.

If MS didn't have their weird semi closed ecosystem for Vscode this would be in Vscode proper.

It seems that it doesn't work with WSL 2 yet. Any plans to support it?

We need someone to compare the efficiency of these agent wrappers. They may use the same models, but not as efficiently as one another.

https://gosuevals.com/agents.html Is quite nice, there are also YouTube videos that do a deeper dive

That table is uninformative and untrustworthy. Where is this detailed breakdown they speak of? How can we replicate it? Where is the cost? Who is behind it?

do i have to run each task manually in the tasks.md? can i not leave it unsupervised?

i also need to individually approve each command for some reason and then if it fails due to a service high load i need to manually restart all over again the same task.

> fails due to a service high load

It seems to be suffering the HN effect right now. Earlier it was working nicely and pretty much doing everything in the background

Sep 1: generate requirements, generate design, generate task list

Step 2: run the tasks in claude code in parallel...

This reminds me of the pocketFlow library, which takes a specification document and uses it to create subtasks and generate code, but can be used with local models.

I do like the control you have over organizing. The only thing I was shocked was I couldn't revert a series of changes (checkpointing) like you can can in Cursor. Sometimes the LLM does it a different way I dont like, so I want to go back and edit the prompt and try again.

I got early access to Kiro. Wrote about my experiences here if you're interested: https://yehudacohen.substack.com/p/developing-with-kiro-amaz...

It is my new daily driver.

Really impressed with what Amazon is doing with Kiro. The emphasis on "spec-driven development" to get beyond "vibe coding" and into production-ready software is a crucial step.

It is strange that Amazon Q extension is incompatible with kiro right now.

Kiro's spec based development is something that's new (for me atleast) and it's pretty good.

This is exactly how I've been building software with AI lately. Getting AI to create a detailed plan with phases, then implement and use a separate AI to review the code. It works quite well! Curious to see how well it works when implemented directly in the IDE

At what point does the manager fire you and just let the AIs have at it ;)

Realistically, none of the models can function fully autonomously at this point. You still need a skilled human at the helm. However, AI tools definitely change how the human works. I find that I spend a lot less time thinking about easy things, and a lot more time thinking about hard things.

Basically, the AI fast forwards through the easy stuff and I just spend all day jumping directly from hard problem to hard problem.

Nah, you never voluntarily reduce headcount. Headcount is what keeps your salary coming. Any manager worth their salt would use this newfound productivity to infringe on other teams' domains: Hostile Takeover => More Headcount => Promotion. We'll see a lot of attempted empire building over the next couple years while all this gets sorted out.

does this have any carveouts for CDK or other aws services? I've found that sonnet sometimes struggles to know what params to use, while amazon Q despite being on paper a worse model, can. It seems this uses sonnet, but are there any adjustments?

Why does it feel like all tech companies are the same these days? It wasn’t always like this right?

Because collecting signals from the people that use these systems is extremely valuable. This kind of data is almost impossible to gather unless you own such a product. And those that do probably won't sell to the competition. So, it makes sense that everyone is in the me too phase.

Goog is even heavily subsidising this. Anthropic is likely doing it with their top tiers as well. Even the small ones @20$ most likely did in the beginning.

It's a new category of tool and they're all competing for it

All the tech companies have a lot of software developers working there and they always have a ton of projects around software development and deployment that they've released. It's been new that they've been _monetizing them_, but that pretty much has to be done for AI tooling because of inferencing costs....

No autocomplete? Why? I mean is the current trend to leave all the control from the experienced dev hands and just review the final code? Not my cup of tea, I'll keep using Cursor and "vibe code" with smart rewrites

Kiro does have autocomplete. It's just not advertised on the product page as a star feature.

In my experience using Kiro you are still going to be hands on with the code. Personally I choose to turn AI powered autocomplete off because when I do touch the code manually it's usually for the purposes of working on something tricky that AI would likely not get right in autocomplete either.

However, the Kiro autocomplete is average in capability in my experience, and you can absolutely use it to write code by hand as well.

I wonder if it's entirely coincidental that "KIRO" is a Seattle-area (amazon land) television station.

Too late to the party. Feels like the market has moved onto Claude Code and terminal agents. I use Claude Code extensively and love the flexibility and fluidity. Also works well through the terminal integration in IDE.

Is there a way to preview changes in CC before “accepting” like you can in Cursor?

My 2c-TLDR; after doing some battle testing over the few weeks (so keep in mind some of this was on pre-release versions):

The good: It's great to see they've baked in the concept of setup -> plan -> act into the tool with the use of specs If you're someone who currently only has Copilot / Q dev, this is a good step in the right direction - if you don't mind changing your IDE. I love that it has a command / task queuing system. Hooks = good.

Goes either way: Even though it uses Q under the bonnet, it does seem somewhat better than Q although I think most of that is down to the use of plan -> act workflows

The not good: There's no reason at all for it to be a VSCode fork and running multiple IDEs for every vendor that wants me to use their products is a PITA. It seems to massively over-complicate solutions, for things that could be quite simple even if the tasks are well defined it likes to create many files and go down very extensive and complex implementation patterns. This has to be something to do with the app itself as Sonnet 4 does not do this with Cline/Roo Code so hopefully it can be fixed (but maybe it suits the kind of folks that write big java apps!). It doesn't seem to have any integrated web browser capabilities to allow the model to run up and explore the app while inspecting the js console browser side like Cline / Roo have. My installation has mysteriously become 'corrupted' and needed reinstalling several times. There's no global rules, you have to keep a note of them somewhere and copy paste them into each project. GH Issue #25

The bad: It's slower than Cline / Roo Code, it just takes a lot longer to get things done. It's very easy to hit the rate limits and be blocked for an undefined amount of time before you can continue working. There's lots of MCP bugs mainly relating to it still not supporting the standard streamableHTTP or SSE modes and breaks all MCPs without any warning or logs if you try to add one. GH Issue #23 The version of VSCode it's built from is quite out of date already, which rings alarm bells for how well such a large, complex application will be maintained and rolled out at speed over time.

I'm a little confused about how pricing works here. What is an 'agentic interaction' and how does that translate to dollars? And how does this work with models that are differently priced???

So I'm glad there are more agentic dev tools coming out, but can we please stop making entirely new IDEs and start integrating as plugins to well-established (and some already paid for) IDEs we already use? Webstorm/other Jetbrains, VS Code, etc.

It is a huge hassle to match my existing settings, which I've spent countless hours tweaking over the years, with a new editor that can't import them. :(

Shameless plug but our co is building a AI plugin for JetBrains that has next edit autocomplete + a strong coding agent (sweep dev)

Isn't that competing directly with JetBrains themselves?

Yes but I think they have worse things to worry about, namely Cursor.

Also if you're interested our plugin is https://sweep.dev!

The obvious solution is a meta-IDE that integrates all these other IDEs and plugins.[1]

Or, you know, stop chasing the latest trends, and use whatever you're most comfortable with.

[1]: https://xkcd.com/927/

Big opportunity to be the first open source model agnostic Claude Code with widespread adoption. You’ll be the vim, the Linux, the nginx, the MySQL of agentic coding. Who will it be? It’s wide open right now.

This is much more tricky than you'd think. Claude Code and other similar tools only work as well as they do because the prompts that power it have been tuned to match a specific model.

When you make a tool that is "model agnostic" you also make a tool that is unable to play to the individual strengths of each model, or you set yourself up for a massive, multiplicative effort of trying to tune your tool to every single popular model out there, even though some of the models are drastically less capable than others.

Mark my word guys, 2026 will be year of cybersecurity.

Vibe coders let's gooo.

Is there any way to move the chat window to the primary side bar? Having two side bars open takes up a lot of space. Not sure why this pattern persists in these VScode forks.

Generally in VSCode and its clones you can drag the window anywhere you like. I've been using my Copilot in the lower area which spans multiple panels, to give myself a little more viewing space.

How do I know that this is an AWS product? This should be on an Amazon domain or the blog should be on an Amazon domain that links to the site.

wait, it's completely free during the preview period? That's a better deal than Cursor, Windsurf, or Claude Code. Gotta check it out

From the little I’ve played with it so far, its spec-driven format seems to give better results when making large changes to code.

Why couldn't this be built inside Q?

What models are supported, can we add custom models? I’m struggling to add Kimi K2 to cursor and surf.

Impressive to see an AI IDE tackle the real world complexity of software development. Love the separation of modes- Vibe for ideation, Spec for clarity, and Agent Hooks for ongoing maintenance. The spec-driven approach feels like a natural evolution beyond the typical AI prototype tools. Excited to try it out on a live project!

super interesting to see how this is marketed:

- Created by an AWS team but aws logo is barely visible at the bottom.

- Actually cute logo and branding.

- Focuses on the lead devs front and center (which HN loves). Makes it seem less like a corporation and more like 2 devs working on their project / or an actual startup.

- The comment tone of "hey ive been working on this for a year" also makes it seem as if there weren't 10 6-pagers written to make it happen (maybe there weren't?).

- flashy landing page

Props to the team. Wish there were more projects like this to branch out of AWS. E.g. Lightsail should've been launched like this.

they literally copied logo (even the color!) from phantom

Awesome! Tried it and I should say, adds structure to my vibe coding. Loving it.

Looks very nice, I like the hooks feature. That's a great idea

Am I the only one who finds AI not very helpful?

Just this morning, Cursor was giving me a ton of incorrect tab completions. When I use prompts, it tends to break more than it fixes. It's still a lot faster to write by hand. Lots of libraries that take *arguments in Python also cannot be groked by AI.

Of course you aren't the only one, and I'm sure you know that you aren't the only one.

I doubt these tools will ever convince every last person on every single use case, so the existence of those people isn't exactly an indictment.

At work it's supremely unhelpful. Giant C++ codebase, big enough to choke even traditional analysis tools like IntelliSense, lots of proprietary libraries.

I have found it extremely useful for spinning up personal projects though.

My wife bought us Claude subscriptions and she's been straight-up vibe coding an educational game for our son with impressive results (she is a UX designer so a lot more attuned to vibes than gen-pop). I'm picking up some computational physics research threads I dropped in grad school and Claude Code has been incredible at everything besides physics and HPC. Define and parse an input file format, integrate I/O libraries, turn my slapdash notes into LaTeX with nice TiKz diagrams, etc.

Hoping I can transfer over some insights to make it more helpful at work.

You have to put in some effort to put in the guardrails and scaffolds to make it produce what you want. It’s definitely not out-of-the-box deal.

Is it pronounced kee roh or kai roh

Notably missing fast apply like Morph

Thanks for accelerating global warming.

Kiro in Finnish means "a curse".

More modern would be Kirous.

Why do I need to log in to a text editor?

anyone can make a comparation with cursor

too many ides , hard to choose

Киреца, бате.

What is the difference between kiro and having a rule file in claude code / cursor / cline saying « always start designing before coding. Create a .md file for specs, ask the user for it if it is not there? ». You can just prompt the specs or whatever feature is in this IDE.

Claude 4 can do it all already.

With my experience with Amazon Q in the AWS console (100% useless, worse than a Google search), I can only assume that this Kiro product will suck and not be a market leader.

As a customer I have no incentive to try it.

I think that reputation is 100% Amazon’s fault. When all you do is ship half-baked rushed products your customers will assume your next big thing sucks because that’s the reputation you built for yourself.

AWS really shot themselves in the foot with naming everything “Amazon Q <insert suffix here>”. The Q that’s in the console is completely and entirely different from the “Q Developer” and other AI products that AWS is launching.

The Q Developer CLI, Q Developer IDE plugins, and now Kiro are pretty much just wrappers around Claude Sonnet 3.7/4, and work just as well as them.

Given the rapidly-changing state of AI, "half-baked" is a moving target. The Q console support was never great, but it's materially worse than it was a year ago, relative to what could be built today.

I would also like to add that forking VScode is not a value add. Just publish a VSCode extension.

So we have another ugly VSCode clone with the same legal/support issues as all the other clones, but without any vibe-coding worthy assists like voice dictation/control or any other major differentiator. Just another "me too" project from AWS to scratch some product manager itch and commoditize the complement of some competitor.

Trash

I'll stick with my gentic IDE & write my own bugs.

Would appreciate a video of someone adding a feature to an existing project, just to get a feel for what the tool does. The long blog post gets lost in the sauce, would love a short 5 minute video.

I think this is where the stickiness is with generation; very little chance I’m switching from Claude Code unless something exceptionally better comes along at this point. Assuming I’m not abnormal, this is a huge win for Anthropic.

Im.not a dev so i dont use these vs code forks...

How is one fork different from cursor or kiro or something else?

Arent these like what i assume skinning chromium or something more ?

I'm surprised no one is gobbling up jetbrains.

They have been cleaning up and getting rid of projects, so seems to be preparing for it.

do you mean jetbrains ai team?

Slop.

Is this another VS Code fork or did they just completely rip the VS code ui?

Fork and an old one

It's another VS Code fork!

Had they not forked VS Code the low value quips would reverse to: "why didn't you just fork VS Code?"

Awesome!

loom mom, another vscode fork!

What's with the edited title "it's Cursor clone".

Unless it's literally a Cursor clone, I'd request to change it to describe the product category.

Cursor by no means defines the whole category. Not even close.

product category: "vscode with ai things slapped on top"

By vscode you mean atom clone with extra tools slapped on top, right?

And with atom you mean Notepad++ with extra tools slapped on top?

To be fair, npp is not using electron. Atom is.

To be even more fair, the category used to be sublime clones. Sublime was on a crazy run in the early 2010s and there were various attempts at an "Open source Sublime".

We've replaced the title. (Submitted title was "AWS launches Kiro, its Cursor clone")

[dead]

[dead]

[dead]

[dead]

[flagged]

[flagged]

What is special about Kiro that makes that true? I do architecture with the other agents just fine.

awesome tool!

I'm interested!

Amazon ewwwww

AWSome KIROOOOOO

Not amazed! Tell me one good reason I should use it?

Lets see EU US data privacy shield gone. Aws a bunch of open source tools gobbled together with proprietary source. Trust in made in US cloud platform tools is gone!

I tried Kiro just to test the tool and I was able to create a small order application. I liked it that that it created the documentation including planning and test scenarios. I will continue using the tool to create more complex apps.

I don't see anything, anything at all, that would make a significant percentage of Cursor users consider the switch.

They can try to market grab with low %, but will find themselves in the boat as Cursor and eventually be forced to raise their prices. Except their market grab will be significantly less effective because they're not a stand-out product. Cursor was.