AWS Kiro: Testing an AI IDE with a Spec-Driven Approach

In July, Amazon web services Launched Kiro, his response to Windsurf and Cursor – but focusing on writing specifications on guests. However, I found that access was limited after a developer rush went to check it. I did not get off the waiting list a few weeks ago, so it’s time to dive.

After signing via GoogleYou should get this screen on the Kiro application:

So enter your code and you should be in it.

Apparently there are at least Six major IDE products based on visual code forks; I know the cursor and windsurfing. And now Kiro.

Kiro is placed on your way so that you can execute it from a shell. It opens by looking (without surprise) similar to the visual code:

As you can see, it is defined on Claude Sonnet 4. I will ignore the “atmosphere” option and go directly to the “spec” design path.

What is the development of specifications?

The workflow focused on Kiro’s specifications breaks down the development into three distinct phases: generate user stories with detailed acceptance criteriacreating a technical design, and divide the work into a sequence of Traceable implementation tasks.

These artifacts should ideally be composable documents with cases of functional commercial use and are primary objects in the Kiro world. Obviously, it is a much more formal approach than simply playing poker dice with the model of great language. Most teams that follow Agile should not have any problem with this proposed process, even if your real workflow varies.

I will test Kiro on the same rails project that I recently tested some other agent coding products. It is my MVC application for the development of simple games that helps me to design conversations.

Specling atmosphere

After loading my code base as a folder, I can then launch Kiro by describing the project on which I want it to work. In this case, I need a distinct utility that only links only one model existing in my system:

For my project, I want the user to be able to carry out CRUD operations (create, read, update, delete) on a thought for the day, which is only a text and an image associated with an existing voice.

The ghost returns after having traveled the project and isolated the related model:

Let’s examine the first document, requirements.md:

This is a good introduction to normal CRU operations. He assumed that thoughts are inspiring, and this is partly true in the context of the game. He also understands that he should follow the convention, as all rail applications should.

Scroll towards the first user:

The “administrator” role is not quite correct, but the relevant meaning here is “can create content”. Kiro captures the criteria of “the voice of the voice”, which is the vital connection with the existing MVC vocal model. He also notes that a text entry is required, while an image is not. This is correct – the writer may not have access to an image when the text is created.

There are six sets of requirements / acceptance in total, covering other CRUD tasks and views.

The last one faces the role of developer, so I know that he will correctly use the rails:

The JSON termination point is important, because this is how I will move the data resulting in the main game. In short, he covered all the bases – largely without any intervention.

Design phase

When we have finished, we are invited to move on.

Now Kiro looks at the controller and considers the code of other MVC models, so he knows how to proceed. As my project is a rails application, the conventions are already solid:

From an agile point of view, it would generally be knowledge of the developer’s area, but it is written in terms that an architect would understand. It is therefore between what I would describe as “user” and “task”. I like the fact that he spotted the bootstrap style in the view.

There are about 170 lines of design, so I will only show another section. He again captures the relationship between the voice in the attributes and my existing models, as well as the automatically generated things that we obtain with ActiveRecord:

There are inclusive tests, but as it is an evolving tool, I will ask that the tests be deleted from the design before going to the tasks:

Take things up

We are now ready to go to the implementation:

The list of tasks is written both for the LLM as for a developer:

However, all the tasks seem correct – as you see, they connect to the requirements. A particular concern goes to the tasks that affect existing models, as in the three task; But he simply wants to establish the additional relationship, which should only be a line in the Voice.RB model file.

There are small “start-up” pimples, so it is clear that they could be used by a team if they wanted to work on the tasks themselves. Some of the test tasks have the impression of being a little more for humans:

However, this highlights an important point. Does Kiro expect a human team to work on these tasks, or expect the user to rely on the LLM to produce code?

Currently, design is based on the latter, which is waiting for the market. But that indicates how the first would work.

Finalize

I am not entirely sure what this phase is really used for, but I am advised to go to the tasks sequentially.

I will not go too deep in the result of the execution of the tasks, because we are here to look at the specifications – we know that LLM can manage rails models quite easily. But let’s go through one. The first task begins with the migration file:

As these are rails, it has a defined way to produce a migration file (the global description of the database of the model), so that I can look at the control too long for the small box provided:

rails generate migration CreateThoughtsForTheDay text:text voice_id:integer image_id:string

Technically, the voice_id should be a reference, even if it is an integer. But I will accept the order. As this is the way these days, the LLM examines what it has done and improves it:

The resulting migration still does not completely mention the reference directly, but we are now entering the usual world of implementation arguments with your LLM companion. It’s a great time to withdraw:

Conclusion

Kiro is aimed at development teams that can use artifacts to approve or modify conceptions outside the tool. It is a different approach from that of “mood coding”, which remains locked in the environment.

I think the workflow may have to be simplified. For the moment, I can modify an existing requirement and the whole tree will update. I fear that the dependence loops caused by user hooks (which I have not covered) can become uncontrollable. Or, more specifically, this could be fragile under stress. But these are the first days.

There is a lack of “jailer” from the user interface at the moment – there is a lot of text, less iconography and containing graphics. This is initially correct because the shared start -up documents are the “currency” produced.

Because they encroach in the workflow of a team, there will necessarily be much more user experience work necessary to see what the teams really need here and what they will take on board. I think that maintenance of artifacts through a team needs separate tools.

But overall, I think the approach shown by Kiro is strong. AWS should be congratulated for supporting this ambitious product. He certainly has much more than a ghost of a chance.