iTranslated by AI

The content below is an AI-generated translation. This is an experimental feature, and may contain errors. View original article
📖

re:Invent 2025: Streamlining Terraform Provider Development with Kiro and Agentic AI Use Cases

に公開
2025/12/10

Introduction

By transcribing various overseas lectures into Japanese articles, we make high-quality, hidden knowledge more accessible. This project takes on the following presentation!

Please check the Spreadsheet for information on re:Invent 2025 transcription articles.

📖re:Invent 2025: AWS re:Invent 2025 - Accelerate Terraform Provider development workflows with Kiro (DVT216)

In this video, Paul Stafford from AWS and Paul Thrasher from HashiCorp explain how Agentic AI is transforming the entire software development lifecycle (SDLC). Managing the AWS Terraform provider with over 3,000 open issues and 518 PRs, HashiCorp utilized Kiro to reduce resource development time by 90%, building over 600 Terraform resources and 500 actions. With Q Developer CLI and agentic chat, agents can now be utilized across all phases of the SDLC (analysis, planning, design, implementation, testing) outside of the IDE, benefiting not just developers but also Ops engineers and BAs. The session also introduces integration cases for Terraform workflows via MCP servers, demonstrating the feasibility of an "organic transformation" through human-agent collaboration.

https://www.youtube.com/watch?v=jEJrOMU5nQU
Note: This article is automatically generated while maintaining the content of the existing lecture as much as possible. Please be aware that there may be typos or incorrect content.

Main Content

Thumbnail 0

Opening of the Final Day of re:Invent 2025 and Speaker Introduction

Hello everyone. Thank you for your time today, and welcome to DVT 216. We are very happy to have you here with us this morning. Thank you very much for coming to re:Invent. Thank you for spending this final hour, the last chime of re:Invent 2025, with us. We did it, we made it through. Well done team. I hope you all had a truly wonderful week. I hope you had the opportunity to make new friends and reunite with old ones. If you learned something new and felt a little inspired, I would be happy. Because that is what re:Invent feels like to me. So thank you for being here. Thank you for spending the week with us.

Well, today is Friday, and I don't think you need to spend any more brain cycles on anything taxing, so we decided that only the Pauls would conduct today's session. That way, you can go home with a little more of today's session content in your heads and won't have to remember anything extra. So once again, thank you for your time. My name is Paul Stafford. I am part of the worldwide team that supports the growth and success of our customers with Kiro and Q Developer. I have been at AWS for 6 years and am based in Melbourne, Australia.

Before that, I was a product director, solutions architect, business development manager, and developer. Actually, I consider myself primarily a recovering developer. I started my career building Java integrations between carrier-grade voice systems long ago. If there is anyone in the audience from the telecommunications industry who wants to reminisce about scars and the good old days, please come say hi later. I love talking about that stuff. And I am also happy to introduce Paul Thrasher. He is the far better Paul, the Paul with the definitely cooler last name, and he kindly agreed to stand on stage with me today.

Thanks, Paul. So I am Paul Thrasher. I'm at IBM, HashiCorp, and now at IBM as a Project Director for Agentic Fabric, where we are doing AI projects within the HashiCorp board. I started long ago with a Bachelor of Fine Arts in Design. I've been a programmer for over 16 years. I started with PHP, but then moved on to Python, Node.js, Go, and Swift. I particularly like Swift these days. I've been at HashiCorp for a little over eight and a half years and moved into product management about three years ago.

Since then, I've become the Product Director for the Terraform ecosystem. I managed providers at first, but also did partner integrations and now handle AI for all of HashiCorp. So I've had a lot of experience in various areas, but at this point, I think I just love building things. That's why I'm standing here on stage making something. Fantastic. That's great. Thank you, Paul. Appreciate it.

Thumbnail 180

The Evolution of Agents and Human-Agent Partnerships

So, instead of showing you the very structured agenda slide that you've likely seen enough of this week, I thought it would be a good idea to give you an overview of what you will hear and see over the next 60 minutes, and then dive into the details of the topics. This way, I can effectively convey both the theme and the details of what we will talk about in this breakout session. Perhaps this is the understatement of the week, but let me say that agents are undergoing a massive transformation. What were once auxiliary tools have now become highly sophisticated, autonomous entities. And at the core of that is what you will hear about today. You will hear a story of change.

I will talk about how agents and their use cases have changed. I will talk about how the SDLC is in the middle of change and in the process of change. I will talk about how services like Kiro have changed, but most importantly, we will also focus on the changes HashiCorp experienced using agentic AI within the SDLC to solve one of their most pressing challenges. The important thing is that you will also see the practical reality of how the human-agent partnership is actually working. And it is a partnership where the agent has become an active collaborator with us and with developers in the development process.

