Artificial intelligence tools are already part of the software development routine. They help complete code snippets, explain functions, suggest fixes, and transform natural language instructions into functional applications. The gain in speed can be significant, especially in the early stages of a project. The challenge arises when it is necessary to ensure that the result meets requirements, follows the expected architecture, and can be maintained by a team.

What is Kiro?

Kiro is an AI-powered development environment created by AWS. The tool was designed to support different stages of development, from defining what needs to be built to implementation, testing, and documentation.

Instead of being limited to generating code from prompts, Kiro provides features to organize instructions into technical specifications, plan implementation, and keep important project information available during work. The goal is to bridge the gap between developer intent and the software produced.

Kiro uses AI agents that can interpret requests, plan steps, and execute actions based on the available context and configured permissions. This makes it possible to work on tasks involving multiple files and components without relying solely on isolated answers in a chat.

The tool is available across different interfaces, including an integrated development environment (IDE), a command-line interface (CLI), and a browser experience. Each modality caters to different ways of working, but they all share the core capabilities of the agent.

This approach can be useful both for those starting a project and for teams that need to evolve existing systems. In larger codebases, a seemingly simple change can impact dependencies, API contracts, tests, and previously made architectural decisions. Therefore, having an organized context helps guide the AI's work and makes reviewing changes easier.

IDE, CLI, and browser: different ways to work with Kiro

Kiro offers different interfaces so developers can choose how to interact with the agent according to their routine and the type of work they need to perform.

Kiro IDE: the integrated development environment for working directly with code. It allows you to interact with the agent, track changes, and review the implementation within the editor itself.

Kiro CLI: runs via the command line and caters to terminal-based workflows. It can be used for development activities, automation, and integration with tools already used by the team.

Kiro Web: allows you to start and monitor development sessions through the browser. The agent can work in isolated cloud environments, including with connected repositories, while the developer tracks progress and reviews results.

Kiro Crew: an open-source development environment focused on agent coordination and work continuity across sessions and tools.

Kiro's current vision is to offer a shared agent across different interfaces, with configuration and context information that can follow the project. This way, professionals can choose the most suitable environment for each situation without needing to rebuild the entire context with every interface change. The availability of certain features varies depending on the modality.

Compatibility with existing tools is also part of this vision. Kiro IDE is based on Code OSS, the open-source project that serves as the foundation for Visual Studio Code. Because of this, it supports importing settings, themes, and extensions compatible with Open VSX.

In practice, this reduces much of the adaptation effort for those who already have a configured development environment. Even so, adoption requires evaluating the necessary extensions, available integrations, and organizational security policies.

The choice of interface depends on the context. Those who work directly in the editor may prefer the IDE, while professionals accustomed to automating processes via the terminal may find the CLI a more natural path. Meanwhile, the browser allows delegating and tracking activities without keeping all the work open in a local session.

Regardless of the interface, the goal is to keep the agent integrated into the development process, respecting each project's tools, rules, and needs.

What is spec-driven development and how does it work in Kiro?

Spec-driven development is an approach that places requirements and technical planning at the center of the development process. Instead of jumping straight into implementing a complex feature, the work begins by defining the expected behavior, the technical decisions involved, and the steps required to achieve the outcome.

In Kiro, a natural language request can be transformed into an organized set of specifications that guides the implementation. The process is divided into three main parts.

Requirements: the first part details what the software needs to do. A generic request, such as adding a review system to an online store, can be broken down into requirements to display reviews, allow submitting comments, define rating criteria, and establish publication rules.

Acceptance criteria help determine when each requirement can be considered fulfilled. They also make it possible to identify gaps and edge cases that might go unnoticed in an initial description.

Technical design: with the expected behavior defined, Kiro can draft a technical proposal based on the requirements and project context. As needed, the documentation allows including architectural decisions, interfaces, data models, API endpoints, and diagrams.

This planning helps visualize how the new feature fits into the existing system before moving forward with implementation. It also gives the developer an opportunity to review proposed choices and correct unsuitable assumptions.

