🦄 Making great presentations more accessible. This project aims to enhances multilingual accessibility and discoverability while maintaining the integrity of original content. Detailed transcriptions and keyframes preserve the nuances and technical insights that make each session compelling.

Overview

📖 AWS re:Invent 2025 - Crowning the Kiro code champions (DVT221)

In this video, Brian Beach celebrates the winners of Kiro’s Labyrinth coding challenge while introducing Kiro’s spec-driven development approach. He explains how Kiro evolved from CodeWhisperer’s autocomplete to an agentic IDE, emphasizing spec-driven development over vibe coding. The challenge required participants to build a Python navigator to escape text-based mazes using depth-first search algorithms, with Kiro generating requirements, technical designs, and tasks before coding. Paul won first place with 1,314 turns, followed by Robin (1,450 turns) and Thanh (1,484 turns). Beach demonstrates how Kiro built the entire challenge application through its specification-driven workflow.

; 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 and Spec-Driven Development: From Autocomplete to Agentic AI

All right, hello. Hi, my name is Brian Beach. Welcome to Crowning the Kiro Code Champions. I’m the tech lead for our Developer Experience team, and I focus on all of the developer products at Amazon. That would include things like CI/CD, our CDK, CloudFormation, and of course I’m spending a lot of my time now on Kiro and the other agent-related services for developers.

So in this session, what I want to do—we only have 20 minutes, it’s really fast—we are here primarily to celebrate the winners of the Kiro’s Labyrinth coding challenge that we’ve been running throughout the week. But I’m going to start with just a quick introduction to Kiro, talk about what Kiro is, and focus in on spec-driven development because that was the focus of the coding challenge that we’ve been running throughout the week. So once I get done with that, I’ll talk a little bit about what the coding challenge was and walk you through an example to give you a sense of what the participants in this were doing. And then finally we will crown the winner, or actually the top three winners, and we have prizes for the top three winners that I’ll be handing out. I know at least two of them are here, so excellent, and we can take a moment to celebrate them and applaud a little when the time comes.

With that, let’s jump in, and again, I’m going to start with just a really brief introduction to Kiro. I won’t spend a lot of time on this, but I do want to talk a little bit about Kiro and what it is. I assume everyone is aware of Kiro. There’s been a lot of focus on it here. It’s been mentioned in many of the keynotes. Hopefully everyone’s had a chance to go through the haunted house up at the Venetian. If you haven’t, make time. It’s a blast. It’s really cool in there. Definitely worth the wait. There’s a bit of a line, but it’s worth the wait to get in there.

So with that, let’s talk about what Kiro is. I’m going to rewind a little bit. I’ve been part of this team for many years, and if we rewind back to 2023, I was here at re:Invent talking about, at the time, CodeWhisperer. And in those days it was all about autocomplete, right? We would start typing and it would automatically finish the line that I was working on or maybe predict the next couple of lines of code. And a couple of years ago that was cool. That seemed really neat that it was able to do that.

We came a long way though, and last year again I was here and now we were talking more about assistance and we were moving into a chat modality. We were able to have a conversation with the agent and talk about architecture decisions, ask it questions. We were able to get a lot more value out of the tool than just a simple autocomplete. And now of course, 2025, the year has been all about agents, right, and there’s a lot of mention of agents during this conference, and that’s really a game changer. It allows the tool not just to give you a response, but the agent can now go out and use tools. It can do things like go and read additional documentation when it needs more information. It can connect to your database and get the schema so that it can write an accurate query. It can run unit tests and get code coverage and know what unit tests to write and make much more informed decisions than we were able to do in the past.

So with those, if you could bring all of that capability in, what would the development experience look like that took full advantage of agentic AI? And that’s what Kiro is, right, the IDE for prototype to production. So I’m not going to go into all the features of Kiro today, but I do want to take a moment and talk a little bit about spec-driven development, because this was the focus of the coding challenge.