Thumbnail 260

So, in creating this session, Paul and I wanted to ensure that every topic over the next 60 minutes was structured in a very easy-to-follow how and what format. Based on a rough calculation of time and slides, the next 60 minutes will be broken down like this. As you can see, we plan to spend more time on the "how" slides and the "how" details. And naturally, this is a level 200 session. So, we will cover the evolution of agents, human-agent partnerships, and delve into Agentic AI throughout the SDLC. We will also perform a few demos. Of course, we will talk about HashiCorp's challenges, then discuss tooling, and MCP will be one of those elements as well.

So, if we do our job correctly, we hope you will think about not just the technical changes, but also the paradigm shift that people are experiencing as they approach software development through the latter half of 2025 and into next year.

For the next 20 minutes or so, please spend time with me, and we will look at those concepts of modern evolution. We will talk about patterns, use cases, and adoption. And after that, Paul will take the stage for the good part.

Thumbnail 340

Paul will describe some demos he recorded. And he will talk about how this is actually functioning for HashiCorp and the benefits they have brought to their customers and their own partner ecosystem. But if there is one thing you take away today, and one thing you remember in the coming weeks, Paul and I want you to remember this quote from the session: Yes, AI agents can create and achieve amazing things. But it is humans who provide the contextual wisdom, the tool wisdom, and the strategies that prevent agents from guessing in the dark.

Thumbnail 360

Now, I will return to this quote later in the slide deck. After we gather a few more details throughout the session, we will break it down further. What are AI agents? They are autonomous or semi-autonomous software systems that can reason, plan, and act to achieve goals in a digital environment. You may have seen this definition floating around the internet over the last few days. And while I understand the intention, I am not a big fan of this definition.

Thumbnail 380

I think of agents as systems to which you grant agency to complete tasks according to the independence, tools, and context you have assigned. These days, Agentic AI is context-aware, proactive in its actions, and can maintain continuity throughout tasks. And when you strip away everything else, these are the three concepts that enable us, as humans and as developers, to effectively partner with the agents themselves. And this is clearly for the purpose and intent of having an intelligent collaborator in software development activities.

Thumbnail 420

Generative AI's Three-Layer Stack and the Expansion of Agentic AI Across the SDLC

So, I thought it was worth putting a few definition points on the table at the initial stage, because there is some ambiguity in the terminology surrounding Gen AI, Agentic AI, and everything in between. At AWS, we think of generative AI as this three-layer stack. You have likely seen this during the week, or previously. At the bottom, there are the services and infrastructure services that customers use to build and train their own models. In the middle, there is Amazon Bedrock, which is used to create generative AI applications. And at the top, there are agent-based managed AI services like Kiro and Q Developer.

At AWS, we think of Agentic AI as being about task management, especially toil-based tasks. And over the next 15 minutes or so, I will be saying the word "toil" many times. This means granting large language models the agency to complete things on your behalf. Because, ultimately, having an agent to which you can assign activities is a powerful concept of productivity and efficiency. And part of the reason for that productivity and efficiency lies in simplicity.

Thumbnail 480

This is because agents are actually composed of only four key components: Memory, where the LLM resides; Tools, which relates to integration features (MCP exists here—this is a slight teaser of what Paul will talk about in an hour or so); Planning, which covers self-management, workflows, and individual datasets; and of course, Outcome, the actual task given to the agent itself.

Thumbnail 510

Thumbnail 520

One of the main reasons agents are becoming increasingly compelling is generational advancement. It is the technology and integration behind these concepts, and all the technological progress. And I promised Paul I wouldn't mow his lawn too much on this slide. Sorry, Paul. But it would be a shame not to mention that HashiCorp is contributing significantly to the tool and planning elements of Agentic AI through the technology and services they have created.

Thumbnail 540

Thumbnail 560

Before moving on, let me provide one more definition. We are seeing customers generating value with Agentic AI in two main categories: accelerating software development and re-architecting workflows across the business. The former is about using AWS's pre-built agentic services, while the latter involves providing tools to build unique agentic solutions. Today, we will focus only on the former—accelerating software development.

Thumbnail 570

Now, when Agentic Services first appeared, they were almost entirely coding companions. They helped developers realize ideas like code completion and automated suggestions. This was a fairly divisive topic for many developers. The early playground for Agentic AI was phase 3 of the SDLC. This concerned what developers do through their IDEs as part of design activities and related processes.

In the early days of Agentic AI—which was only about two years ago—the benefits of agentic AI were hidden behind conditions like being a developer, having an IDE, and working in phase 3 of the SDLC. Finding ways to expand the value of agentic concepts beyond these conditions was indeed one of the driving forces behind the direction Q Developer has taken over the past 12 months. This is particularly to better reflect the full SDLC and all the personas involved in it. Customers began our discussions with a primary question: "Where are people spending their time in the SDLC?" Because it is not just about code creation.

