AWS re:Invent 2025 - [NEW LAUNCH] Kiro powers: Empower agents with specialized expertise (DVT343)

🦄 Making great presentations more accessible.
This project enhances multilingual accessibility and discoverability while preserving the original content. Detailed transcriptions and keyframes capture the nuances and technical insights that convey the full value of each session.

Note: A comprehensive list of re:Invent 2025 transcribed articles is available in this Spreadsheet!

Overview

📖 AWS re:Invent 2025 - [NEW LAUNCH] Kiro powers: Empower agents with specialized expertise (DVT343)

In this video, Arundeep and Dan from the Kiro team introduce Kiro Powers, a new feature that extends the agentic IDE's capabilities through shareable best practices. They explain how Kiro evolved from autocomplete to an agentic IDE using EARS syntax for structured development. Kiro Powers addresses the challenge of AI agents struggling with specialized tasks by providing dynamic, curated context from ISV partners like Neon, Supabase, Stripe, Figma, and Netlify. Each power includes MCP servers, steering files, and hooks that activate on-demand, reducing context bloat. The live demo showcases integrating a Neon database backend into a Next.js application and deploying it with Netlify, all through natural language prompts without leaving the IDE.

; This article is entirely auto-generated while preserving the original presentation content as much as possible. Please note that there may be typos or inaccuracies.

Main Part

Introduction to Kiro: An Agentic IDE Built for Development to Production

Hey folks, thank you so much for bearing with us for the last presentation of the day. My name is Arundeep, and I am a Senior Solutions Architect Manager for Kiro. Today I'm going to talk about Kiro powers, and I'm joined by Dan today. Hello folks, my name is Dan Kiuna. I am a Specialist Solutions Architect for the Kiro team. All right, so let's take it away.

We'll first talk about what is Kiro. Quick show of hands, how many of you have heard of Kiro? Awesome. I'm just making sure that I'm in the right place presenting. We'll talk about the existing landscape and challenges, and then we'll talk about what is Kiro powers. We'll end it with a live demo. We're taking the agentic leap of faith and hope that the demo works live today.

All right, let's talk about what is Kiro. Before we talk about what is Kiro, let's talk about how AI has changed software. I can't believe that it's just been three years, and we have seen so much innovation happen in the whole generative AI ecosystem and landscape. We started with autocomplete. I mean, guess when you were last excited when you could have functions being autocompleted on your IDE, right? It helped developers write code faster.

In 2024 came the agent assistance era, where the agents were assisting with larger pieces of code. You could now have full-blown modules, functions, SDKs, and you would be able to answer questions by talking to the chat assistant. And in 2025, the innovation took one step further, where you would complete development tasks end to end, more complex tasks like writing a full-stack application from scratch, migrating and modernization of full projects, end-to-end tasks with human in the loop always.

But what would a complete development experience look like if you could take full-blown advantage of AI agents, and that is where Kiro comes in. So Kiro is an agentic IDE that is built for development to production. The unique value proposition of Kiro is that you can create specs, which is creating a specification to span out your requirements in a markdown format. It uses the Easy Approach to Requirements Syntax, or the EARS syntax. I've memorized the acronym of that multiple times by now, but it uses the EARS syntax to go ahead and present the requirements, and then the requirements get turned into a design artifact, and then it gets scaffolded into all the tasks that need to be implemented by the agent.

Now, why is this important? Couldn't agents do the lines of code and write production code earlier? Yes, they could, but they would enter into an agentic loop, right? Because agents would steer away in a different direction. There was no structure to the coding that was created by the agent. So we went ahead and thought that the first step is to move towards the software development life cycle and how we have done and produced software in the past, and how can we use that and feed it to an agent so that it could follow a structured approach, right? So that is what Kiro is.

Existing Landscape and the Challenge of Specialized Development Tasks

