AWS re:Invent 2025 - Accelerate development with Kiro's new agentic AI capabilities (DVT228)

🦄 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 - Accelerate development with Kiro's new agentic AI capabilities (DVT228)

In this video, Kiro Powers is introduced as a new feature that bundles MCP (Model Context Protocol) and steering instructions to give AI agents specialized capabilities without overwhelming them with context. The presentation demonstrates how Powers work through live demos using Figma, Postman, and Supabase integrations. Harry Mauer from Postman shows how their Power enables automatic API collection creation and mock server setup directly in the IDE. Tyler Schuckert from Supabase demonstrates building a complete personal banking app with proper database schema, security checks, TypeScript type generation, and authentication. Powers can be installed with one click from a curated marketplace or custom-built using a power.md file, making agents extensible while maintaining performance through progressive disclosure of context.

; 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 Powers: Addressing the Generalist Problem in AI Agents

We're going to be talking about Kiro powers. I'm doing the He-Man power move, similar for you. Quick show of your hands, how many people here have used Kiro? All right, cool, a handful. How many people have heard of Kiro? Yeah, I think we did our job. When I had a session on day one and I asked the audience, it was like 30%, and by day four now, everyone knows about Kiro. So we're hoping that a lot more of you try Kiro once you get back over the holidays, actually, and hope all of you took advantage of the 1000 free credits you can get at the Kiro haunted house back at the Venetian.

So today we're going to talk about powers. This is a feature that we launched just yesterday morning. I will get into what it is and what problem it solves, but here's the rough agenda. We'll start with the general problem that we were trying to solve with powers. How we're going about solving it. And then I will do a live demo, so hopefully the demo gods are with me. Oh, I totally forgot. I forgot to introduce, we have two partners here. I have Harry Mauer, who's the CTO of Postman, and then Tyler Schuckert, who's a DevRel engineer at Supabase, and they're going to talk about their use cases, about how they're using powers to really streamline the onboarding for API development and backend development.

Now I'm sure you've seen a variant of this slide over the last four days over 1000 times. AI has transformed software development. What started with inline code suggestions that would give you a function has now evolved to full-blown agents that are able to build large features in your code base. But one of the problems is that AI agents are still generalists, jack of all trades, if you will. So every time you go to do something specific, like you're working on a front end or you're working on an API or a backend, there's a lot of massaging you have to do with the agent, providing the agent a lot of context to get the right outcome you want.

The Challenges of Specialized Tasks: From MCP to Context Rot

For specialized tasks, agents do face challenges. The first one really is that software is evolving every day. Every day there's a new SDK. Every day there's like a new tool or technology that's launched. The models that power the agents are often trained on data that isn't up to date. So if you want to work with an SDK like the Strands TypeScript SDK for agent development that came out at re:Invent, you're going to have to figure out how to get the model, or the agent, to build Strands stuff. You could link it to the docs, but it's just going to go ahead and decide what it wants to do.

And the second problem is that even when the agent does know about a particular piece of technology or a framework, it can miss steps and it doesn't really have an onboarding manual for that technology. MCP was built to solve that problem. How many of you are familiar with MCP? Okay, so MCP is Model Context Protocol. It's a convention that was built so that you could share, so it allowed for agents an extensible model when working with agents. So for example, both our partners here today, Postman and Supabase, have MCP servers. The MCP servers really talk to their APIs, so they're able to do things like list projects, update tables, create collections.

But the MCP alone is also not enough. The problem that happens with agents is as you add more and more MCPs to your agent, the agent gets overwhelmed with context. And a real problem that's emerged in the industry as a whole is context rot, that as more tools get added and are made available to the agent, performance degrades, and quality output declines. Additionally, even with the MCP server in hand, there's often guidance and onboarding instructions that are completely missed that the agent just does not follow.

So what you often need to pair is almost a combination of MCP and context. Now a lot of solutions have popped up even beyond MCP in the market now. You have Claude Skills, you know, Anthropic recently launched, it's called Tool Search Tool, kind of a weird name, that allows you to dynamically discover tools. You have cursor rules, you have agents.md, but they're sub-agents. But they're all different ways to get to the same thing.

If you go look online in the forums and on Reddit, people are very confused about what to use and when to use what. There are tons of YouTube videos about MCP versus skills versus sub-agents, and they all kind of do the same thing. The end goal is really you want to generate code to match your intent.