Thumbnail 650

In our discussions, we realized something. If modern development involves more than just the act of development, how can we deliver the value of agents to all areas of the SDLC where people are working? Or, to put it more poetically as written on the slide, how can we broaden the reach of the value of agentic AI? Excellent application design is the output of multiple personas spanning all six phases of the SDLC, from scope and standards to documentation, modernization, and measurement. As a small note, the pink text does not represent random SDLC terms. These are areas and actions where Q Developer, through CLI or IDE modalities, can impact SDLC tasks and toil, and effectively collaborate with the people working in those phases.

Thumbnail 690

Thumbnail 710

Thumbnail 720

Practical Demo of Organic Transformation with Q Developer CLI

Our view on this was that we needed to democratize the value of agentic AI in tasks and toil, making it more accessible to non-developers and those not working in phase 3 of the SDLC, even outside of the IDE. So, earlier this year, we released two features to advance this concept: a command-line interface, meaning the IDE is no longer required, and agentic chat. This opened the door to conversational, natural language interaction without the need to manage context between individual specific agents. It was truly fascinating to see the use cases that emerged and were discovered as a result of this.

Thumbnail 750

One of my favorites is what we are starting to call "organic transformation" internally. This avoids the need to cross half of the SDLC through processes or phases, where modernization targets are identified by operations from stage 6 of the SDLC and are then agentically analyzed, planned, designed, and implemented. Now, it is time for some fun. I will show you how to actually achieve or execute something like organic transformation using the Q Developer CLI, and what that might potentially look like.

Thumbnail 780

Thumbnail 800

In this scenario, I am an operations engineer at a fictional company. I received a ticket stating that the payment processing system is struggling. You can see some details there: CPU utilization is currently at 25 percent and is underutilized, and it takes 4.22 hours to execute 50,000 transactions. There is a business impact; it should ideally be completed within an hour. Now, in this scenario, I should point out that I queried a very simple Java application using the Q Developer CLI, which we created to reflect the process of organic transformation within the time we have.

Those with a sharp eye may have spotted some of the terrible things I put into this application, such as hardcoded database credentials and artificial timers. This is like a list of terrible things you should never do to an innocent application. It is a simple application, but it is a truly worst-case example of a modernization target that many companies might have, harboring performance and security issues.

Thumbnail 860

Thumbnail 870

As a competent Ops engineer, I understand the need to quickly switch into analytical thinking mode to identify what is happening with this application. So, I open the command prompt and type Q Developer CLI to immediately enter the interface. From there, I can interact in a very user-friendly conversational format. As you can see, my first prompt says, "Analyze the payment processor Java file of the legacy payment system." Now, there are many reasons why this is not a good prompt. In fact, it is a terrible prompt. The main reasons involve ambiguity and a lack of purpose, but this is intentional at this point. Because I want to see how we can build this in a way that generates continuously improving hygiene.

Nevertheless, within a few seconds, Q Developer returned a response. You can see the detailed information categorized by security. It has clearly detected hardcoded credentials. It also found SQL injection vulnerabilities. From a performance perspective, it points out that connection pooling is not being performed and that there is a lot of synchronous processing. There are also leaks. Architecturally, transaction management is missing, and there is no error handling at all.

It is quite a nightmarish situation. But the important thing is that it is starting to identify risks, scope, actions to take, and further priorities that should be considered. Yes, Qiro is telling me there are performance issues, but perhaps more importantly, it is saying that there are several serious security concerns, which in a very direct way, says that is the actual priority to look at. And as a competent Ops engineer, now is the time to leverage the power of iterative conversation with the service to dig deeper into the actual analysis.

Thumbnail 940

Thumbnail 960

Thumbnail 970

Since there is a pom file, it means there are integrations. So, I say, "Review the pom file, identify old dependencies with security vulnerabilities, and propose modern alternatives." Great. My prompt is evolving and becoming a bit more specific in the conversation. As a result, specific information is being returned. This is good. I have started building context and gaining momentum. You can see that CVEs are beginning to surface. Modern alternatives and frameworks are being proposed, and this is all good because these are things that will reduce the actions I will have to take in the not-too-distant future.

Thumbnail 980

Thumbnail 1030