Just to give you a recap of features, if you have not attended multiple sessions for Kiro this week, that's totally fine. I'm going to do a quick recap of all the features that exist within Kiro today. On the right side of the screenshot, you see the agent. That's the primary mode of interaction with the agent. It's a separate sidebar chat. You can do vibe prompting and vibe coding by chatting with the agent in the vibe mode, or you can use the spec mode where you can create a spec and author a spec by prompting in natural language. Once you produce the prompt, then you can see the artifacts that get generated in the Kiro folder.

On your left pane, you also have MCP configuration. You can integrate with either local MCPs or remote MCPs, and we have added additional capabilities for MCP integration using OAuth as well. And it's not uncommon for agents to be taken in a different direction, and you would want to steer the agent in a particular way. And for that we have steering rules. So steering is a set of rules in markdown files where you can guide the agent for a specific behavior. For example, if you're working on a Python project and you want to use a specific framework for testing, then you would go ahead and add a line in your steering file and say that always use pytest, always use it in this format, and the agent will steer to use that.

Outside of that, you have agent hooks, which is essentially nothing but automations that can be executed based on events that happen in the IDE. So, for example, if there is a file save in a TypeScript project that says that I'm updating my component, go ahead and run a hook and update the readme for that component so that everybody can take advantage of the readme.

So these are all the features that exist in Kiro today. But if you take a step back and look at the existing landscape of what are the tools that exist out there in the industry today, MCP servers provide a standard for connecting tool communication across clients. So we've got MCP client and MCP server. So you don't have to author M times N integrations. You just do M plus N. So if your agent is interacting with N tools, you just have 10 tools for you to interact instead of deploying 50 integrations.

Skills, if you work with Claude, then you have instructions or set of scripts and resources that can guide the agent in a specific behavior which Anthropic introduced. And you can also look at dynamic tool handling which is discovering and loading tools on demand. This is something similar to tool search by Anthropic. And then if you take a look at IDEs like Cursor, they have a specific set of rules that provide custom integrations or instructions to the agent, which is very similar to what we have in Kiro as steering rules. But now let's jump into the problem. AI agents, what we have seen, are still performing in a generalist behavior. They're not specialists.

If you take a look at a generalized dev task, code structuring, yes, it can do that really well. Code reviews, code testing, completion, and documentation, making sure that the READMEs are right, and performing updates as and when your code changes. But when you look at a specialized dev task, this is where the entire ecosystem of development comes into play. If you're looking at a UI developer, the UI developer might have special requirements for working with Figma for design to component generation. If you're looking at an API developer, then the API developer might have integrations with OpenAPI or any other framework that is very specific and niche to that developer's environment. And same thing goes with databases. Databases is a huge beast, and backend development in AI agent development. So the challenges with specialized development is that AI agents today struggle with specializations.

This overload of documentation, multiple MCP servers and tools that exist that is passed as context, and developers need to spend a lot of time in guiding these agents in use cases. There's a lot of handwritten steering files that we have seen from customers that are guided and catered to these specific use cases. And then there's no prescriptive best practices for dev tools. You can connect to tools but with limited opinionated guidance. And then there's very limited dev expert collaboration. So there's domain expert knowledge that is not codified and there's limited mechanisms to exchange expertise. So now we have framed our problem statement where AI agents need dynamic access to tailored context gathered from use case specialists.

Introducing Kiro Powers: Shareable Best Practices for Extended Agent Capabilities

Now, this can be provided, but over time, what would happen is there would be context bloat because you're passing in the context of all the MCP servers and tools that's configured in your IDE, all the steering files that has been configured in your IDE. And that is where we are coming up with a new concept called Kiro powers. We launched this yesterday where you can now extend Kiro agent capabilities through shareable best practices, all from curated powers that we have worked with for specific ISV use cases, and we plan to expand these use cases as well.

So what does the power include? It can contain one of the following or all of the following, which is an MCP server, a steering file, and hooks for actions. Now what are the benefits of this? The dev to deployment use cases, spanning full stack development, backend development, API development, database development, observability, you name it, you can target that specific use case and targeted context for fast decisions by the agent. Now the agent does not need to run into a loop if it needs to figure out what are the tools that it needs to access for full stack development. And best practices curated from ISVs. If you want to integrate Stripe for payments, you don't have to worry about figuring out a number of best practices that you have come across or hand authoring them from your own. This is curated by Stripe themselves. This is a power that has been created by Stripe, right?