Implementation tasks: finally, the requirements and design are converted into smaller tasks organized according to their dependencies. Each task can be linked to corresponding requirements, making it easier to track progress and verify what has been completed.

With this plan, the developer has the chance to review the specifications and follow the implementation step-by-step, maintaining a clearer view of how changes were planned.

Specifications can be updated as the project evolves. When requirements change, professionals can revise the plan and tasks to keep documentation aligned with the system's current needs. This process does not eliminate the need for human decisions or replace code validation, but it creates references that can be consulted during implementation and maintenance.

The goal is to make the decisions guiding development explicit, facilitating code review and project continuity as new features are added.

Features for AI-assisted development in Kiro

Beyond specifications, Kiro brings together features to preserve project context, automate actions, and expand code verification capabilities. They help guide the agent during work and reduce dependence on repeated instructions with every interaction.

Steering files

Steering files are orientation files that record project information, such as coding conventions, technologies used, folder structures, and architectural decisions. Kiro can consult this information to guide its responses and changes.

In a team that uses specific patterns to organize components or handle errors, for example, these files help keep instructions readily available to the agent. This way, the developer doesn't need to repeat the same conventions with every request.

These documents can also record testing approaches, documentation standards, and other relevant rules. However, they need to evolve alongside the project so as not to guide the AI with outdated information.

Agent hooks

Agent hooks allow you to configure actions that trigger when specific events occur. Depending on the configuration, the agent can execute an activity following file changes or when receiving a manual trigger.

This mechanism can support recurring tasks that are part of the development workflow, such as keeping documents aligned with the code or running checks at specific points. Instead of relying solely on the developer's memory, the team can define when certain actions should occur.

Automation does not mean that every activity will run without supervision. Behavior depends on the configured triggers, the instructions provided, and the permissions granted to the agent.

Testing and automated reasoning

Kiro also features tools aimed at requirements analysis and behavioral verification. The goal is to identify potential gaps and contradictions before implementation and enhance the ability to find issues that existing tests fail to catch.

One of the techniques involved is property-based testing. Unlike tests that only verify specific examples, this approach evaluates rules that must hold true across a wide range of different inputs.

Consider a function that calculates an order's final total. A traditional test might check the result for a few known values, while a property-based test can verify whether the calculation adheres to certain rules across a broader variety of valid inputs.

This helps uncover failure cases that do not appear in initially anticipated examples. Still, the quality of verification depends on the properties defined, the scenarios tested, and the application's context. None of these techniques guarantees that all defects will be identified.

Integrations and model selection

Support for the Model Context Protocol (MCP) makes it possible to connect Kiro to compatible external tools and sources. The protocol establishes a standardized way to provide context and tools to AI systems, expanding the integration possibilities within the development environment.

The tool also allows choosing among different AI models, depending on availability and the task's requirements. This selection allows factoring in elements like the ability to handle complex tasks, latency, and cost. In automatic mode, Kiro can route the request to a model suited for the task based on available options.

These features serve different purposes. The value lies in combining these mechanisms according to need, without assuming that all of them must be active in every situation.

What changes in a dev's routine?

The main shift proposed by Kiro lies in how work is distributed between the professional and artificial intelligence. Rather than using AI merely as a question-and-answer model or to generate code snippets, developers can leverage agents to organize stages of a broader process, keeping requirements, technical decisions, and verification criteria as part of the workflow.

Such a process can reduce the effort spent on repetitive planning and documentation tasks, make it easier to understand complex changes, and help teams maintain shared standards. Additionally, it creates opportunities to review decisions throughout development before they are fully embedded into the code.

For technology companies, this approach can contribute to making AI-assisted work more traceable and aligned with internal conventions. For individual developers, it provides a way to organize projects that start with an idea and need to evolve into a sustainable implementation.

The proposal is to have AI participate in a more organized development workflow, where the software produced can be understood, tested, and maintained over time.