So, let us quickly look back at what we have done to our SDLC in this very short interaction. We have achieved this by turning some of the toil in our daily environment into agentic actions. Analyzing new features, creating new functionality, security updates, codebase and architectural fixes—these usually begin in Phase 1 with BAs, technical BAs, project managers, and architects working together. And they usually ensure they perform some of the toil-based actions detailed in our example, such as scoping, usage analysis, and identifying risks. However, by turning this into an agentic action, we move these tasks to an agent and work iteratively with that agent to complete the task. This allows technical BAs and architects to focus on higher-value concepts, such as analyzing and promoting technical solutions or identifying technical aspects of business solutions. By shifting toil to agents, we are increasing the efficiency of Stage 1. And as we begin to transition into Phase 2, we are gaining momentum.

Thumbnail 1050

Streamlining Planning, Design, and Implementation Phases with Agentic Chat

Now that I am satisfied with the service analysis, I move on to the planning and design phases. As you can see, I am asking what the three immediate improvements are that would have the greatest impact on the payment processing system. I am focusing on quick wins. Now, based on the wording I used in the prompt, Kiro is beginning to understand that I am moving forward and am looking for details more relevant to planning and design work. Therefore, specific content, such as "replace this with this," begins to appear in the responses. Kiro is now using the context awareness we have built and developed to dig into specific tactics. This is a classic example of a toil-based task that an agent can handle.

Thumbnail 1090

And in the output, it digs deeper, touching on vulnerabilities, DB transaction management, and the memory and resource leaks I mentioned earlier. However, here we also begin to see output regarding expected outcomes and implementation plans. And if this were a real-world situation, I would go back and forth with Kiro to nail down very specific details, such as "help me create a risk management plan," "help me create an ROI estimate," or "help me create key assets." "Help me design this as a cloud service," and so on. And in a form very similar to what we saw in the analysis, by using agentic chat, I am shifting additional tasks to an agent and working iteratively with that agent to complete those actions.

Thumbnail 1120

Planning and design is one of the areas in the SDLC with deep potential for efficiency through agentic collaboration. The main reason is that BAs, project managers, developers, and architects work closely together to establish the foundation of the project and the fundamental information about what we are actually doing. And this can be a very labor-intensive and time-consuming task. Especially regarding topics like those shown there, such as practices, standards, dependencies, and the implementation details themselves.

Thumbnail 1150

And now, we enter the really important part, the idea of implementation—the phase that is truly critical. As you can see, at this point my prompts have become much more verbose, and I am being much more direct with Kiro: "We have a high-priority ticket regarding payment processing performance for our legacy payment system. Based on all the context we have investigated so far, create a specific and detailed plan to address the performance and security issues we have discovered. Prioritize the plan according to our organizational priorities of protecting customer data, excellent customer performance, and frugality. To expedite the approval of this plan, it needs to pass through a change review board. I need clear value identified from an ROI perspective, success criteria, details on improved customer experience, etc. Identify actual actions and who is responsible for what."

Thumbnail 1210

Now, clearly, you can see that the prompt is evolving. It has a purpose, but it is not restrictive. As a result, I get a much richer response that can work within the scope of my prompt, leveraging the foundational context we have developed and collected while progressing through phases 1, 2, and 3 of the SDLC.

Thumbnail 1230

Thumbnail 1240

Thumbnail 1250

Thumbnail 1260

And in this scenario, Kiro outputs a step-by-step implementation plan. This is something that I, anyone else, or even Kiro itself can complete agentically. And from here, we begin to consider turning this into an asset that can be taken to a change review board, acting as an escalation, or creating integrations with third-party systems like Jira. And crucially, it includes predicted outcomes, the risks we are trying to mitigate, and success criteria that can contribute to what the details of the definition of done are—achieved through systematic creation rather than subjective creation.

Thumbnail 1270

Now, what happens at this point is very interesting, something we didn't quantify much in the early stages. By giving people the ability to assign tasks and chores, they gain the ability to shift their value elsewhere when managing assigned tasks and their associated returns. Typical examples include senior developers who can start thinking like tech leads, operations engineers who can start thinking architecturally, or project managers who can start thinking programmatically. This is because they are constantly managing and reviewing outcomes and actions that have specific standards, and there are very deep and inherent quality benefits that accompany this.

Thumbnail 1310

Great. Now let’s go back to the quote from five minutes ago and apply that lens to everything we just talked about. It is still humans who provide the contextual and tool wisdom, and the strategy to prevent agents from guessing in the dark. This collaboration with agents—giving humans the ability to have agents deal with toil-based activities while humans deal with higher-order value like orchestration—is a powerful concept. Now, let’s take this concept of human-agent collaboration a step further and get into the details with a real-world, concrete example. To do that, I would like to welcome Paul Thrasher back to the stage. Thank you, Paul.

Thumbnail 1370

Challenges Faced by HashiCorp and Solution Approaches with Agentic AI