Kiro Powers: Bundling MCP and Steering for Extensible Agent Capabilities

So we really took a step back with powers and we thought about how do we get the agent to learn something specialized, and do it in a way where it doesn't actually overwhelm the agent with context. And that's kind of why we launched Kiro Powers. What Kiro Powers do is they're a bundle that gives the agent extensible specialized capabilities. It really makes your Kiro agent extensible so you can add a power, and then the agent knows about that power. When you take on a task that is related to the power, the agent can just automatically discover it.

The unique thing here is that as you add these powers, they're not going to overwhelm your agent with context because the agent is getting very minimal information about the specific technology. So in this case, if we add Postman and Supabase, the agent just knows that it has these Postman capabilities available. If you ask questions about APIs, it'll automatically just say hey, I need to use the Postman power, and it'll actually start going ahead and following the instructions in the power.

What the power really contains, and I'll show this in the demo, is a combination of front matter and markdown. There's a power.md file that defines basically onboarding instructions and a workflow for the agent to follow, and that's the only required piece of information. But what you can also do is combine that with MCP tools to really make it powerful. So power is the only available solution out there right now that combines steering and MCP in one bucket.

What we do is we have a template really for the power.md that allows you to do things on install and on activation. It allows you to install hooks and steering files, which I'll kind of show you in the demo. We've partnered with partners, so we've got a curated set of partners. We've partnered with partners across the lifecycle of application development. So from UI development with Figma to API development with Postman to backend development with Supabase and Neon to payments with Stripe.

Building and Sharing Powers: A Community-Driven Approach

It's not just curated powers. We've built it in a way so anyone can build a power. In fact, in my demo, what I'm going to do today is start with one of the curated powers and then actually live build a power and bring it into my project. What that allows is really the community to build a whole variety of powers. Just yesterday at my last session, I had three individuals come up to me and say, hey, I've got this really cool use case for a power. They were doing Java upgrades and apparently that's really hard. I'm not a Java developer.

We already have, there's multiple repos. Someone created a Kiro Powers repo overnight, and they've got a Playwright power. So it's really going to open up an extensible model of working with Kiro, because I trust me, you're going to have a power for that. What we've done is our UX is also very simple. So within the Kiro interface, the IDE interface, we have a new powers pane where you just click on the power. It loads our curated powers, and you can just one-click install it, and you will see this very shortly.

As I called out, even from the same interface, you can build your own power or import a power. So if you got a public GitHub URL, someone on the internet shared this power being like, hey, this is a super cool Playwright power I built, you can just add that and your agent will have awareness of that. The second use case is a start of phase one of our journey towards more governance for teams around powers. But it alone will already enable teams. So let's say you have a team and you want to define coding conventions, you define rules around how you work with particular technology.

You can define that in a repository with Powers, and you can actually import the Power from a folder so each developer can clone the repository to their individual environments and actually import Powers. We're going to make that a lot better in the future.

Finally, this kind of organically came up as we were working with partners because every partner was saying, hey, now I've got to maintain these unique files for every provider because as we all know, there's a lot of agentic tools out there. What we wanted to do was not build something that's proprietary in nature, so hopefully with the way we built this under the hood, Powers is itself an MCP server. So hopefully once we make this public, we didn't make this public immediately, but you can use Powers with Klein, the Hero CLI, Cursor, maybe even Claude Code. And hopefully when we do that, Harry and Tyler here will be able to keep that one file and actually when working with multiple providers they can just provide that bundle as context.

Live Demo: Exploring the Kiro Interface and Job Seeker Application

So I think I've spoken enough about Powers here. So let me actually go ahead and switch to a live demo. Since there were many people in the audience who have not actually used Kiro, let me give you a quick tour of the interface. So Kiro is an IDE fork of Code OSS, and what we really have is this Kiro pane here. It has four features that we launched with, so the application that I'm showing you today is an application I've built in my last two demos. It's a job seeker's app.

So the pitch here, and my plan is after this I'm going to quit my job and go build the next billion dollar unicorn, but the pitch here is that people looking for jobs often have tools and there's enough information available to practice questions, but there isn't really a way to practice tone and style and diction and how you're answering something. So we built, we live built this app in a one hour session where essentially the flow is like a user starts an interview, you voice record the answer, we transcribe the answer, and then after you go through the interview, we send the results to an Anthropic Claude SDK that then generates a qualitative and quantitative score of how you did. And we use Specs, so if you're not attended any of the sessions on Kiro, Specs is the unique feature that we added to the space. It gives a structured approach to building with AI because you can really plan effectively before you go and implement work.