So what does the anatomy of a power file look like? So a power.md file will look something like this. So this is the name for Supabase, and this is the display name as to how it would look like and the description and keywords that can identify that specific domain.

For example, if somebody prompts saying, "I want to build a database and I want to build a full stack application by integrating with a database, and that should be Postgres," then your agent that will have access to the Supabase power will activate that power and only use that power on demand to create that.

Right, so these are the specific list of partners that we have worked with for launch. We plan on expanding this to more, but honestly, Dan is going to show you in just a bit where you can author a power of your own requirements, and you can share that within your organization too. So that's the capability of powers. We have worked with Figma, Supabase, Stripe, Neon, Datadog and Dynatrace, and Netlify, Strands as well, and along with Postman for launch.

Live Demo: Building and Deploying a Full-Stack Application with Neon and Netlify Powers

All right, I'll hand it over to Dan for a live demo. I'll go ahead and demo Powers really quickly and kind of show how Powers are in action. So what we've done with this new launch is we now have a new pane at the top there that helps you manage all the powers that you can add to Kiro. And there are two main sections. There's a section where all your installed powers are, and there's this new section where all of our partners and curated powers are going to be displayed.

And so for this example, what I have is I'm a backend developer, let's say, for this scenario, and I've been tasked with creating a database with Neon. So a front-end developer shared some front-end code which is just a simple Next.js application, and I just need to add a backend to it and start displaying data to the front. So what I can do is I can come in here and find the Neon power and have it installed.

And within a few seconds it is now ready to be activated by the Kiro agent. So some of the things about the Neon power that's contained in the Neon power is it has an MCP server that the agent will be able to interact with, as well as a set of steering files that discuss the best practices and how to address certain scenarios.

So I'll start by just prompting the agent and just say, "Add a backend database for my front-end application." And by just having that simple prompt, it'll take a look and it should identify that as a Neon power. As you can see, it's been activated and start using that power. So before this activation happens, all the context that may have been included if I had manually included the MCP server and any steering files would have been included, but now as the agent is going through and utilizing the power, it's asking me to trust this tool, so I'll go ahead and accept.

That's getting pulled in as the agent is discussing. So it helps with things like context bloat as well as aligning to the best practices. So I'll go ahead and accept the list of projects. It's just checking now my Neon account for any projects that might exist. And the reason this is automatically working is I had already set this up before, and so the MCP server had already authorized with my account through OAuth. So if this is your first time, you will see a little pop up that says authorize and connect your account to the MCP to your Neon account.

So it's going to go through and do some initialization, create some backend files, edit my current front-end files, and set up the integration, and it'll give me a summary of that. So it's telling me the next steps is to add my Neon database URL, so I should be able to just ask the agent to do that for me. Let's add the database URL to the ENV file. So it'll start setting up that for me. It's going to make some more MCP calls, and again these are being brought in dynamically, and so it's helping keep my context window as minimal as possible.

So it's going to check for any projects that I have and try to retrieve the connection string for that. If you wanted to create a new project, you can also obviously prompt it in that direction. But since I already have an existing database, I'll just let it use that existing connection string. So it's going to modify my secret variables in my ENV file, and I'll accept the changes. And then I'll go ahead and say, "Is there any additional setup required?"

The agent should now be able to analyze my project one more time and double check with the Neon power to cross check what else may be needed or if everything is completed, that way I can go ahead and run my application locally. It does look like it does need to create a table or check for a table and run an SQL command using the MCP tool, so I'll accept that. It'll invoke that tool and make the calls for me. It looks like we're still running the same command. The good thing about this is I did not need to leave my IDE, go into Neon, and set anything up. The agent and the power working together are doing that for me while I focus all my attention into the IDE itself.