So, what problems are we trying to solve at HashiCorp? We are seeing constant, accelerating growth in the AWS Terraform provider and the AWSCC Terraform provider. As you can see here, there are currently about 3,000 open issues and, as of the last check, 518 open PRs. And while there are over 3,000 contributors, HashiCorp has only one software engineering team. That team supports over 5 billion downloads. I think it was 5.3 or 5.4 when I last checked, but recently it is over 5 million per day. That means we are supporting a significant number of users every day, along with the increasing volume of resources that bring in PRs and issues.

Thumbnail 1410

Thumbnail 1440

So how is this team continuing to cope with constant changes, increasing issues, PRs, downloads, and support? As you can see, if we do not change anything, it will increase beyond our maintenance capacity. So, it has been difficult to scale. Of course, to scale the team and welcome and onboard new members, the same engineer needs to have experience with Terraform, the SDK for building Terraform providers, Golang, and AWS. Of course, you can train them, but it is obviously helpful if new engineers have as much as possible when they join.

Thumbnail 1500

Writing PRs naturally takes more time than reviewing them. Since overall development velocity slows down, each engineer must keep up with that. This accounts for the majority of their work. When welcoming and onboarding new contributors, they need to understand standards, principles, working methods, and how things operate within HashiCorp and within this team. This is constantly changing as we scale to accommodate growth here. Regarding code quality, we need sanitized, compliant code. Of course, it must always be high quality, and ideally, it should improve over time.

Thumbnail 1520

As we go through the process of hiring, creating PRs, and onboarding new members, we must maintain that rigor and keep code quality high. And there is the security risk; as you can imagine, given our large-scale customers and the massive scale of Terraform and AWS, we need enough scrutiny during the process of accepting various contributors to ensure no malicious code is injected. You can probably imagine the risk: if code were injected and made its way into a contributor's work, it would suddenly be embedded everywhere, including in banks and other security products.

Thumbnail 1560

And all of this ultimately leads to a bottleneck in reviews due to the number of external contributors. Furthermore, they all require reviews by experts with specialized knowledge in various technologies and services. This limits not only the number of reviewers but also the time it takes to process them. In other words, the point here is that scaling this is difficult. Therefore, over time, we have had to think about what the options are, how to improve the process, and how to address that burden.

Thumbnail 1600

Thumbnail 1610

Of course, it primarily requires a lot of hard work. But now, AI is also available. I have worked with raw models, built things in-house, and tried various approaches, but I believe this efficiency gain does not reduce the engineering role; rather, it expands what the team can achieve. So, what are we looking for? What can we expect going forward? We want our human team to be more effective. We need to scale their work and their efforts. We want it to be easier for engineers and for the external teams maintaining their providers. This is not just about this AWS team.

Thumbnail 1670

At HashiCorp, we are trying to scale these efforts across many partners. And we have already spent a lot of time through various investments in these maintenance cycles, PR and review processing, hosting service scaling, and the ability to accommodate more contributors. This is nothing new for us. So, naturally, we explored AI as an option. About a year ago, in the early days before agents emerged, we explored trying raw models. Or even now, we can see how much faster throughput could be because we can parallelize a lot of work.

Implementation as we move along this path could be faster. We can also incorporate CI/CD or some kind of consistent process when changes come in. And while it is good for exploration and experimentation, for us, the results were unpredictable. They are hard to reproduce. Just because you ran one prompt one way does not mean it will work the same way for another similar resource. It requires a fairly deep understanding of these resources, relies heavily on prompting, and these are like things that work only once after getting a result.

Thumbnail 1730

We have tried instruction-based agents. These are the kinds of agents most of you are familiar with. They are great at guiding us along a workflow. If we proceed together, they can follow the patterns we set, and they don't require too many structures or checkpoints. In some cases, you can try to see how far you can get, aiming for a one-shot result. Like, 'can you code for 30 minutes?' But as Paul showed, they are still limited by prompting. They require careful user monitoring to check the code and ensure it is good, and they can drift, misunderstand, or head in the wrong direction between implementations.

Thumbnail 1790

And more recently, we tried spec-driven agents using Kiro, ever since Kiro was released. They provide us with consistent, high-quality work, which is fantastic. Of course, that comes after putting in the rigor and pre-prompting to get clearly defined requirements.

It was a wonderful result for the complex work we did within the AWS provider. One caveat, however, is that it requires a lot of upfront thinking and design. But this is something we already do at HashiCorp. It is part of our process anyway. As you can see in the SDLC, we go through these phases already, so that upfront thinking fits our flow regardless.

Thumbnail 1840

Practical Demonstration of Terraform Action Development using Kiro: Achieving a 90% Time Reduction