So to give you, can everyone see the interface okay? I'll just make it a little bigger. To give you an overview of the interface, so you start with a prompt, and what we break that prompt into user stories and acceptance criteria that actually define your requirements. So in this case you see things like as a job seeker I want to answer interview questions using voice recording so that I can practice speaking. Then we switch to a design and the design really, if you look at it, it starts with an architecture diagram, so this is a React application and it's got all the components and interfaces within it. And then you get to a task list, and the task list includes optional tasks and required tasks that you can then execute.

Now this entire flow, we did this flow in a whole session where we built this application and I'll do a quick demo of the application as well because you can start with an interview. Agentic development involves working with MCPs, context, and tools. It's a hard problem to solve, which is why we launched Powers. Powers was a technical problem we solved recently. We did this in a way where we used the concept of progressive disclosure to make the agent effective. I research things on the Internet and using social media. And then what this app does is that

the system sends this data over to the cloud, transcribes that data, and sends it to a model. The model analyzes the results and gives me a score. It looks like I'm not ready to get a job yet. There's a lot of work I've got to do. And it gives you qualitative feedback as well. Cool. So that was a quick tour of the application. I didn't really talk about the other features, but we have hooks.

Hooks are a way to implement lifecycle events, so they actually watch the IDE for different events like file save, file create. We're adding more like on agent chat complete. And you can actually do things. You can do actions, so you can ask the agent to do something, or you can run commands. It's kind of an enforcer, if you will, when you're working with agents. And then as we talked about, MCP and steering are like ways to guide the agent, to give the agent rules to follow when they build things.

Figma Power in Action: From Design System Rules to Chrome DevTools Testing

It's a very quick overview of just the core Kiro interface. Now, what we launched with powers is this new tab here. So adding a power here is really easy. What I'm going to do in this demo is that I have this interface here that I've built. This was the interface I built just in my last session. But I also have a Figma file that, let's say my designer built, and this kind of looks much nicer than what you just saw, right?

So what I'm going to do is I'm going to try and get Kiro to take this. I'm going to install the Figma power and try and have Kiro go and implement this. So let's actually go ahead and install the Figma power. All right, so that was installed, and if you want to take a look at what a power looks like, the power itself is just a markdown file with the power.md. Let me open the front matter because it's the markdown version, because it's easier to understand.

So this is what front matter looks like, right? And as you can see, we have keywords related to Figma like UI, design, code, layout that help the agent decipher when it should actually invoke this power. And with this power, there's like a workflow defined. You know, execute this file to generate the right context for Figma, and so it's going to create something called a system design rule and then also a hook which we can watch. And then with the power, there's an mcp.json. So this is the MCP configuration.

Figma has an MCP server, and so you can add one or more MCPs within a power, but working with Figma, they have one MCP. So now what I'm going to go ahead and do is I'm actually going to say try power and see what happens. So as you can see, it activated the Figma power and tells you what you can do with the Figma power. And the first thing it's doing is this thing called, it's saying it needs to create design system rules.

Now, what create design system rules is, is a tool in the MCP for Figma. But if you were to just download the Figma MCP and start working with it, it wouldn't automatically get invoked. In fact, there's documentation embedded in some Figma link which says like copy this prompt, paste it in, and generate this file. What this file does is actually gives the agent really good context on how to, it gives Figma and the agent really good context about what the specific project setup is, what the specific project has in terms of a design system.

So this should generate shortly. But it'll have things like what is the CSS styling, what are the design tokens, like what are the layout rules, colors, right? These are all things that Figma finds very useful, and the agent also finds very useful when it generates code. Now, so it created the steering file, and it's got the steering file with this inclusion mode as always. So what this means is now I have the steering file included right here. Every time the agent runs, it will use this file as context because Figma really thinks that this is an important file for the agent to have access to.

And second, it created something called, this is slightly more contextual to like an audience that's familiar with Figma, but it created a hook called Figma Component Code Connect. Now what that does is that Figma has this concept of components. In your UI, you have conceptual components, and you can really map the two together.