I'm going to go ahead, it's going into a loop here a little bit. Okay, so it's created the database schema and it's saying my application is ready, so I'll go ahead and prompt it to run a local dev server for my application. It'll go ahead and in this stage again it's managing my context and will run this. There may be an error as expected because there's one more step that we need to do, which is install the dependencies, so it'll go through and oh yeah, I forgot to install my dependencies, so it'll run the install command for me. After this, it should be able to run the local dev server and we can start interacting with the application.

I also noticed another cool thing is now you can see how much of context has been used within Kiro, so I don't know if you can see the indicator at the bottom. But that's a cool little indicator for the current session, how much of context has been used by the agent. Once it turns fully green, that means the whole context has been consumed. That's correct. Yeah, so without powers, and you can do your own testing, without powers that might fill up a lot quicker, but with the power, with the use of a power, it helps manage that context a lot better. We'll run our local dev server and now we have it running locally, and we shouldn't see any data, so I'll refresh this. Now we see that we don't have any data. What I can do is I can say, add some sample data to the backend.

It'll interact with the Neon power and utilize the MCP tools and add some dummy data. It's going to run an SQL command to insert some products. Again, the reason why you didn't actually see data is because there was no data in the database, right? The tables were created new, so we're not faking it by like adding something on the UI and showing a products page. Yeah, this is all live, correct, yes. Yeah, and the other cool thing is nowhere in my prompts did I mention anything about products, right? All that context was already in the front-end application. The front-end application had some metadata that said this is for an e-commerce website that has products. By inferring directly from that, it's able to create the database tables as well as products that I need for my local dev server.

It's going to keep running a few more SQL commands and insert some products. Once that's done, I can go back to my front end application. We have six products added and if I do a refresh here, I think I might have to do a hard refresh. We now have six products that have been inserted all through by using the power. Another cool feature from Neon that Neon provides is the ability to also branch your backends. I can, if I wanted to, if I was interacting with some data and I wanted to maybe modify my tables, my schema, things like that, Neon has a feature where you can create a branch and make your changes that way you're not affecting any tables. I can do that from here.

For example, I can come and prompt the agent and say I want to modify my database, please create a branch. From here it'll go in and make the request to my backend, my Neon table, and then it's going to retrieve some metadata about my current existing project, create the branch, and then now I can interact directly with that branch from my agent. Modify the schema, have any products or changes that are needed to be done locally, and once I'm happy with my changes, I can go ahead and merge the branches into my main, the dev branch into the main branch. So I'll let that complete. Dan, this is cool from a backend developer's perspective, right? Like, what if I wanted to host this application or deploy this application? That's a great question. Let's say I'm done. I've done all the changes that I need to do, and I wanted to now deploy this somewhere.

You could, for example, if you're working with Netlify, we also have a Netlify power, so you can come in here and install that power if it's not already installed, start a new session, and then just essentially ask the agent to, I would like to deploy that power. So if you say, please deploy my application, this should detect that hey I want to deploy the application and there's a Netlify power available, and so it'll go ahead and activate that power for Netlify and then interact with my Netlify backend.

There's a few steps still needed for Netlify to work because it does utilize some Netlify CLI commands, and so you set up the authorization and any other setup, and it'll walk you through that as well as any setup that's needed so you can actually deploy it. But after a few seconds, what you should have, or let's say a few minutes, let me say you should have something to where, because I've done this before, it'll output all the different deployments and so you would have your, let me copy this, and the applications won't match, but you have this deployed somewhere with valid products, of course.

So that's where the power of powers comes from is that again it helps you streamline your workflow, get to what you need to do faster. I could have spent maybe an hour, a couple of hours setting up the steering files trying to figure out what's the right MCP server, what are the best practices, but with powers I was able to immediately go from having just a shell of a front end application to a fully deployed application as well. Cool. That's all we had for our talk today. Thank you so much for attending, and we're happy to take any questions off stage.

---

; This article is entirely auto-generated using Amazon Bedrock.