So, there are some interesting numbers. Honestly, for us, it is wonderful and truly encouraging; development time for provider resources and actions has been accelerated by 90%. I will show you that shortly. We have also developed over 700 high-quality configuration document resources. I believe there are thousands of resources we need to manage, catch up with, and develop. Documentation is a big part of that. We applied AI there as well, and the quality remains high. We get rapid iteration speed, and tests and various controls also come along throughout the process.

Through development, we have built over 600 Terraform resources. We used to spend a significant amount of time on that. We have achieved over 600 so far. This was a week or two ago when I checked these numbers. There are definitely more now. Also, 500 Terraform actions have been created so far. In terms of overall efficiency, we have achieved about a 90% time reduction, which is the figure across actions and Terraform resources combined. In some cases, we witnessed development of a Terraform resource that used to take a full 40 hours shrink down to about 4 hours. It is a massive speedup for us and really encouraging.

Thumbnail 1950

So, how do we follow the SDLC process at HashiCorp? In the analysis and planning phase, we create PRFAQs and PRDs. I believe PRFAQs originated from Amazon, and they are fantastic things we borrowed from them. This is like upfront planning. This is primarily the job of product management, but it is also upfront work done in high collaboration with engineering to figure out what we need to go build. RFCs have been used at HashiCorp for a long time, acting as a process for engineers to design what they intend to build upfront and define the direction through the design implementation phase. And of course, engineering is all done within the IDE and GitHub.

Regarding testing and integration, we naturally have standard unit tests and integration tests. However, the AWS Terraform provider is quite large, and as you can imagine, performing integration tests across all AWS services is not only slow but also costly. Therefore, this is an asynchronous, less frequent process. But for us, documentation is also important. This is a very large part of it. If we cannot deliver it in a form that you can understand and consume, we have not fulfilled our job. It is not useful for anyone. Through the maintenance process, it returns to continuous monitoring, handling issues and PR reviews, which is fed back into the analysis and planning phase.

Thumbnail 2050

Now, let's start the first demo. I will show you how we applied the SDLC phases with Kiro. We will build a new Terraform action for the AWS provider. Actions are new to Terraform. The model does not understand them. The model understands building within Go. When you search for anything related to Terraform on Google, you get a lot of HCL code. In other words, in this aspect, it is unknown to many of the processes we usually expect to work well. In this case, it is 'DynamoDB create backup,' which simply triggers a DynamoDB backup. And this is all real code that we actually ship.

Thumbnail 2100

This is the analysis and planning phase. We have started creating the steering document.

Thumbnail 2110

Thumbnail 2120

Thumbnail 2140

Thumbnail 2150

Kiro helps with that. Sometimes, it launches with a single click. At HashiCorp, we go through the PRVQ and PRD stages, which reflect our typical process, and it is exactly like that now in Kiro's way. Sometimes, you might want to execute these as separate steps to iterate while collaborating with the team. Throw it into the repository and get feedback. But here, we want to demo end-to-end how we work, so we will breeze through it. And since LLMs aren't the fastest to execute, we have sped it up to show you all the stages here.

Thumbnail 2160

Thumbnail 2170

Thumbnail 2180

Thumbnail 2190

The spec here is about how to read the repository and how to work in the way we want. I collaborated with one of the engineers on the Terraform AWS Provider. He is an excellent engineer and is well-versed in the codebase, having already built a great number of resources. So, he can jump in, write the prompt, and tell Kiro exactly how we want to approach this task. This is not implementation yet. This is writing the spec for how we want it to behave when we start triggering the next task. These are just requirements.

Thumbnail 2200

Thumbnail 2220

Thumbnail 2250

Here, I am manually writing this out based on documentation. You can see me including other files. I am giving it good examples to reference. Then, I refine the documentation. I make a few updates, check those files, do a bit of prompting, and yes, it is done. I love this part, as the LLM does some work for us based on what we need from this process and this documentation. And those files will become available as part of the library we are building, so those maintaining the Terraform provider can create actions similar to what we have done. This is fantastic. As a PM, I am doing the talking, but I also want to derive some product value from this. I will talk about how we will deliver some of this work to all of you later.

Thumbnail 2260

Thumbnail 2280

Thumbnail 2290

Thumbnail 2300

Thumbnail 2310

Thumbnail 2320

Thumbnail 2330

This is phase 2: the design and implementation stage of the SDLC. I asked it to create a plan. It immediately kicked off, started writing code, and proceeded step-by-step. Kiro writes the code based on the steps I laid out in the task document. We are speeding this up, but in terms of our engineering time, this is real-time; this is how we developed this feature. It was 1 hour and 20 minutes in total. We are speeding it up to condense it into about 6 minutes for you all, but this was our real-time process. As it goes along with the LLM, he is checking to ensure the code is being generated appropriately. You can see it updating the task and making changes based on feedback from previous steps. And, of course, because this is going into production, we need to ensure it meets our standards and quality.