The way this hook runs is that on every file create, it will basically try and map the component to the Figma version of the component. So that's really what you can get with this power. Right out of the box, you get an onboarding experience that's fully guided, that isn't just telling you to go install an MCP server from the docs and figure out how to work with it. As a developer, there's nothing more important than staying in the flow.

All right, so it's saying, okay, great, my Figma power is now up and ready to use. And it's giving me some examples again, so this is all very useful because it gives you what's almost like documentation that you'd have to follow but without leaving your editor. Now, if I were to go to Figma, Figma has this feature called Dev mode right here, which allows me to select a component. And I can just copy this example prompt that says implement this design from Figma. And then I go in here and I'm going to just go ahead and paste that. And let's see what the agent does. Hopefully this works.

Yep, so it's trying to get this tool from Figma. I'm just going to go ahead and auto approve the tools so it will never ask me for permission again. Okay, great. Okay, so now it's connected to Figma. I fetched that frame and what you can see it says I've found this topic. Let me convert this design to match your project CSS approach. So it's taking the Figma context and it's got context because it includes that design context file at the beginning. It is going to say, oh wow, now I can understand what you've got in your project and what Figma has, and it's now going to go ahead and create a new enhanced topic card component. Let's see how it does.

So the interesting, the funny thing here is I've done this like two times before the demo and both times the results were slightly different and that is just the nature of working with AI systems right now. But they were close enough so I'm hoping this version is also going to be pretty good. So this is the other cool thing we've launched with Kiro in the last couple of months. When we first launched Kiro, the agent would have a lot more errors in the actual interface, and it required some back and forth to fix them. But we launched diagnostics tool support which actually can look at and find linting issues, linting errors, and we launched support for dev server so it can read compile time errors and the agent just auto recovers itself. So I was able to do most all my demos this re:Invent, this is my fourth session, without the agent really making mistakes which has been super cool. And now I'm going to jinx myself for sure.

While this is happening, let me just show you how easy it is to create a power. So I have this power that I've built. I really like it. So Chrome has a DevTools server that actually will run Chrome and be able to do things like click on components, test for responsiveness, check hover effects. It can do a lot. So I've set up this Chrome DevTools power and it's essentially got two files. It's got a power.md file with instructions for what to do and an mcp.json file. Now, for me to add this to Kiro, it's going to be super easy. I would just go into Kiro here and say add custom power, import a power from a folder. And there, now I have a Chrome DevTools UI testing power available to me as well.

Okay, so it implemented something. Let's see how it did. All right. Oh, not bad. It's pretty good.

Let's actually now go ahead and see if I can invoke the Chrome DevTools power. Now run Chrome DevTools to make sure everything is okay. Okay, so it's running a background power. Let's see if it works. Okay, great. Oh, did I have my MCP on? I cheated a little bit. I unfortunately had not disabled the actual MCP server, but that's fine. So what this is going to do now is that you see how it opened its own instance, and now check out what it's going to do. It's going to see that the dev server is running now. There's a new design rendering great. Let me check the console for any errors. So look at the runtime, look at the actual console runtime, see if there are errors. Okay, no errors. Now let me test the hover effects. So it's going to actually hover on the UI component. I believe the UI component has some hover states to see if the hover works. And now it's doing okay, how is this going to work on a mobile device? It's going to resize the page. Yeah, so I think you get the gist of it.

Harry Mauer on Postman Power: Streamlining API Development and Testing

So the powers really give you the ability, the agent ability like a toolkit abilities, a Swiss Army knife of abilities without overwhelming it with context. I kind of walked you through the Figma use case. I'm going to ask Harry to come on and talk about Postman. Awesome. Hi everybody. My name's Harry Mower. I'm the Field CTO of Postman, and in my role, I help our largest customers improve their overall software development process. How many of you are familiar with Postman? How many of you use Postman? Yeah, there you go. So for those that haven't, Postman is the most widely used tool to test and design and to manage your APIs. We're used by over 40 million developers. Over 500,000 organizations have adopted us, and we've become one of those indispensable tools in the developer toolkit, sort of like Git and VS Code, strong coffee, and noise canceling headphones, right? We're part of the tool chest that every developer typically uses.

