Kiro Code entered Public Preview approximately three weeks ago. I successfully created several accounts before they temporarily restricted access due to overwhelming demand. During this preview period, the platform offers free access to both Claude 4 Sonnet and Claude 3.7 Sonnet.
How Kiro Code Distinguishes Itself from Other VS Code Forks
With the current proliferation of VS Code forks in the market, you might reasonably question what makes Kiro genuinely unique.
The primary differentiator for me is its implementation of spec-based development. Initially, I assumed this would be comparable to the various .cursorrules files that can be configured, or similar to the client rules and memory bank files available in other tools. However, when comparing it to Claude Code and the Claude .md files, I discovered the fundamental distinction lies in where you actually invest your time and how the platform abstracts the development process. Rather than focusing on writing code directly, you spend the majority of your time planning and architecting the solution.
The Requirements Gathering Phase
When planning a new feature or developing an entire application, the initial step involves gathering requirements. You can provide requirements to Kiro in an unstructured format, and it will transform them into a comprehensive set of product requirements complete with acceptance criteria and user stories. The system breaks these down into multiple requirements, each with corresponding user stories and acceptance criteria.
For instance, examining requirement number 4 from one of my current projects, it states: "User story: As a developer, I want to understand the backend schema and API structure so that I can properly integrate with the service name." This requirement includes four detailed acceptance criteria.
The system has mapped out a substantial framework, totaling 10 distinct requirements with a minimum of 4 acceptance criteria each.
Transitioning to Design Documents
After defining the requirements, the next phase involves developing the design document. This document links directly to the requirements and outlines the architecture with a comprehensive overview. It creates visual representations using Mermaid diagrams, providing a clear architectural flow. The level of detail can be adjusted based on your specific needs. Whether you're developing an entirely new product or implementing a feature within an existing system, it can be adjusted to suit.
The design document incorporates code snippets, maintains links back to requirements, and defines elements such as type interfaces, high-level functions, folder structures, and library selection decisions.
Where I Actually Invest My Time
Once the initial documentation is complete, you'll find yourself iterating between requirements and design documents multiple times. This iterative process is where I spend approximately two-thirds of my time in Kiro. That is, refining the design and requirements rather than creating implementation tasks.
The significant advantage is the ability to identify potential issues during the design and requirements phases, before any code is written. This approach minimises the risk of having an agent create an entire feature that might require substantial changes later.
Similar to how you might incorporate steering documents and other codebase components with .md files in Claude Code, Client, or Cursor, Kiro offers the same capability. You can include steering documents and MCP servers, specifying within the steering documents where and how to reference the MCP server throughout the implementation.
Creating and Executing Task Lists
Following the completion of the design document, you proceed to create the task list. This list provides a granular breakdown of how to transform the requirements into functioning code. For example, in my current implementation plan, task number 1 is "Create backend insights service foundation," which includes multiple sub-points and links to requirements 1.1, 4.2, 10.1, 10.2, 10.3, and 10.4. The complete plan comprises 14 distinct tasks, each with approximately 2 to 3 sub-tasks.
The interface enables you to queue these tasks for agentic execution. Rather than monitoring each task's completion individually, I typically spend 5 to 10 minutes thoroughly reviewing the task list before initiating the automated execution.
How Kiro Verifies Requirements Through Testing
A crucial aspect of Kiro's approach is its method of verifying requirements through comprehensive unit and integration testing. One common challenge when using AI for code generation is the difficulty in understanding the user perspective and simultaneously generating appropriate unit tests.
What makes Kiro particularly interesting is its verification methodology, and how it confirms requirement fulfillment by creating corresponding unit or integration tests. The system creates tests specifically for each requirement and ensures that the implementation satisfies the requirement when tests pass. Importantly, it doesn't generate superficial tests with empty functions merely to achieve completion. AWS appears to have implemented something genuinely innovative under the hood here.
Enforcing Code Quality Standards
Another notable strength is its handling of code quality standards. For instance, I'm currently working on a repository with stringent linting and type-checking requirements. In my steering document, I specify that task completion requires not only meeting the criteria through tests mapped to requirements but also passing type checking and linting. If the code fails linting, testing, or type checking, the system automatically revisits and revises the implementation.
The system iteratively ensures that all code passes linting, testing, and type checking before proceeding to the next task in the queue. While this process requires additional time, it represents the closest approximation to delegating a ticket to a human engineer that I've encountered thus far.
The Bottom Line
When the agent begins the next task, it effectively mirrors an engineer selecting a ticket from the backlog, implementing the solution, and writing corresponding unit tests.
Ror developing wrappers, services, and utilities, it demonstrates exceptional capability.
Top comments (0)