Replicating Kiro's Spec-Driven Development in Trae: A Free Alternative Tested and Compared

Amazon Kiro's Embarrassing Debut: Pulled Offline Two Days After Launch

Amazon's AI coding tool Kiro initially took the developer community by storm with its "Spec-driven development" concept. But reality hit hard — writing requirements crashed, writing detailed designs crashed, writing task lists crashed, and even saving documents crashed. To make matters worse, the official team pulled the product offline just two days after its public release, leaving users stuck in a waitlist queue.

Despite Kiro's stability issues, the Spec concept it introduced — driving AI-assisted programming through standardized requirements documents, design documents, and task lists — is a methodology worth learning from. The question is: can we achieve the same results with a more stable, more accessible tool?

A Domestic Alternative: Replicating Kiro's Full Workflow with Trae's Agent Pipeline

Some developers have tried using Trae, a free Chinese-made IDE, combined with custom agent workflows to fully replicate Kiro's three-document pipeline. The core advantages of this approach are: free, no waitlist, and a higher degree of automation.

Requirements Documents: EARS Notation Helps AI Better Understand Your Intent

For the requirements writing phase, this approach adopts the EARS (Easy Approach to Requirements Syntax) notation. This is a requirements writing method particularly well-suited for AI-assisted programming scenarios, enabling AI to more accurately understand development intent.

EARS was originally proposed by Alistair Mavin and colleagues in 2009, born out of aerospace engineering practice at Rolls-Royce. Its core idea is to eliminate ambiguity in natural language requirements through five fixed sentence templates (ubiquitous, event-driven, state-driven, optional, and complex). A typical sentence pattern looks like: "When [trigger condition], the system shall [response behavior]." This structured expression naturally aligns with the contextual understanding mechanisms of large language models — LLMs produce significantly better output quality when processing consistently formatted, semantically clear input compared to vague free-form text. This is why the same functional requirement described in EARS format dramatically improves AI implementation accuracy.

Unlike Kiro, which has AI generate requirements all at once, this agent approach uses a step-by-step strategy: first write an outline, then decompose tasks, and finally write requirements for each task individually. This progressive generation method makes AI output more reliable, and the resulting requirements documents can even surpass the quality of many product managers' hand-written versions.

Design Documents: Task-by-Task Progressive Writing for Better Quality

The design document phase also employs a task-by-task progressive writing strategy. From actual comparisons, both Trae and Kiro generate highly detailed design documents with clear directory structures and complete technical solutions.

There's a key insight here: having AI complete complex tasks step by step is far more reliable than asking it to output a complete document all at once. This also explains why simply asking ChatGPT to "write me a design document" often produces poor results — it lacks a structured guidance process. From a cognitive science perspective, this closely mirrors how human experts work: even excellent architects don't produce complete design documents from thin air. They first define boundaries, then refine modules, and finally flesh out interfaces.

Task Lists: Trae Runs Fully Automatically, Kiro Still Requires Manual Clicks

The task list phase is where the two differ the most. Kiro requires developers to manually click the "Start Task" button to execute each task one by one, while Trae's agent solution achieves fully automatic sequential execution with zero human intervention.

This difference reflects two distinct AI Agent architectural philosophies. Trae's pipeline automation relies on the ReAct (Reasoning + Acting) framework and Function Calling capabilities — the agent can not only passively respond to instructions but also proactively plan task sequences, pass state between steps, and automatically trigger the next phase. It's essentially a lightweight AI workflow engine. Kiro's current version still retains manual confirmation checkpoints, which may be a conservative but reasonable design choice during the early stage when stability hasn't yet met expectations.

This means developers only need to describe their requirements at the beginning. Everything afterward — requirements document generation, design document writing, task decomposition, and code implementation — can be completed automatically in a pipeline fashion.

The Spec-Driven Development Methodology: Why Standardized Documents Improve AI Programming Quality

Setting aside the tool debate, Kiro's Spec-driven development concept itself deserves deeper consideration. Its core logic operates on three levels:

1. Requirements Standardization: Describe requirements using structured syntax to reduce ambiguity and help AI accurately understand developer intent
2. Design First: Complete technical solution design before coding to avoid extensive rework later
3. Task Atomization: Break large tasks into independently executable small tasks to reduce AI error probability

It's worth noting that Spec-driven development isn't an entirely novel concept. It's essentially a modern practice that combines the early phases of the traditional software engineering "waterfall model" (requirements analysis → system design → detailed design) with AI code generation capabilities. In the era of agile development, these upfront documents were often dismissed as "over-engineering" and simplified. But AI-assisted programming has given them renewed core value — AI models lack the tacit knowledge and contextual inference abilities of human developers and must rely on explicit specification constraints to produce high-quality code. This also explains why "Context Engineering" is becoming one of the most important development skills in the AI era: what information you provide to AI matters far more than how you prompt it.

The essence of this methodology is combining software engineering best practices with AI capabilities. AI excels at generating content under clear constraints, and standardized documents provide exactly those constraints. Whether you use Trae, Kiro, or Cursor, mastering this methodology will significantly improve the quality of AI-assisted programming output.

Trae vs Kiro: Test Comparison Summary and Practical Recommendations

Based on hands-on testing results, the Trae approach outperforms in several dimensions:

Dimension	Kiro	Trae
Availability	Pulled offline, waitlist required	Free and open for use
Stability	Frequent crashes	Runs stably
Automation Level	Requires manual task triggering	Fully automated pipeline
Document Quality	Detailed and complete	Equally detailed and complete

For developers looking to try Spec-driven development, here are some practical recommendations:

• Tool Selection: As a free domestic AI IDE, Trae currently outperforms the not-yet-publicly-available Kiro in terms of accessibility and stability
• Process Design: The key isn't which tool you use, but whether you've established a standardized "requirements → design → tasks → execution" workflow
• Agent Configuration: Through custom Prompts and workflows, any AI coding tool with Agent support can achieve similar results
• Progressive Generation: Avoid having AI output large volumes of content all at once — step-by-step guidance is the key technique for improving generation quality

This case highlights a trend worth watching: when overseas tech giants' AI coding products are unusable due to stability issues, domestic tools combined with community wisdom can actually deliver a better development experience. The Spec-driven development concept is sound, but implementing it doesn't necessarily require waiting for a specific product — understanding the methodology itself and using existing tools like Trae can get you there just as well.

Key Takeaways

• Amazon's Kiro was pulled offline just two days after launch due to severe stability issues, but its Spec-driven development concept is worth adopting
• The domestic tool Trae, combined with custom agents, can fully replicate Kiro's three-document pipeline of requirements, design docs, and task lists
• Using EARS notation (originating from aerospace engineering practice) for requirements writing with progressive generation is more reliable than one-shot output
• Compared to Kiro's manual task-by-task execution, the ReAct framework-based agent solution enables fully automated pipeline development
• The core of Spec-driven development is requirements standardization, design-first approach, and task atomization — essentially combining traditional software engineering best practices with AI capabilities, practicable without dependency on any specific tool