For those that aren't familiar with me, I had a long history in developer tools. I spent a long time at Microsoft in Developer Tools. I ran Dev Tools for Red Hat for a long time. I actually worked on Dev Tools at AWS, and now I'm here at Postman, and I've never been more excited about software development. I feel like my entire twenty-plus year career has led to this point where my code is finally able to write my code, right? And it's just awesome how much you can get done in just a short amount of time with these tools. But for as powerful as they are, they still need a lot of guidance, right? So as Nikhil was saying, they're very much generalists, and they need a lot of guidance and knowledge to help them do the job in the way that you want them to do it, right?

So you've got to tell them what kind of framework to use and what kind of language to use, and importantly for Postman, which APIs you want to use to build in your application. And this is where we see Postman continuing to play an indispensable role, right? As I mentioned, millions of developers use Postman to collaborate and build their APIs and test them and manage them. And increasingly those developers are being joined by countless numbers of agents, right? So agents now are wanting to do the same thing that developers did. They want to test their APIs, they want to share the APIs, and they want to do that not only with other developers, but with other agents as well. And today we enable that through our Postman MCP server. So there's an MCP server out there today that you can use within whichever coding agent or assistant that supports MCP that you want to use, but there's some limitations to it, and this is why we're so excited to be partnering with the Kiro team, right?

You know, for instance, we want to provide a lot of capabilities to those MCP servers, so we have over 100 tools, but most of them really can't deal with that many tools, right? So we have a slimmed down version which only has 40 tools, which can also sometimes overwhelm them, right? So one of the things we're really excited about in here is the ability for that to automatically load after we install the MCP server, right?

And the other thing that we usually stumble upon is when someone goes to use our MCP server, we're relying on them to actually write the system prompts to make it more effective. Now with Kiro, we have these steering files, and we can package all this up into a power that makes our MCP server much more powerful for the agent to use. Rather than me talking about it, I want to give you a quick demo. I am not as fearless as Nikhil, so I recorded mine. Let's see if we can get the video going.

I've got a sample application, a personal finance application. It's interesting that me and Tyler both started working on the same thing. It's pretty robust and has a lot of the same things that you would expect to have in a large enterprise scale application. It's got a GraphQL API, an SDK, and a CLI. I use Postman to help manage all of the different versions and share those APIs with my team. In my pipelines, I automatically generate a collection and a spec for each version, and I do that as part of my pipeline process.

When I want to build an API that I can collaborate on, one that's still in development, I also want to create a collection and be able to share that with my other development teams. Through the new Kiro power, I can do that right inside my IDE. Here's a sample prompt I put together. I'm asking Kiro to create a collection based off an endpoint within my API for just reporting. One of the things that we tell in the steering file is we tell Kiro to keep a Postman.json file for all of the metadata about the workspace and the collection and the user information that we use, and we build upon that as we go because it's going to help some of our more advanced features like the hooks work later on.

As Kiro goes through the process here, it's going to use my API key to connect to Postman. It's going to read my code, understand the endpoints that I need to make, and then it automatically creates this collection inside of my workspace that now I can share with my team. It's got everything it needs here, and you should see that here. There's my new endpoint in development. This is pretty cool, but if someone went to go to use this, it wouldn't really work. It would tell them what the input was supposed to look like, but there's no real way to test this.

One of the cool features inside of Postman is the ability to create mock servers and environments for APIs that aren't quite finished yet. I can mock out this environment and share that with the team who needs it downstream while I'm continuing to develop the implementation. I can do that now directly inside Kiro instead of having to do that inside Postman. I don't ever have to leave my IDE.

In another prompt I asked, I tell Kiro to take that collection you just built, the one you just saved inside of that JSON file, and now let's build a mock environment and server for that so that we can test these directly, or we can test these without the implementation being completed. It's going to go through the process here of doing that. Again, as it does this, it keeps adding to that metadata, and the reason it can do that is because we told it to do that in the steering file. If I had to rely on the end user to do that, I couldn't rely on you all to do that. We automatically package that up for you to do that.

The mock server was automatically created, and again, the only thing I had to tell Kiro to do was look at my code. I didn't have to write a spec or do anything like that. I said investigate, look at my code, create this collection. Once you create the collection, now you know everything about that, go create this virtual environment inside of Postman, which has a mock server in it and all the environment variables that I need. Now I can actually go and test this and get test data back to be able to run that collection. As I said, this is really great because now I don't have to, the other team, if I'm a downstream team, I don't have to wait on me to finish it, and I can also just start to test that right here inside Kiro, so I want to make sure it works for the other team.