Let’s talk, to set the stage for this, let’s talk a little bit about the challenges that we face today with these tools. Most of it comes down to, I think everyone’s aware of and familiar with the concept of vibe coding, right? This is, I go into the tool, I give it a prompt, and it goes and starts writing code. Generally I’m giving it a pretty poor prompt. Despite all of the sessions on prompt engineering that are going on, we’re still pretty terrible at writing good prompts. And so Kiro recognizes that and focuses on helping you build out a specification so that we don’t have the quality problems that we’re going to have when we’re vibe coding. And that comes from giving it a really small prompt and letting the tool, or forcing the tool, to have to extrapolate and make a lot of assumptions about what you want to do. And when you’re doing that in vibe coding, we’re generating a lot of code that we then have to go and fix, which means we’re accumulating technical debt as we’re working.

What we’re doing with spec-driven development is we’re expanding the scope that the agent is involved in. In vibe coding, it’s all about using the tool, right, to focus on writing code, to do the implementation. What we really want to do with spec-driven development is broaden that and focus specifically on the planning and design phase, when we’re writing requirements and working on our technical design. Bring the agent into that and work out a lot of those unknowns

before we start writing code and before we start accumulating technical debt. Spec-driven development has been something that we’ve been talking about for a while. Kiro makes this part of the product, and so when you start Kiro up, you make the decision, do I want to go into vibe coding mode and just start coding, or do I want to go into spec-driven mode and work on my requirements and design. And when you’re using it, when you’re doing spec-driven development, we work through a series of phases to build out that specification.

So the first step is we build out the requirements. And this is represented as a series of user stories and the success criteria for those user stories, just like we used to do when we had a lot more discipline before these tools came along and we would plan things out. Once we have the requirements, and we iterate on those a little bit, and we have that locked, we’ll move into the technical design. We’ll move beyond just the business requirements for the application, and we’ll next focus on the technical design. What is the architecture going to look like? What languages and libraries are we going to use as part of this implementation? And we’ll iterate on that a little bit and get that to be really clear and well defined.

And when we’re done with that, we’ll next go and build out the list of tasks. How are we going to approach the project? What’s the sequence and order of things that we need to do to accomplish this? And then when we get all of that done, then it’s time to write code, so that we’ve figured out and eliminated all of the uncertainty that is in that short prompt that we started with. We get all of that documented, we have a lot of clarity about what we’re going to build, and then we ask Kiro to go write the code, and we get much better outcomes as a result of doing that.

Kiro’s Labyrinth Coding Challenge: Navigating Mazes with Depth-First Search

So with that quick introduction, let’s talk a little bit about Kiro’s Labyrinth and then connect the dots between the coding challenge and how that is related to spec-driven development. So if you’ve been by the kiosk up in the Venetian, you probably saw this picture and went to the site, and we have been running this challenge throughout the week. There’s been a leaderboard up. This is not the actual leaderboard. I had to submit this deck months ago, so this is just kind of a representation of what it looks like. We’ll talk about the real challenge in a minute.

And if you registered and signed up, you would download a package. You’d get a little bit of code to get you going, and you’d start working on building a navigator to escape a maze. And the maze looked like this. You get a couple mazes as part of the sample package. In this maze, S represents your starting position. The mazes are simply just text so that we can generate more. It’s really easy to generate more test cases. But the start is represented by the S at the top, and you’re trying to find the E, the exit at the bottom. X’s represent walls that are impassable, and the hash sign there is mud. You get stuck in the mud for a little bit. So your goal is to write a Python application that can navigate through this maze and get from the start to the exit and find its way out. Of course you don’t know what the maze looks like that you’re actually going to be working in.

