DEV Community: BeagleWorks

Getting Started with Spec-Driven Development Using Kiro + Jules + Cursor + GPT-5

BeagleWorks — Tue, 12 Aug 2025 01:01:47 +0000

OpenAI has finally announced GPT-5.

https://openai.com/index/introducing-gpt-5/

As part of the launch, GPT‑5 is available free or at a significantly reduced price for a limited time. Notably, on Cursor, even new users can access GPT‑5 in Agent Mode at no cost.

In this article, we’ll take advantage of this window to demonstrate Spec‑Driven Development using near‑free tooling.

Components Used

While many combinations are possible, for this walkthrough we’ll use tools that offer generous free tiers:

Kiro + Jules + Cursor + GPT‑5

Kiro: IDE, generates Specs
Jules: Web service, here, evaluates Specs validity
Cursor: IDE, generates instructions for the coding agent model by referencing the Specs
GPT‑5: LLM, operates based on instructions from Cursor

What are Kiro, Spec-Driven Development?

Sorry for the self-promotion, but please refer to this article:

Kiro and Spec‑Driven Development: A Quick Refresher — https://dev.to/beagle_dog_inu/kiro-and-spec-driven-development-a-quick-refresher-752

In brief:
Kiro is an AI-powered coding IDE developed by AWS.
Spec-Driven Development(SDD) is the approach of creating specifications documents(Specs) first before asking for coding.

What is Jules?

https://jules.google

Jules is Google's autonomous AI coding agent that operates as web service.
It integrates with GitHub and operates at the repository level.
While its coding capabilities aren't advanced enough for new development, it's particularly strong in areas like maintenance, testing, documentation verification, and code review.
This time, we'll be using it to evaluate the validity of Specs.

What is Cursor?

https://cursor.com

Cursor is a VS Code–based AI coding IDE and one of the most advanced tools in this category. Although typically intended for paid users, there is a limited‑time free trial of GPT‑5 even for free users, which we will make use of here.

Workflow Overview

1. Create Specs in Kiro

I’ll reuse the Specs from my previous article with improvements. After experimenting with the initial phases using Sonnet 4.0 and encountering issues, I made the following changes:

Explicitly specify TypeScript
Minimize class usage
Adopt Kent Beck’s Canon TDD approach and update the task list accordingly
Prohibit modifying test cases when tests fail
Create Steering including the above rules

For background on Kent Beck’s Canon TDD approach, this article is helpful:

https://tidyfirst.substack.com/p/canon-tdd

2. (Optional) Evaluate Specs Validity Using Jules

(While this step isn't mandatory, I wanted to evaluate the soundness of also TDD implementation this time, so I'll include this process.)

While the generated Specs are readable, manually verifying their soundness is quite challenging. We'll use Jules for this validation.

I upload the Specs and Steering to the GitHub repository, grant Jules access, and issue the following prompt:

This product includes specification documents for Spec-Driven Development. The documentation is located in the .kiro/specs/browser-tetris directory.
Specifically, requirements are defined in requirements.md, design specifications in design.md, and the task list in tasks.md.
The .kiro/steering directory contains rules that must be followed during coding.

Please verify:
1. Whether design.md is consistent with requirements in requirements.md
2. Whether tasks.md covers all aspects of design.md
3. Whether design.md and tasks.md adhere to Kent Beck's recommended TDD approach

The results are satisfactory, so we can proceed.

Jules' response is as follows (summary):

The analysis results based on the review of the specifications and operational guidelines are summarized below.

Is design.md based on requirements.md?

Conclusion: No. design.md is based on requirements.md but significantly expands the scope.
Details: Adds new block types, skip function, pause function, and leveling system. There are also inconsistencies in controls (e.g., space key function differs).


Does tasks.md fully cover design.md?

Conclusion: Yes. tasks.md comprehensively covers all aspects of design.md with a detailed implementation plan.
Details: Breaks down all features into specific, actionable tasks, covering everything from initial setup to integration testing. Serves as an excellent TDD-based roadmap.


Do design.md and tasks.md adhere to Kent Beck's recommended TDD?

Conclusion: Yes. Fully compliant with Kent Beck's TDD methodology.
Details: Development guidelines explicitly state adherence to TDD. tasks.md consistently applies the Red-Green-Refactor cycle across all development stages, from data models to UI, demonstrating disciplined adherence.

3. Implement with Cursor

Launch Cursor and open the relevant directory.
In Agent mode, select GPT-5 as the model and proceed as follows:

