In the first part we talked about the Agentic revolution: the evolution from traditional models to intelligent agents, what the Agentic Loop was, MCP, Strand Agents, and how they can work together to create wonders.
Now it’s time to see those wonders, which in AWS’s case have materialized in: Amazon Q Developer CLI and Kiro.
In this post we’ll cover:
- Amazon Q Developer CLI: The natural evolution of AI-assisted development
- Kiro: The AI agent that’s redefining automation
- Revolutionary use cases that were previously impossible
- The future of human-agent collaboration
- Why this revolution is different from everything before
Amazon Q Developer CLI
Beyond a Code Assistant or Conversational Chat
Some time ago, at re:Invent 2023, AWS launched Amazon Q. At that moment, it seemed like AWS’s best launch, but over time the balloon deflated and honestly, although it was useful for some things, I found it not very useful, even giving me recommendations I didn’t like.
In March 2024, AWS launched AWS Q Developer CLI and here we truly had a tool that is a Game Changer.
Let’s see what AWS Q Developer CLI is and how it differs from what we had before.
Q Developer CLI: An Agentic AI Assistant in Your CLI
Unlike other assistants, including Q Developer itself (without CLI), this integrates into your own CLI, allowing you to interact with your own PC and use its tools to help you.
Q Developer proposed improvements to your code or allowed you to generate code based on interactions with it, but Q Developer CLI is capable of reading an entire directory of code, documentation, Excel files, and based on them, generate code or even execute actions.
A clear improvement is that it’s an assistant within my own PC, with my own context. Moreover, it can read files (that I give it access to) and execute OS actions (those I allow), so it can be autonomous in multiple tasks.
An example I usually mention is something that habitually happens to me: some problem with an SCP that I’ve set up myself. I discover that I have some SCP (which most of the time I created myself) that’s blocking an action, but since I’m absent-minded, I don’t remember which SCP it is and I have to investigate it. It’s something simple, but requires time.
With Q Developer CLI, I can give it read-only access to my master account, my problematic account, and even my Logs account, explain my problem, and have it help me identify it.
It’s not a complex task but it’s very tedious, plus it requires reading policies very carefully.
Q is capable of reviewing what action is being denied, relating it to my SCPs, and proposing a solution, and even, if I let it, executing it autonomously.
This is one example, but there are many others like asking it to help me identify cost problems or even simulate the cost of an architecture.
On the other hand, I focus a lot on AWS, but it can also review documents I have on my PC and generate new ones, help me with HTML problems on a website, or even help me with performance issues.
Kiro
What is Kiro?
In July 2025, AWS announced Kiro, which is a native IDE in Agentic AI. It’s a clear evolution of Q Developer CLI but more oriented to a developer environment.
Unlike traditional editors with AI plugins, it’s designed from scratch as an intelligent agent that can:
- Understand the complete context of the project and its dependencies
- Execute complex tasks autonomously with human supervision
- Maintain persistent context of project decisions and patterns
- Integrate tools through MCP (Model Context Protocol)
- Generate code autonomously
Beyond the Usual Vibe Coding
A difference with Kiro is its method of operation. Instead of doing Vibe Coding, Kiro is capable of defining a Spec for a project so that it follows these steps:
Requirements Gathering: Generating readable project requirements based on our context. Design Generation: Once requirements are defined, Kiro will generate a design based on them. Task Generation: When we have a closed design, Kiro will generate a series of tasks to execute the project based on the agreed requirements and design.
Each of these points requires manual validation. In this validation, we can accept what Kiro proposes (I don’t recommend it) or carefully review the requirements, design, and tasks for the project to be successful.
Autonomous Execution
Once the plan is defined, Kiro can execute tasks independently, from code generation to infrastructure configuration, including dependency management.
Advanced Context Management
One of the advantages of this model is that Kiro has context of the entire project and not just separate sections. Additionally, each interaction of each task feeds the context, making execution very complete.
Moreover, by using the Specs that I’ve validated, Kiro will follow instructions without straying from the path.
This is further enhanced by a Kiro functionality called Agent Steering that will allow us to standardize conventions in Kiro, which we can also share not only at the level of all our interactions with Kiro in this project, but those of the entire team.
Allowing all development to follow the same rules we impose (Naming, Library Usage, Project Alignment, etc.)
Kiro’s Impact on Development
Before Kiro
Developer/Engineer → Plans → Codes → Tests → Deploys → Maintains
With Kiro
Developer/Engineer → Defines objectives → Kiro assists throughout the cycle → Developer supervises and adjusts
This transformation allows developers to focus more on strategy and creativity, while Kiro handles much of the tactical execution under supervision.
Obviously, the model isn’t perfect and Kiro will make mistakes, hence the need for supervision, but it will give superpowers to our developers/engineers to be more efficient.
MCP for AWS Q Developer CLI and Kiro
How MCP Powers These Tools
Both Kiro and Amazon Q Developer CLI leverage MCP (Model Context Protocol) to extend their capabilities natively.
This way they can execute tools, from reading or modifying local files, to connecting to external tools, such as AWS itself. They can also read official documentation, best practices, and even known issues.
This makes them very powerful as individual tools, but the ability to interact with other tools makes them even more powerful.
For example, on many occasions you can ask them to install a tool to execute an action, like reading a gigantic CSV to make a data correlation.
The Power of Standardization
We already talked in the previous article that MCP is very interesting because it’s an open standard and allows integration with many services, which are growing every day.
This MCP integration means that:
- Any tool that implements MCP works automatically
- We can create our own MCP servers to improve our contexts
- The MCP ecosystem is growing organically and collaboratively
- There’s no vendor lock-in in integrations
I recommend taking another look at the MCP that AWS itself has. With them, you’ll be able to have incredible power.
Why This Revolution is Different
So far, the post is a summary of capabilities, but how does Kiro or Amazon Q Developer CLI help me and why is it better than other AI tools I used before?
Okay, I’ve said this a lot, but what does this change mean?
Until now, I could ask any AI and it would help me, but it didn’t execute actions for me. It’s true that I could generate my own agents and could call them, but it’s complex.
In this case, I can use these tools to help execute my daily work, in a simple way.
It’s Not Just Another Incremental Improvement
Qualitative Change, Not Quantitative
I’m not going to use a revolutionary LLM. Moreover, both Kiro and Amazon Q Developer CLI use Anthropic models, being able to choose between the most recent Claude Sonnet versions.
As you can see, they’re not even Anthropic’s most powerful models, but how we use them makes more sense. The Agentic Loop will divide tasks into multiple tasks that it will execute sequentially, allowing problem-solving and improvement in response.
Role Transformation
Instead of executing or writing code, our role changes to defining strategy. That is, I can ask Amazon Q Developer CLI to help me find a problem and it will execute the diagnosis for me, and I can guide it until finding the most appropriate solution and it will even help me implement it.
Or in Kiro, I can define a new project and define requirements and guide development.
Additionally, these tools will be proactive and can warn us of problems or bad implementations.
Prompt Improvement
I no longer need to be a Prompt engineer to have a coherent response. One of the great advantages of this model is that context grows according to interactions and learns from errors. If the model itself detects an error, it will solve it, but it also saves the context of that error. Additionally, it will be able to execute tools to gain context, like reading a file with requirements, reading an example of what I expect, consulting documentation, or executing remote actions in an AWS account or other provider.
The Multiplier Effect
Exponential Productivity
One of the improvements of these tools is that they allow us to advance faster. Instead of performing tedious tasks, like reading a YAML (Never happened to me 🤦) to find that we’ve misplaced a space and broken the entire file, they can do it for us quickly.
They also allow optimizing what we do on the fly and let us implement it to our complete stack.
Imagine that in the middle of development we discover a way to improve our APP’s performance and it’s applicable to other areas. Until now, we had to have these areas identified and apply the improvement. Now these tools can do it for us.
Development Democratization
These tools also help make advanced capabilities more accessible to everyone, although let me clarify here that they need human supervision.
I don’t recommend trusting 100% in what they propose, because they don’t always get it right. If you don’t have experience in an area, it’s recommended that someone with experience review it before putting it in production, but it’s true that they can help us in areas where we have doubts or perhaps don’t fully understand.
AWS Q Developer CLI, Kiro and Me
Okay, but how can we use it in our daily work?
I use both tools, but for different use cases.
AWS Q Developer CLI helps me a lot in my daily work when I need to execute actions, that is, solve a problem, execute something, while I use Kiro more for the end-to-end of a project, defining specifications and requirements.
To help you, I’m going to tell you some examples from my daily work.
AWS Q Developer CLI
When I have to execute some action, solve problems, compare things, do an assessment, do tests, make documentation, AWS Q Developer CLI is my champion.
For example, I have to do an Assessment of an account. It’s something I can really do with my eyes closed, but it consumes quite a bit of time, so I can launch an interaction with Q:
|
|
This example is very simple, but it allows me to pass an example so Q executes a series of tasks following a standard generated by me.
In this case, it needs to read a doc, and therefore use an external tool to read it. I can do it with an MD, but I want it to generate a doc based on my format.
Another example is when I have to perform a Cost calculation in AWS and I’m using servers with licensing. A common question is the cost of this licensing. It’s something simple to extract but very tedious because it requires extracting the cost of instances without licensing and subtracting them, but with Q it’s simple:
|
|
This example created a script that is the base I now use when I need to make these calculations.
We can also ask for many more things, for example reviewing SCPs, implementing changes, reviewing problems, etc.
These are things I can really do, but they would take me much more time.
Kiro
Unlike Q Developer CLI, I use Kiro for long-term projects, when I want to maintain context for a long time and also need to create complex code that needs many iterations.
In this type of project, Kiro is better (I can do it with Q Developer CLI, but Kiro is better).
For example, if I ask Kiro the following:
"Create an e-commerce application with:
- Frontend in Next.js
- Backend in FastAPI
- PostgreSQL database
- Payments with Stripe
- Authentication with Auth0
- Deploy on AWS"
First, it will generate a Requirements file:
Second, it will generate a Design:
And finally, a task list:
Once we have the 3 files, we can start launching tasks and create our implementation.
In fact, I’ve tested it in several implementations (which for contractual reasons I can’t show) and it works quite well.
Pricing Models
We also have to compare their pricing models.
Amazon Q Developer CLI
Amazon Q Developer CLI offers a simple pricing model oriented to teams:
- Free Tier: 50 agent requests per month, ideal for trying the tool
- Pro Tier: $19/month per user, with increased limits and enterprise functionalities like:
- Increased agent request limits
- Code transformation capabilities (4000 lines of code per month)
Kiro
Kiro presents a more flexible model with multiple levels:
- Free: 50 perpetual credits (don’t renew monthly)
- Pro: $20/month with increased capacity
- Pro+: $40/month for users with intermediate needs
- Power: $200/month for intensive use
Paid plans include additional flexible usage at $0.04 per additional credit, allowing scalability according to actual use.
Comparison: When to use each tool?
| Aspect | Amazon Q Developer CLI | Kiro |
|---|---|---|
| Best for | Specific tasks and problem solving | End-to-end projects and complete development |
| Type of work | Execute actions, diagnose, analyze | Create complex code with multiple iterations |
| Context | Short sessions, specific problems | Persistent long-term context |
| Typical use cases | Assessment, cost calculation, troubleshooting | Complete applications, complex architectures |
| Methodology | Direct interaction and immediate execution | Specs → Design → Tasks → Implementation |
| Required supervision | Moderate, for critical actions | High, especially in spec validation |
| Main strength | Speed in operational tasks | Structured and methodological development |
| Pricing | Free: 50 requests/month Pro: $19/month per user |
Free: 50 perpetual credits Pro: $20/month Pro+: $40/month Power: $200/month |
But Is Everything So Beautiful?
The short answer is no. Neither Kiro nor Q Developer CLI are infallible. On many occasions, especially at the beginning, they won’t meet our expectations. We need to keep some things in mind:
Review Specs Very Carefully
This is perhaps the first problem. We have to be very clear about what we ask for. In Kiro’s case, we have to be very careful when generating a new SPEC. We have to review each point very carefully. Many times we assume requirements because they seem basic to us, but for both Kiro and Q Developer CLI they’re not so basic, so we might have to redo our work from the beginning.
That’s why my recommendation with Kiro is to spend time reviewing requirements, design, and tasks, since all the time we spend will be beneficial in our implementations. In Q Developer CLI’s case, it’s similar. We have to be specific about the limits we set for our interactions, as well as define the context well. We don’t need to make a giant prompt, but we do need to adjust it and understand what context Q has of what we want to do.
These Tools Require Supervision
It’s not about letting these tools do development autonomously. If we do that, the result will be quite bad.
Here I always use the analogy of a Junior. You can delegate work to a Junior, but you have to audit it so they don’t deviate and don’t make mistakes. If a Junior makes a mistake, it’s our fault as Seniors, since we haven’t supervised them well. The same happens with Kiro and Q Developer. We have to audit what they do and if they make mistakes, feed the prompt so it doesn’t happen again.
This can be frustrating at first, but over time you understand how they work and how you can improve your prompts.
They Always Choose the Easy Path
This doesn’t always have to be a bad thing. On many occasions, we tend to complicate ourselves and these tools are designed to use the easy path.
The problem is that on other occasions their easy path is disabling a feature, doing a simple analysis, or skipping a step. This is something we have to keep in mind and be able to detect.
A Loop Can Be a Very Big Problem
On certain occasions, you can enter a loop where they recommend a solution, it doesn’t work, you have several failed iterations, and they return to the beginning to propose the same initial solution.
This isn’t common, but it can happen. We can even feed it back ourselves by telling it not to do something specific and then it proposes it as the best option if others fail…
Curiously, it has a simple explanation. On one hand, we have to keep in mind that models are trained at a given moment and then fed via RAG (retrieval-augmented generation), which can mean the solution isn’t looked for outside (In an MCP). But it can also happen that we ourselves feed the model by telling it not to do something. That action enters the context and although I understand it as not valid, it will propose it to us because we’ve told it it’s an option…
In the end, it will always look for the easy path, although we can force it not to.
They Can Invent Features
These tools usually give us incredible ideas, but sometimes they’re as incredible as they are impossible.
This has happened to me sometimes with Control Tower and terraform. On occasions, they’ve recommended using terraform resources that don’t exist (although it would make sense if they did). In those cases, you can realize it yourself and ask if it exists, or on other occasions, you’ll realize when implementing.
Be careful with what they propose and if it doesn’t fit, ask them to reason it out.
Sometimes They Can Be Dangerous
On some occasions (more Q Developer CLI than Kiro) it has decided it’s a good idea to delete something or stop something without my permission. On one occasion, it deleted my AWS CLI Credentials file because it didn’t know how to use a profile…
They’re very powerful tools, but they also require us to be attentive. We can limit this in the Prompt, but I recommend you pay attention to the actions they execute.
So Better Not Use Them?
Precisely the point is the opposite: use them but with sense.
They’re very powerful tools but require control.
They’ve really solved many things for me, besides helping me a lot.
- I’ve reduced execution time for many tasks with the help of Kiro and Q Developer CLI
- Some great ideas that hadn’t occurred to me or that I didn’t have time to implement are now implemented
- I hate documenting and the time I dedicate to documenting has been reduced a lot, and most of the time they explain things better than I do
- They force me to do testing, but they do it themselves
Final Reflection
The era of AI agents has begun. Are you ready to be part of this revolution?
It’s not about replacing developers/Engineers, but about enhancing our capabilities in ways we had never imagined before. These tools help us execute certain tasks that take us a lot of time or are repetitive and allow us to focus on what really matters: create, innovate, and solve complex problems.
To put a curiosity, they’ve helped me perform tasks while attending a meeting, something I couldn’t do before, because in the end I neither attended the meeting nor was I aware of what I was doing.