And you do this by writing a navigator class in Python, and this is a really simple interface. You are presented in a series of turns, and you’re asked what do you want to do in this turn. That’s the next action. What I wanted to represent with this is kind of those early text-based games like Zork, Colossal Cave, or what was the other big one, I can’t remember the name of it. I remember when I first started, when I got my first computer, I had an Apple II. And it was the monochrome screen before graphics, and the statement would come up and it would say, you find yourself, you know, you awake in a field and to the east and west are walls, and to the south is this muddy bog and there’s a trail to the north, what do you want to do? So it’s kind of trying to embody that in this challenge.

And so you decide in each turn what you want to do on the next action. You can move north, south, east or west, or you can look around and discover what’s around you. If you do a move, you’ll get back a response that says it was either successful, you’re stuck in the mud, you found the exit or you’re blocked by a wall and weren’t able to move. If you do a look action, you get back a dictionary that tells you what is north, south, east, and west of you, so you can start to learn more about your environment. And using that very simple interface, the challenge is to write a Python application to go and solve this. And it comes with a simple CLI so that you can put in your navigator and test it with different mazes and see what happens and watch the sequence of events as you try to escape.

We ran this in two rounds. We ran the qualifying round where users wrote their navigator and just submitted them, and we would execute them in a secure sandbox in AWS, and that’s what was driving the leaderboard. And then as of yesterday we went through in the final round and evaluated the specifications behind the scenes and even used them to rebuild the app. So let me walk you through an example and kind of connect the dots between the challenge and what I talked about with Kiro, so you understand what the participants were doing.

I started here with a prompt. This was an example that I built out, and I started with my prompt and said, hey, I want to build a simple Python application to solve a maze. Please review the current file. The current file here was just the readme file that came with the project that I had open in my IDE. That was enough, right? I didn’t have to go and explain all of the details that I just explained to you. Kiro was able to just read the readme file and say, okay, now I understand the scope of this. I said I want to do a depth-first search algorithm. If you’re not familiar with that, that’s a basic thing that you would learn probably in a computer science class in the first year or two, a basic algorithm for searching through an unknown data set.

We need, of course, to keep the maze. We want to remember where we’ve been so that we don’t end up getting lost and doing loops or something in the maze. I want to remind it that, hey, we don’t have access to the internet during the evaluation. We’re running in a secure sandbox, so you can’t bring other libraries in. You have to be really clean about doing this just in pure Python.

So Kiro takes that simple prompt and it writes a series of requirements, a series of user stories here. This is one of about six to twelve that you would get depending on the scenario here with this. You can see here it says, right, I want the navigator to build an internal map of the maze. This requirement is about managing the internal map, the view of the world, and then there’s a series of acceptance criteria. We need to start by initializing an empty set. You can see here that I’m really establishing exactly what I expect of the tool. I’m not just jumping in and giving it a two-sentence description, but I’m building out a really clear description of what we’re trying to implement.

Once this is done, we’ll next move to the technical design. Here’s where we move from just the concept to starting to look at how are we going to implement this. This again is about the maze exploration and the map and talks about the algorithm. We get into a lot more details, and now it’s starting to talk about exactly how are we going to implement this. The first thing we’re going to do is look around if we don’t know what’s around us. If we see an exit, let’s go there. Obviously that should be the next step. Then let’s talk about the exploration. What are we going to do? You can see there the order of preference. We’re going to first try to move north, then if we can’t, we’ll move east. If we can’t do that, we’ll move south. If we get stuck, we’ll backtrack and we’ll move backwards through the maze.

Then finally it creates a series of tasks, and this is just one of those tasks. This is the third task in the series, and this is it building out the map building section again. Then specifically the on_look_result and how it builds the map from what it sees as it’s looking around.