Thumbnail 2340

Thumbnail 2350

Thumbnail 2360

Thumbnail 2370

Thumbnail 2380

In this case, we did not encounter any major errors. We have gone through this process a few times. We used Kiro's CLI a few times before this. That was part of our initial improvements. Kiro was relatively new to us, but he was quickly able to get up to speed in many respects through his experience and work with code. And Kiro ensures that the packages he is building here are consistent with other code and services developed. Since we had a few examples, it became a bit easier. Writing the first action was, of course, a long interaction process with the Terraform Plugin Framework, the SDK, and other provider work, but once you have a few, you can rely on previous examples.

Thumbnail 2400

So, we proceed step-by-step and ensure it is progressing correctly. And each task we move through references those steering notes. In phase 3, which is the test and integration phase, we have already started writing tests according to the specifications in that task list.

Thumbnail 2410

Thumbnail 2420

Thumbnail 2430

Thumbnail 2440

We go through each step of the task file, and since tests and documentation are usually written at the bottom, we reach those at the bottom. As before, we are doing live development here, and it is an opportunity to use these tests to ensure the code is correct, performing correctly, and producing the right expected output. It writes unit tests for us, so we can confirm everything is functioning.

Thumbnail 2450

Thumbnail 2460

Thumbnail 2470

Thumbnail 2490

After unit tests, we move into end-to-end tests. We seem to have tripped up a bit on authentication credentials. We need AWS credentials to run these tests, but we were able to quickly create a DynamoDB table and trigger the backup action. A test failure occurred here, but Kiro read the output, went back to the implementation, fixed it, re-tested, and passed. While we have to provide human-readable instructions, Kiro is doing all the actual work, testing, and actual coding; we just have to focus on supporting it with a natural language flow and path.

Thumbnail 2500

Thumbnail 2510

Thumbnail 2520

Thumbnail 2540

Toward the end, you can see it also generates the documentation. Documentation can also take a long time. These are generally based on the APIs in the AWS reference documentation, which follow standard formats and follow the same standards as other documentation. Documentation is a bit tedious, but it is boilerplate in many cases because we need to support it. I think you can see that Kiro is not doing everything alone, but rather we are coding together with the agent. From there, we naturally move to a pull request on GitHub and also find an AI friend to review the code.

Expanding Workflow Support with MCP Servers and Kiro Power

While developing this, we were thinking about how we could support your AI workflows. What does HashiCorp have for the rest of you? That has been a central part of the workflows we have been developing and working on. It was through MCP servers, and we wanted to bring some of that efficiency to you, the users. You have seen many talks about MCP this week, but what is our perspective? How are we thinking about it? For us, this is an open-source project that supports AI workflows. It brings context to your development environment as you work. In fact, we are seeing more IT business use cases coming out of MCP servers, especially with Terraform alone. This gives you connections between tools and models within agents—or other contexts—and provides rapid, plug-and-play integration. We found that we could write these MCP servers, provide them to partners, and place them in other products. This is something we could not do before.

Thumbnail 2640

Thumbnail 2700

Now, about the MCP server in Kiro: here you can see a quick setup, but an example prompt would be, "Help me set up an S3 storage bucket in Terraform." This is a very common task that usually requires going to look up documentation. In this case, the MCP server operates within that workflow, handling things in a pattern similar to how you would do it. I think of this as simply wanting to support these workflows within products, whether they are open-source or commercial. This MCP server searches for content in the registry, retrieves content from multiple documents, triangulates how to create resources, and combines those results to create the necessary resources. So, let me show you the MCP server within Kiro with a simple demo.

Thumbnail 2710

Thumbnail 2720

Thumbnail 2730

Thumbnail 2740

Thumbnail 2750

So, can you help me create an S3 bucket using Terraform? It's a simple use case. I've created so many buckets that I can't count them anymore. But we start from scratch. That was an empty repository. Using the MCP server, I fetched the latest provider version. This works not just with AWS, but with all providers. It also checks multiple resource documents to get the best match for that context. It's great that the model knows how to do that and the agent supports it. You can also feed all this information back into the Kiro steering document, but for this demo, I'm keeping it simple.

Thumbnail 2760

Thumbnail 2770

Thumbnail 2780

Thumbnail 2800

Thumbnail 2810

Thumbnail 2820