Now why this is cool and why I wanted to show this is that this is a standard test that we're going to run, not only just to validate the collection work and the mock environment worked, but it's also going to be called every time I make a change to the source code because I automatically packaged a Kiro hook inside of it. One of the things that you would do as you're developing your APIs is you want to go back and test it and make sure everything works. Now automatically when I change the source code and save it, Kiro knows that because there's a hook inside of there, and it's going to run that same collection in that mock environment that we created and make sure everything still works. Now we've got this closed loop system.

This is one small example. Like I said, we have over one hundred tools inside of our MCP server. You can do everything from creating collections and workspaces and sharing them and also generating other code. We're really interested and excited to see what you all are going to do with it. It's available today. You can go install it from the Kiro marketplace, and we also have a Discord server. We'd love to get your feedback, so if you could take the time to join, we'd love to hear it, and hopefully you'll get a lot of value out of it. Thank you. Tyler.

Tyler Schuckert Demonstrates Supabase Power: Building a Personal Banking App

Thanks, Harry. Hi everyone. I'm Tyler and I'm a Developer Relations Engineer at Supabase, and today I'm going to talk to you about Supabase and the Kiro power that we're launching. For those who don't know what Supabase is, Supabase is a backend platform loved by many developers across the world. We have 5 million developers shipping over 90,000 databases every single day, and we have shipped in total 16 million databases.

Earlier this year, we shipped our MCP server. The Supabase MCP server includes numerous tools for building applications on top of Supabase. You can do things like list out tables, manage your database migrations, manage your storage bucket, really anything that you can do within the Supabase platform. This MCP server forms the backbone of our Kiro power.

And I am happy to announce the Kiro power for Supabase. We are announcing two Kiro powers from Supabase, one to work with your local Supabase database and another to work with a hosted Supabase database, so that you can start locally and deploy your Supabase database to your cloud. It uses the Supabase MCP and the Supabase CLI to build, manage, debug, and scale applications with the help from an LLM.

Not just having access to these tools, but the Supabase Kiro powers understand the best practices of how to use Supabase and how to use a Postgres database. So you don't have to be a database expert in order to get building on a Postgres database. Now let's see it in action.

So I'm going to start with a plain Vite app. I'm going to go ahead and install the Supabase local Kiro power. I'm going to hit install and hit try power, and off we go. We're going to start up with the onboarding flow, and it's going to check things like whether I have Docker running, whether I have the Supabase CLI installed, and whether I have initialized the Supabase project within the working directory.

Now, I hadn't initialized Supabase in here, so it went ahead and initialized Supabase for me. And then now it's fetching the Supabase credentials and creating an environment variable environment file for me within this project directory. Now, once all the initial setup is done, we are going to jump into building some tables.

So, I'm also going to work on a personal finance, personal banking app. So I'm telling Kiro here to create all the tables that you need in order to build a personal banking app. And Kiro is able to understand all the best practices to build tables, best security practices when it comes to Supabase, and incorporate all that in here. So it has created the tables, it has created all the necessary security safeguards to make sure we create a nice and safe banking app.

One of the key powers that we're shipping is this security check. It's part of a Supabase core feature, and what it allows you to do is take in all the best security practices and make sure all the tables and various configurations are following those security best practices. I'm going to go ahead and run it, and it actually found some problems. So Kiro was able to quickly fix that up by running another SQL segment.

Now, another favorite thing about Supabase, another favorite thing of mine about Supabase, is that it can generate TypeScript types that match your table schema. And Kiro is doing that for me without me having to tell it to generate all these TypeScript types. It's able to understand that we're working in a TypeScript environment and Supabase has this TypeScript generation feature, and we should probably generate some TypeScript types. And there you go. Here it has created the TypeScript types and now installing the Supabase JavaScript client library.

So generating all these TypeScript types, installing the Supabase client libraries, these are standard practices that we follow. And it was able to do that without me having to interfere with any of the prompts. It understands all these best practices that it needs to do in order to get started with a Supabase project. Now, finally, once all the tables are created, all the configuration is set, Kiro is generating all the database migrations. And after a while, let's check out the migration file that it created.