This project should be developed using Spec‑Driven Development.
The specification documents are located in the .kiro/specs/browser-tetris directory,
- Requirements are defined in requirements.md
- Design specifications are in design.md
- The task list is in tasks.md

The .kiro/steering directory contains rules that must be followed during coding.

Refer to tasks.md and begin development sequentially from task #1

Cursor proceeds sequentially from task #1, much like Kiro. Perhaps due to differences in IDE capabilities, it appears to adhere to the steering rules even more strictly than Kiro, resulting in a rigorously Spec‑Driven Development and at a faster pace.

4. Complete Coding → Fix Bugs → Completion

I worked on this intermittently, so I can’t give an exact timeframe, but the main tasks were completed within a few hours.

Initially, we had a functional prototype - amazing!
However, there were two bugs:

Block rotation wasn't reflected visually until after landing
The game over condition was incorrect, preventing proper game over detection

I issued bug fix instructions and completed the project. (I'm regretting forgetting to instruct them with TDD...)

Demo site
https://github.com/beagleworks/SDD-BrowserTetrisPlus/public/

Repository(some documents are written in Japanese)
https://github.com/beagleworks/SDD-BrowserTetrisPlus

The implementation now works as intended.

Overall Assessment

While I made minor adjustments to Specs, Steering, and some template files before deployment, approximately 95% of the application was implemented by AI.

When I tested the same tasks earlier with Kiro (Sonnet 4.0), some items I had initially abandoned as difficult were completed by GPT‑5 without hesitation. Cursor’s high level of polish also contributed—so while this isn’t solely about GPT‑5’s raw capability, the combination of SDD + Kent Beck’s Canon TDD with Cursor + GPT‑5 proved remarkably effective.

And the fact that this combination is currently available for free—even if only for a limited time—is genuinely exciting.

This could be an opportunity to try creating various applications - it would be interesting!

Kiro and Spec-Driven Development: A Quick Refresher

BeagleWorks — Thu, 07 Aug 2025 02:40:43 +0000

Hello, I'm BeagleWorks. 🐶

According to Kiro's official Discord, Kiro is now sequentially inviting users from its waiting list. With previews having started about three weeks ago, this is welcome news for those who have been waiting.

If user numbers grow significantly, Kiro's Spec-Driven Development (SDD) philosophy could become the mainstream approach in AI-assisted coding.

In this article, I'll provide a quick refresher on Kiro and its approach to Spec-Driven Development.

What is Kiro?

https://kiro.dev/

Kiro is an AI-integrated IDE from AWS, based on VSCode. Described as "The AI IDE for prototype to production," it offers both conventional "Vibe Coding" (similar to Cursor) and an innovative feature: Spec-Driven Development. This approach represents a new paradigm in AI-assisted coding.

Currently, it utilizes models such as Claude 4.0 Sonnet and Claude 3.7 Sonnet.

What is Spec-Driven Development?

As the name suggests, SDD is a development methodology that begins with solidifying specifications before proceeding to code.

Specifically, the AI analyzes human requirements and generates three key documents—a Requirements Definition, a Design Specification, and an Implementation Plan—before any code is written.

During AI-assisted coding, these documents are continuously referenced, which helps to minimize implementation errors that violate specifications and reduces rework. Throughout task execution, the AI maintains a clear understanding of "what needs to be built and how."

In contrast, the current trend in AI coding often involves "developing ideas directly by interacting with AI for automated implementation"—a process that is essentially an advanced form of Vibe Coding. However, as development progresses, this approach often leads to challenges such as maintaining code quality, negative consequences from a lack of documentation, and projects becoming overly complex and straying from their original purpose.

Spec-Driven Development is believed to significantly mitigate these issues.

Kiro's Spec-Driven Development Approach

In Kiro's SDD methodology, you progressively generate documents called Specs through interactive conversations with the AI. These include:

requirements.md (Requirements Specification File)
design.md (Design Specification File)
tasks.md (Task List File)

Through a dialogue with the user, the AI generates each document, makes iterative changes based on feedback, and requires human approval to finalize the spec before proceeding to the next. This ensures a logical flow: the design documents maintain consistency with the requirements, and the tasks are appropriately decomposed based on the design.

Additionally, you can create a complementary document type called Steering. You can write project-specific rules, constraints, and policies in natural language, and the AI agent will always reference both the Specs and any documents placed in the Steering directory when operating. For existing projects, you can even ask the agent to generate an initial Steering file.

Once this setup is complete, you can instruct the AI agent to begin implementation. In tasks.md, you'll find sections marked with ⚡️Start task. Clicking these initiates the implementation for each task. Simply proceed by clicking through these sections, and the AI agent will handle the implementation process, ultimately completing your application.

Simply proceed by clicking through these sections, and the AI agent will handle the implementation process. This alone will complete your application.

However, since the primary model is Claude Sonnet, its coding capabilities can be limited, making it difficult to have it complete a complex implementation entirely on its own. Furthermore, during the preview period, the daily usage limits are quite strict, and you may reach your limit mid-task. Depending on the number and complexity of the tasks, completing the implementation could take anywhere from two to five days.

Other features include support for MCP servers and event-driven Agent Hooks, which can assist the AI agent in its operations.

Actual Implementation

Since it's quite straightforward, let's create a Spec for the classic game Tetris. To make it more interesting, we'll add these features:

Monominoes, dominoes, and triominoes (blocks of size 1, 2, and 3) will also fall.
Players can skip the next block. Skips are limited, but they regenerate when lines are cleared.

First, select the Spec mode as shown below.

Then, enter our requirements. Ideally, one might consult an LLM to flesh out preliminary specifications, but for this demonstration, we'll keep the prompt simple.

I want to create a Tetris game that runs in the browser. 
Please prepare a requirements document in Japanese.

(Since I am Japanese, I requested the documents in Japanese.)

After a brief pause, requirements.md is generated in a structured format based on the EARS (Easy Approach to Requirements Syntax) notation. The generated document seems to cover all the necessary requirements for Tetris.

Next, we'll enter the additional requirements. (In a real-world scenario, you would likely include these in the initial prompt.)

- Please add monominoes, dominoes, and triominoes as falling blocks.
- Implement a feature to skip blocks shown in the preview.
Specifications: Players can hold up to 4 skips, and clearing 2 lines regenerates 1 skip

After another brief pause, requirements.md is updated to reflect the additional requests. This time, some specifications were missing, so we'll request a correction.

Regarding triomino blocks, only L-shaped ones seem to be defined.
Please also add straight-line triomino blocks with three squares.

This time, the corrections were implemented properly. After confirming the changes, the design document, design.md, is generated.

While I have some minor concerns—for instance, I'd prefer not to use JavaScript classes, and I question if the algorithm is optimal—we won't proceed with the actual coding this time, so we'll accept it as is. If you have preferences for programming languages, technologies, libraries, or frameworks, you should specify them during this design phase.

Regarding rule settings and coding policies, I'm uncertain whether these should be specified here or in the Steering document—this requires further verification.

After confirming the design, the task list, tasks.md, is generated. I personally find the task granularity a bit coarse, but I decide to accept it for now, especially considering the daily usage limits.

Confirming these changes completes the process.

Actual Specs(written in Japanese)

The Emerging Trend of Spec-Driven Development

The influence of SDD is spreading to other tools, including Anthropic's Claude Code.

Using Kiro to create Specs and then requesting coding assistance from Claude Code (written in Japanese):
https://zenn.dev/ubie_dev/articles/kiro-claude-code
A method for enabling Claude Code itself to perform Spec-Driven Development (written in Japanese):
https://zenn.dev/gotalab/articles/3db0621ce3d6d2
claude-code-spec-workflow:
https://github.com/Pimzino/claude-code-spec-workflow

I've also come across articles experimenting with Spec-Driven Development using the Gemini CLI and Cursor. Cursor seems especially well-suited for this, as it allows users to explicitly instruct the agent to follow an SDD methodology.

Impressions and Summary

Regarding Kiro itself, while it made an impressive debut, its popularity seemed to wane over time. To be honest, the waiting list period was too long. Without a steady flow of new users, even Kiro's innovative Spec-Driven Development proved insufficient to maintain momentum.
If Kiro becomes accessible to everyone once the waiting list is cleared, it may once again become a hot topic.

The Spec-Driven Development approach that Kiro champions for AI coding undoubtedly has the potential to become a mainstream methodology. As AWS VP Marc Brooker noted in the Kiro development blog:

A specification is a kind of (version controlled, human-readable) super prompt.

"A comprehensive document that clearly outlines a project's objectives in human-readable form can simultaneously serve as both AI instruction and a long-term memory guideline, and of course it also helps humans later review the project."
This captures the essence of Spec-Driven Development.
Those who recognize and appreciate this core value - whether adopting it in forms distinct from Kiro's approach - may ultimately help establish SDD as the de facto standard in AI coding.