You can also ask it to use public or private modules. If you are using HCP Terraform, you probably have your own best practices built into policies and modules, and you can retrieve them. Here, I'm having it follow CIS policies fetched from the registry, and here it is updating the code to be compliant with the policy. Later, you'll see it also interacts with the Terraform CLI. Here it is. It performs formatting. Having MCP perform formatting doesn't make much sense since it knows the CLI so well, so it just runs it. For basic formatting and validation, I think those are the best use cases for them. Other than that, personally, I don't think an agent should execute the rest of the Terraform plan or apply. HCP Terraform exists to support that process for collaboration and security.

Thumbnail 2830

Thumbnail 2840

Thumbnail 2850

Thumbnail 2860

Ultimately, you get an S3 bucket with logging and policies, and we've verified that it is not public. This means it follows not only best practices but also the policies within the business, is ready for use in a production environment, and complies with what is expected from a human going through a PR process. So, what are HashiCorp's next steps? We have introduced many AI-first development practices. We are focusing on human-agent partnerships and have set up a dedicated team for provider development and configuration authoring using AI agents. I think more support and tools will be provided there.

Also, a few days ago this week, we learned about Kiro Powers together with you, and yesterday we quickly put together documentation and an MCP server. Even though we only just learned about it this week, we secured legal approval and marketing support and announced it yesterday as a launch partner. We developed these specifications and various aspects. We plan to launch it in other places, but currently, there is the HashiCorp Terraform Kiro Power. The team will work on things to support configuration development and Terraform provider development.

We plan to provide official agent documentation for Kiro and other agents. We will provide these tools. Since each of these tools has its own proprietary support, we will build in response to that. We believe this is beneficial for HashiCorp, IBM, our partners, the entire ecosystem, and all of you, the users. Working within the context of AI agents will become much easier. I think more things will come out in the future. We want to accelerate significantly regarding AI within HashiCorp, and we will take in the latest ideas from other parts of the industry. This is, of course, how we have always operated, so we are proceeding with a very similar process even now that AI is involved.

Thumbnail 2990

Please check out our Terraform MCP server. I will leave the QR code up for a while. We have also built them for Vault and Vault Radar. I expect even more will come out in the future. Through there, please also check out Kiro Power. And in the near future, documentation on how to best use this MCP server is scheduled to be released.

Thumbnail 3030

The Future of SDLC: Human-Agent Co-creation

Thank you, Paul. Thank you, Paul. And before we finish in a minute or two, I want to take off my hat in public and recognize the incredible achievements you and your team have made. You've achieved amazing results, such as regaining 90% of your team members' time in a single day. I want to say "well done" for everything you and your team have accomplished in this process. It's truly a fantastic result.

Thumbnail 3060

Paul and I have talked about the many ways agents are transforming the SDLC. We've talked about backlog grooming, requirement generation, and intelligent orchestration. This comprehensive integration of agents into the SDLC is transforming what was a somewhat linear and sequential process into something that moves in a more dynamic, looped fashion. Where this leads will be truly interesting for all of us to watch over this very short period.

Thumbnail 3080

However, one thing is certain: this is what enables the efficiency and quality of delivery that Paul just explained. And while I know we have been repeating this point, none of this really happens without a synergistic relationship where humans and agents co-create. And that applies to Ops engineers who use agents for infrastructure orchestration, monitoring, and incident response. But it also applies to technical BAs who use them to analyze requirements and create user stories. And if you are a purist like me who likes the "when-then-shall" approach to user stories, take a look at what Kiro can do.

Thumbnail 3140

It also includes architects simulating system designs, ensuring compliance, and evaluating scalability, as well as project managers handling sprint planning, communication with stakeholders, and risk analysis. The result is a more comprehensive and efficient development environment, where every role contributes meaningfully to software delivery. This is a very exciting concept. If I were to predict the next 12 months, this is what it looks like to me. Without a doubt, agents will gain greater autonomy. For instance, as use cases like the "organic transformation" I spoke about earlier become clearer and are adopted.

Thumbnail 3180

However, that is directly tied to what we call true collaboration. In this context, it doesn't mean heavier collaboration; it means effective monitoring, which, as we discussed earlier, is one of the keys to the human-agent partnership. And finally, for the third and final point of today's session, higher quality output from the SDLC means a faster, more linear path for organizations and developers to capture the opportunities they are addressing through software creation. So, where can you learn more?

Thumbnail 3210

One of these events is still going on right now. If you haven't been to the House of Kiro yet, it is in this building, Level 2 of the Venetian, in front of the expo; so please go, walk through the spooky House of Kiro and check it out. It is a bit of an exciting experience. It's a very cool experience. And there is great swag on the other side. So thank you all for your time today. I truly appreciate you spending an hour with us. It was a wonderful time. Paul, thank you for joining me on stage. Travel safely. And I look forward to seeing you all again next year. Thank you.

Discussion