I Let Kiro Build My Application. Here's What Surprised Me
What I learned after using Kiro to build a real application with AI.
I've been using AI coding tools for a while, but my experience changed when I started using Kiro.
At first, I expected Kiro to be another AI coding assistant: describe what I want, get some code, fix the mistakes, and continue.
But that's not really what stood out to me.
What surprised me was how much Kiro could participate in the actual development process, rather than simply generating individual pieces of code.
I stopped asking Kiro to write code
One of the first things that changed was how I interacted with the AI.
Instead of constantly saying:
"Write this function."
or
"Fix this error."
I could give Kiro a much bigger requirement.
For example:
"I need users to be able to reset their passwords through email."
Rather than immediately jumping into a code snippet, Kiro can help break the requirement into smaller pieces and work through the implementation.
This is where Kiro's spec-driven development approach became interesting to me.
Kiro can turn an idea into requirements, design, and implementation tasks before actually making the changes.
That sounds like a small difference.
It isn't.
Kiro made me think about requirements differently
When you're writing everything yourself, it's easy to have requirements in your head.
You know what you want the application to do, so you start coding.
With Kiro, I found myself thinking more carefully about what I was actually asking for.
What should happen when something fails?
What should happen if the user enters an invalid email?
What happens if the request is repeated?
What existing functionality should remain unchanged?
These questions matter because an AI agent can implement your instructions very quickly.
But if your instructions are unclear, Kiro can make assumptions for you.
And those assumptions might not be what you intended.
The impressive part wasn't the code
This was probably the biggest thing I noticed.
The impressive part wasn't:
"Kiro can write Python."
We've already reached the point where AI can generate code.
The interesting part was being able to give Kiro a goal and let it work through multiple steps of the development process.
Kiro can inspect the project, understand existing code, create or modify files, and work through implementation tasks.
That feels much closer to working with an AI developer than using traditional autocomplete.
And Kiro isn't limited to the traditional IDE experience either. AWS has continued expanding Kiro's agentic capabilities, including Kiro Web and Kiro Crew.
But Kiro isn't magic
This is where I think people can get the wrong impression from AI coding demos.
You can give Kiro a requirement and watch it produce a large amount of code very quickly.
But that doesn't mean you should blindly accept everything it produces.
I still need to review the implementation.
I still need to understand the architecture.
I still need to think about security.
I still need to test edge cases.
And I still need to ask:
"Is this actually the right way to solve the problem?"
Kiro makes implementation faster.
It doesn't remove the responsibility of making good engineering decisions.
The better way to use Kiro
I think the biggest mistake would be treating Kiro as:
"Build my entire application for me."
A better mindset is:
"Help me build this application, but let's be clear about what we're building."
The quality of the result depends heavily on the quality of the requirements and context you give the agent.
That's one reason I like the idea behind Kiro's specs.
Instead of relying entirely on a conversation with an AI, you can create something more structured around what the application is supposed to do.
The AI has a clearer target.
And I have something I can review.
Kiro also changed how I think about developers
This is probably the most interesting part for me.
If tools like Kiro continue getting better, developers may spend less time manually writing every piece of code.
But that doesn't mean developers become less important.
It may mean that different skills become more important.
Understanding requirements.
Designing systems.
Reviewing AI-generated code.
Debugging.
Thinking about security.
Making architectural decisions.
Knowing when the AI is making the wrong assumption.
In other words:
The value may move from writing every line of code to knowing what should be built and whether what was built is actually good.
Where I think this is going
Kiro is part of a much bigger shift happening in software development.
We're moving from:
Human → writes code
to:
Human → describes the problem → AI plans → AI implements → Human reviews
And Kiro is an interesting example of what that future could look like.
AWS is pushing this idea even further with Kiro's agentic capabilities and specialized Kiro Powers, which can give Kiro expertise around specific tools and workflows.
The question is no longer simply:
"Can AI write code?"
I think we've already answered that.
The more interesting question is:
"How much of the software development process should we let AI handle?"
And I'm still figuring out my own answer.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article