So taking that and putting it all together, let’s look at an example of what this looks like. This is Kiro finding his way through the maze. This is not me doing it. This is a Python application finding its way. You see it tried to go north and it couldn’t, so it started going east. When it couldn’t do that anymore, it started going south, following that algorithm that I was just showing you in the design. I’ll speed this up a little bit. You see him start to move. You can see over on the right he’s doing a look and a move and a look and a move and a look and a move, and you can see the sequence. Then he gets to the end and he backtracks. There was probably an optimization that I could have done there. There’s no need to backtrack here. There were no known branches, so this was an opportunity that I could have written a better algorithm. You can also see on the return that I’m continuing to look. That’s kind of wasteful. That’s another thing that a better algorithm would have probably eliminated and had better success. He gets stuck in the mud here for a little bit and finds the exit after exploring only about half the maze. So overall this went pretty well. He did a good job on this one.

Crowning the Champions: Paul, Robin, and Thanh Take Top Honors

Okay, so let’s just give you an idea of what the participants were doing over the week trying to solve this. And so with that, let’s start to look at the winners. To do that, I didn’t know who the winners were when I created this deck, so I got to jump over to my own machine here with some a little bit later information.

For those winners there, there are three. I’ll show you what the package comes with. We got a nice Kiro bag with some cool swag. It comes with a hat, and then there’s a Kiro branded keyboard that has some cool Kiro logo and Kiro specific keys on it as part of the prize package. I have this for each of the three winners. So I’m going to list them. I’ll show you who the winners are and then specifically how they performed. Note that this maze is much larger, so these numbers are a lot bigger than the numbers we were seeing in the earlier very simple mazes. The maze that they competed in was much, much larger, and I’ll show you the ultimate winner in the end.

So first, Thanh came in at 1,484 turns to escape from the large maze in the complete environment. So you’re here, right? Yep. So great job. That’s third place.

And then very close behind, we have Robin at 1,450 turns, so pretty close right there between third and second place. Is Robin here? I wasn’t sure if he was going to make it. Okay, I’ll track him down at some point and make sure he gets his prize.

And then ultimately we have Paul, who came in as our first place winner, a little bit better than 100 turns fewer at 1,314 turns, so great job. He’s here. Excellent. And just to wrap this up, I do have a really quick sped up video. This is much bigger, so I sped it up quite a bit, but I have the video of yours. And of course you didn’t have the video, right? I didn’t give the video tool to everybody because they don’t know what the maze looks like, so they didn’t have that option, but I do have the video.

Of his running through this much larger maze, way sped up, so you can see him. He’s actually cranking through these first sections of it, making good progress, got stuck in the mud there. He could have gone around that. And then he cranks pretty quickly up to about halfway through, gets stuck here for a little while, really trying to find his way out of this section of the maze. This confused him a little bit. And then he makes really good time here. Gets stuck up for a little bit, goes into this big open field, and does a pretty good job of navigating through that and cranking through the mud there, and then ultimately finds the exit after 1,300 moves. So great job. Awesome.

All right, and with that, I’m going to wrap it here, but I will say there’s a lot of other opportunities to learn more about Kiro. So if you haven’t been to the house, the haunted house, the House of Kiro in the Venetian, that’s in the lobby of the Venetian. It’s awesome. Go check it out. It’s definitely worth the wait there, and that’s running through tomorrow. Then the kiosk is open in the AWS Village in the Expo Center, and that’s where we’re running the challenge. The challenge, of course, is closed now, but you can still go and ask questions there. That’s open through 4 o’clock today.

And we’re kind of coming to the end of this conference, so a lot of stuff is wrapping up. And then right here in the loft, which is over in this corner, we have people there today at noon, which is like now, immediately after this. So if you’re interested, come on over, and if any of the winners are interested and want to come over, we’re going to focus on, you know, check out what I built with Kiro. So if you want to come and show off what you built with Kiro, this would be a good opportunity to go.

I’m going to go and, if there’s time, I’m going to show off how we built the Kiro’s Challenge, because of course Kiro built all of this. I didn’t write any of this code for this challenge. Kiro built the whole thing, okay. And also we have people over at the whiteboard at 4:30. If you have questions about Kiro, you can come and we’re doing a live whiteboard session again over in the loft today. And with that, thank you very much, and congratulations again to the winners.

---

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