So you can see, Kiro has created a nice accounts table for us with all the columns that you would need for a personal banking app, like user ID, account type, balance, currencies. It also generated other tables too, like budgets, categories, transactions, all the tables that you would expect in a personal banking app. And then you can view that within the Supabase dashboard. You can see the transactions table, budgets table, all being associated to the auth user ID table. So it has taken all the best practices that Supabase offers and put it all together.

Now let's come back to Kiro and keep going. So it's now generating some front-end code to connect to our Supabase database. This is a TypeScript type that I mentioned earlier, and as you can see, we have all the matching TypeScript types that match the table schema. Now, let's go ahead and create a new chat session and work on the UI.

So the prompt here that I'm giving it is basically saying, hey, I have these tables in my Supabase project, please create a UI that matches what I have in the tables. This is one of the neat tricks that I like to use when building apps using Supabase and large language models. I like to start from the tables, and then once I'm done with the tables, I have it generate the UI because having a nice airtight table structure is very important. And once all the tables are in place, large language models are generally really good at understanding what's going on and figuring out the best UI that goes with those tables.

So Kiro is analyzing all the schema that we generated, and it's generating all this UI code to display what we saw in the database on the front-end code.

And just like that, we have some nice set of prototype code. Let's run the local dev server and check it out. So the UI looks good, it looks like a personal banking app, but we don't see any data, right? Well, that's because we just created the tables, but we haven't inserted any data into it. Obviously.

So let's go back and ask Kiro to add some dummy data into the database. And Kiro, again, is able to figure out how to insert dummy data into Supabase, what the best practice is. And it's running some SQL command to insert some dummy data into all the tables that we created earlier. And after inserting all these data in four different tables, it double checks that all the data has been inserted. And then I've asked it to create a local seed file to keep all these dummy data persisted within this project. Looks great.

Let's go ahead and check it out. Now, within the Supabase table, we had those dummy data, but it looked like we haven't signed into the app yet. So I'm asking Kiro to add authentication to the app. And Kiro is able to figure out the structure of the Supabase project, the fact that obviously the passwords are encrypted, so you wouldn't be able to insert just 123456 into the passwords column. You need to properly encrypt or hash the passwords. It's able to figure out how Supabase does it. And able to do that.

It's able to self-correct it. So on the first shot, we missed it, but I've gone ahead and asked it to make some fixes. And it's on its own, was able to figure out that, okay, the Supabase local dev server needs to relaunch. So without me telling it, it was stopping the Supabase dev server, relaunching it, loading in all the seed data that we created again, and resetting the scene so that the proper authenticated user is created within the database.

And so far, I have done minimal steering. It's all the Kiro's steering file that's doing all the heavy lifting. And with some edits from Kiro, we are able to sign into the app, and as you can see, you can view all the dummy data that Kiro created in this nicely authenticated, proper personal banking app. So that was Kiro Power from Supabase. Again, we have the local version and hosted version. And I hope you liked what you saw, and I cannot wait to see what you build with it. Thank you so much.

What's Next for Kiro Powers: CLI Availability, Governance, and Automatic Discovery

Thank you again Harry and Tyler. That was really great. We really appreciate both of you coming here and talking about the powers and both powers are super useful. I've been using both of them for my own application development, so I've really benefited from actually learning a lot about Postman and Supabase over this last month. Cool.

So what's next? There's a lot of questions. I think availability in the CLI we want to actually make, we have a Kiro CLI if you don't know. We also want to make it available more broadly. More use cases, more partners, we have on our website we have a way for you to submit a form and actually send us powers, and we're reviewing them weekly and if we find interesting ones we can curate them. You can do it as an individual as well, by the way. It doesn't have to be your organization. If you have a specific use case that you want to highlight and it meets our bar for adding it on, we're happy to do it.

Organizational use cases are going to be a big one. So being able to govern like powers around what powers teams can install is going to be another feature that we add, and I think our goal here is really for Kiro. The Kiro agent has powers, and over time, a Kiro agent should be able to discover powers and say, hey, you're trying to do this. I know there's a power to do to solve this problem without the user actually having to explicitly go and say anything.

Yeah, so as we said, you can go ahead and start using it right away on Kiro, and thank you so much again everyone for taking your time. I appreciate everyone joining at four p.m., and I'm happy to take questions if you have questions. Happy to kind of if you come up and we can take questions. Thanks again.

---

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