# Using Spec-Driven Development for Production Workflows

Erik Hanchett

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/IddXPepIAS4-using-spec-driven-development-production-workflows) · [Video](https://www.youtube.com/watch?v=IddXPepIAS4)

## Using Spec-Driven Development for Production Workflows

Write and review requirements, design, and implementation tasks before asking a coding agent to build, then turn the agreed behavior into tests.

Familiarity with coding assistants and Markdown is enough to follow the workflow; the final testing example uses TypeScript.

### Specifications before code

[0:11](https://www.youtube.com/watch?v=IddXPepIAS4&t=11s)

How do you get a coding assistant to produce better software, rather than simply produce code faster? **Spec-driven development puts reviewable specifications before implementation.** Requirements and design documents, written in Markdown, give the assistant an explicit description of what to build before it starts changing code. The intended benefit is both speed and quality; the workflow itself is the subject here, rather than a measured comparison of those outcomes.

![Presenter beside a Spec-Driven Development slide stating that structured specifications are created before any code is written.](https://ai.engineer/api/talk-essay-media/131f29e12c0daef55931860229814ea21fb9667d5bbf667d496055353ca8bc7c)

Spec-driven development creates structured specifications before code is written.

The difficulty is familiar to anyone who has managed an eager intern. Early in Erik Hanchett’s career, a VP would walk around suggesting ideas, and Hanchett would drop his assigned work to pursue them. His manager taught him a different sequence: record the request, put it into the schedule, and discuss it before acting. Coding assistants can show the same eagerness. A plausible new request becomes an implementation unless someone supplies the priorities and checkpoints that should come first.

Hanchett introduces himself as a senior developer advocate at AWS with more than 15 years of software development experience. His recommendation is to make that intervening process explicit for the agent: capture what is wanted, inspect the proposed approach, and only then authorize implementation.

### Give the agent enough context—and review what it does with it

[2:44](https://www.youtube.com/watch?v=IddXPepIAS4&t=164s)

Better frontier models do not remove the need to describe a changing project. Requirements, software conventions, and architectural choices keep moving; the model needs the current version of that context. Thinking and planning modes in agent harnesses can delay the jump into code, but Hanchett favors an additional checkpoint: actual documents that a developer can inspect and revise before implementation begins. He presents these recommendations as working judgments, not settled rules for every project.

![Presenter beside a purple slide asking whether the latest frontier models can do everything.](https://ai.engineer/api/talk-essay-media/dfcdc38062346d09194413d0c1b991212c228811863080c1f0caf340a171cc63)

“Can’t the latest frontier models do everything?”

More context is not automatically better. Files such as `AGENTS.md` and `CLAUDE.md`, or steering documents in [Kiro](https://kiro.dev/), should contain enough rules to orient the assistant without burying the task in instructions. Keep persistent project guidance focused, and bring specialized instructions into the workflow when they become relevant.

**Skills** provide that on-demand guidance. Hanchett describes them as instruction files activated by task cues or a slash command. More precisely, current [Kiro Agent Skills documentation](https://kiro.dev/docs/skills/) describes automatic activation through matching the request to a skill’s description, rather than a guaranteed literal keyword trigger. Skills can help while the assistant writes the design document and again while it implements individual tasks.

**The developer remains responsible for both the plan and the code.** Review requirements and design documents interactively, then review the generated implementation. That does not mean reviewing alone: other developers, coding assistants, and pull-request review tools can all help. Their assistance does not transfer responsibility for the result to the agent.

### The workflow does not depend on the editor

[6:20](https://www.youtube.com/watch?v=IddXPepIAS4&t=380s)

Kiro grew out of a pattern AWS teams saw among customers who were dissatisfied with their coding assistants’ output. Those customers were already asking agents to produce full requirements and design documents. Kiro turned that practice into a product workflow, with an IDE and a CLI. Its [general-availability announcement](https://kiro.dev/blog/general-availability/) is dated November 17, 2025, anchoring Hanchett’s reference to a release late in the preceding year.

The IDE exposes Vibe and Spec modes. Spec mode addresses the need to plan larger features and complex projects with a clearer understanding of the existing application. Hanchett describes increasing interest in the CLI as well. Hanchett reports tens of thousands of launch downloads. He also recalls a preview access gate introduced under heavy demand, users finding ways around it, and the later public availability of the IDE and CLI.

The same process can be performed manually with a coding assistant:

1. **Create requirements.** Ask the assistant to derive user requirements from the feature request, or supply an existing requirements document as its starting point.
2. **Review the requirements.** Work through omissions and misunderstandings before moving on.
3. **Create and review the design.** Ask how the accepted requirements will be implemented, then inspect that proposal.
4. **Generate implementation tasks.** Derive the task list from both the requirements and the design, so the work has a traceable basis.

[GitHub Spec Kit](https://github.com/github/spec-kit) is another way to organize this staged process across coding assistants. The essential mechanism is the sequence of artifacts and reviews, not a particular editor.

### Start with a feature, then refine the documents

[9:41](https://www.youtube.com/watch?v=IddXPepIAS4&t=581s)

In the recorded Kiro IDE, select Spec and enter a request—for example, a movie MCP server that tracks films you have watched, or a movie website. Hanchett calls the CLI entry point Plan mode and later refers to a quick plan mode. Those are the recording’s labels; [current Kiro Specs documentation](https://kiro.dev/docs/specs/) describes CLI specs and Quick Spec.

![Slide titled Ask it to begin! with the prompt “Build a Movie MCP server to keep track of movies I’ve watched” and an interface showing Vibe and highlighted Spec options.](https://ai.engineer/api/talk-essay-media/4f0b62570c0f41a9fbf09c3f1b4fb3ec662ac8fd17d70421af87ab5d844a8192)

A movie MCP server prompt alongside the highlighted Spec option.

A new movie application is an easy example, but specs also fit existing codebases. Hanchett has seen years-old applications containing dozens of spec files. He recommends the approach especially for in-depth features and complex projects that need upfront planning. Kiro also offers a bug-fix spec workflow, although he suggests a more direct vibe-coding interaction may be sufficient for small changes.

The requirements phase produces an introduction, user stories, and requirements in [EARS—Easy Approach to Requirements Syntax](https://alistairmavin.com/ears/). Structured requirements make the triggering situation and expected behavior easier to inspect than a broad feature request. Clarifying questions can come before document generation; the quick plan option described in the recording uses those answers to generate the documents together.

The next artifact is a higher-level design, potentially including Mermaid diagrams or ASCII diagrams. The order can vary: start with requirements, start with design, or combine the two documents where that makes sense. **Pause here to add project knowledge and implementation preferences.** A generated design becomes useful when someone who understands the application edits its assumptions and choices, rather than merely accepting a polished Markdown file.

### Make the first tasks deliver something working

[12:07](https://www.youtube.com/watch?v=IddXPepIAS4&t=727s)

Before generating implementation tasks, inspect the Markdown for inconsistencies, hallucinations, and errors. The resulting task list can include **property-based tests** derived from requirements and design: checks of behavior that should hold across different inputs. Hanchett recommends generating and running those tests as part of implementation.

He also asks the assistant to reorganize the beginning of the task list around a working MVP. His usual request is to put the top four tasks first and make them deliver that initial version. The purpose is to see the application working before proceeding through the rest of the plan. The useful constraint is a working slice of the product, not four arbitrary items checked off a list.

### Bring existing requirements into the spec

[12:55](https://www.youtube.com/watch?v=IddXPepIAS4&t=775s)

[Model Context Protocol](https://www.anthropic.com/news/model-context-protocol) connects AI applications to external data sources. Hanchett sketches a model-backed tool such as Kiro, an illustrative provider such as OpenAI or Anthropic, and MCP between the application and its sources. The workflow benefit is access to information the team has already written elsewhere.

Command-line tools can cover some of the same ground. Hanchett acknowledges that alternative while describing MCP, including its security work, as still maturing. For specification work, his concrete use case is pulling tickets and larger requirements documents from systems such as Jira or Asana. A product manager’s requirements can then inform the generated spec instead of being manually reconstructed in a new prompt.

The assistant still needs to know where to look. Put a rule in steering documents or `AGENTS.md` directing the specification workflow to the relevant MCP server, or explicitly request that source in the initial requirements prompt. This makes retrieval part of requirements creation, before the assistant turns incomplete context into a design and task list.

### Inside the movie-site specification

[14:45](https://www.youtube.com/watch?v=IddXPepIAS4&t=885s)

The IDE demonstration opens a prepared movie-database project rather than building a new application during the recording. Its starting request was “Please create me a movie website.” Hanchett deliberately chose the design-first path, then opened the rendered Markdown preview. The design includes architecture and sequence diagrams, and he describes iterating with the assistant to edit that design.

![IDE preview titled Design Document: Movie Database (80s Theme), showing Overview, an Architecture diagram, and the start of a Movie Browsing Flow sequence diagram.](https://ai.engineer/api/talk-essay-media/5f9fed6618520df7753c03fda1f3b28b12b8b6838ab82786cf163211a53e2410)

Rendered movie-database design document with architecture and sequence diagrams.

Further down the design document are property tests using [fast-check](https://fast-check.dev/docs/api/interfaces/Parameters/) in TypeScript and Node. Hanchett describes property tests running dozens or hundreds of times with different values. That repeated variation is how the tests probe whether a stated property survives more than a few handpicked examples; the recording does not establish the project’s configured run count or a passing test result.

The requirements document follows, again using EARS and user stories. The visible walkthrough reaches movie-data loading and a requirement triggered by application initialization, involving the filter engine. This gives the design and implementation a more specific target than simply making a movie website: startup behavior is expressed as something the application is required to do.

### From the MVP task list to a genre invariant

[16:29](https://www.youtube.com/watch?v=IddXPepIAS4&t=989s)

Hanchett then asks the assistant to reorganize the movie-site tasks around an MVP. The revised task list assigns tasks one through four to a browsable movie grid with search, genre filtering, sorting, and an ’80s synthwave theme. He says the requirements were revised around that goal and that he subsequently implemented all the tasks. The displayed list explains the intended first working version; his account supplies the implementation outcome.

The IDE also exposes property-test execution information and hover descriptions. The final example states a precise invariant: **for any movie dataset, the extracted genres must be exactly the sorted set of unique genres.** This combines three obligations: preserve every genre present in the input, remove duplicates, and return the result in sorted order.

For a concrete illustration, take two movie records with genres `['Drama', 'Comedy']` and `['Drama', 'Action']`. Extraction should produce `['Action', 'Comedy', 'Drama']` without changing either record. The following TypeScript expresses the operation and tests the same invariant across generated datasets:

```typescript
import assert from 'node:assert/strict';
import fc from 'fast-check';

type Movie = { genres: string[] };

function extractGenres(movies: Movie[]): string[] {
  return [...new Set(movies.flatMap(movie => movie.genres))].sort();
}

const movies: Movie[] = [
  { genres: ['Drama', 'Comedy'] },
  { genres: ['Drama', 'Action'] },
];

assert.deepEqual(extractGenres(movies), ['Action', 'Comedy', 'Drama']);

const movieArbitrary = fc.record({
  genres: fc.array(fc.string()),
});

fc.assert(
  fc.property(fc.array(movieArbitrary), dataset => {
    const before = structuredClone(dataset);
    const result = extractGenres(dataset);
    const inputGenres = dataset.flatMap(movie => movie.genres);

    assert.deepEqual(new Set(result), new Set(inputGenres));
    assert.equal(result.length, new Set(result).size);
    assert.deepEqual(result, [...result].sort());
    assert.deepEqual(dataset, before);
  }),
);
```

The set comparison checks membership, the length check rules out duplicates, and the sorted-copy comparison checks ordering. Input preservation is an additional check in this illustration. The movie example ends with a specification that can be challenged by tests: an exact relationship between input records and output genres, rather than an impression that filtering looks right.

## Resources

- [Kiro](https://kiro.dev/) — Official product site with downloads and documentation for Kiro.
- [GitHub Spec Kit](https://github.com/github/spec-kit) — Open-source toolkit for turning specifications into implementation plans and tasks across coding assistants.
- [Kiro Specs documentation](https://kiro.dev/docs/specs/) — Current guide to specification artifacts, feature and bugfix workflows, and task execution.
- [EARS: the creator's guide](https://alistairmavin.com/ears/) — Alistair Mavin explains structured requirement patterns for events, states, optional features and unwanted behavior.
- [fast-check run configuration](https://fast-check.dev/docs/api/interfaces/Parameters/) — Reference for property-test run counts, random seeds, counterexample replay and execution limits.
- [Kiro Agent Skills](https://kiro.dev/docs/skills/) — How to package reusable instructions and invoke them automatically or through slash commands.
- [Introducing the Model Context Protocol](https://www.anthropic.com/news/model-context-protocol) — The original announcement explains MCP's purpose and client-server approach to connecting assistants with external systems.
- [Kiro's general-availability announcement](https://kiro.dev/blog/general-availability/) — The November 2025 announcement introducing general availability, Kiro CLI and property-based testing.

## Slides

### Movie database design document

In Kiro’s Spec mode, the presenter starts a movie website with a design document. Its Markdown outlines the application components, a local JSON data layer, and an 80s-themed styling layer.

[14:47](https://www.youtube.com/watch?v=IddXPepIAS4&t=887s) [Kiro displays the movie database design document in Markdown, including its overview and architecture outline.](https://assets.ai.engineer/sites/aiecode2025/sha256/aaa6083f119387667f2bc7488b03fee79c6340f0aaa9bf2cf3a666d80ed8e7b7.webp)

# Design Document: Movie Database (80s Theme)

## Overview

A retro-styled movie database application built with Nuxt 4 and Tailwind CSS v4, featuring a synthwave/80s aesthetic. Users can browse, search, and view details about movies with an immersive neon-lit, retro-futuristic visual experience reminiscent of 1980s pop culture.

The application uses a client-side data layer with a local JSON dataset of movies, providing fast filtering, searching, and sorting without requiring an external API. The 80s theme is expressed through neon color palettes (hot pink, electric blue, purple), retro typography, grid-line backgrounds, and glowing UI elements inspired by synthwave art.

## Architecture

```mermaid
graph TD
    subgraph "Nuxt 4 Application"
        A[app.vue - Layout Shell] --> B[pages/index.vue - Movie Grid]
        A --> C[pages/movies/_id_.vue - Movie Detail]
        B --> D[components/MovieCard.vue]
        B --> E[components/SearchBar.vue]
        B --> F[components/GenreFilter.vue]
        C --> G[components/MovieDetail.vue]
        A --> H[components/AppHeader.vue]
        A --> I[components/AppFooter.vue]
    end

    subgraph "Data Layer"
        J[composables/useMovies.ts] --> K[data/movies.json]
        J --> L[composables/useSearch.ts]
        J --> M[composables/useFilters.ts]
    end

    subgraph "Styling Layer"
        N[assets/css/main.css - Tailwind + 80s Theme]
        O[assets/css/animations.css - Neon [illegible]
    end

Interface text:
SPEC-DRIVEN DEVELOPMENT — AIE WORLD'S FAIR · SF
design.md — stirtrek
.kiro/specs/mo...
.config.kiro
design.md 9+
requirements.md
tasks.md M
.nuxt
.output
app
assets
components
composables
pages
types
app.vue
data
node_modules
public
server
tests
.env
.env.example
.gitignore
nuxt.config.ts
package-lock.json
package.json
README.md
tsconfig.json
vitest.config.ts
movie-database
1 Design
2 Requirements
3 Task list
Sync Files
Continue
New Session
Let's build
Plan, search, or build anything
Vibe
Chat first, then build. Explore ideas and iterate as you discover needs.
Spec
Plan first, then build. Create requirements and design before coding starts.
Great for:
• Thinking through features in-depth
• Projects needing upfront planning
• Building features in a structured way
Open Preview
Ask a question or describe a task...
Claude Opus 4.6
Autopilot

### Design document preview

The design uses a local JSON movie dataset for client-side search, filtering and sorting without an external API. The presenter previews its architecture and browsing flow after iterating on the generated document.

[15:20](https://www.youtube.com/watch?v=IddXPepIAS4&t=920s) [Rendered movie database design document with an overview, architecture diagram, and beginning of a sequence diagram.](https://assets.ai.engineer/sites/aiecode2025/sha256/d3adf95c0500399380f59d07a7bfa794c0e608251f252001ef8b8001f059b267.webp)

Design Document: Movie Database (80s Theme)

Overview

A retro-styled movie database application built with Nuxt 4 and Tailwind CSS v4, featuring a synthwave/80s aesthetic. Users can browse, search, and view details about movies with an immersive neon-lit, retro-futuristic visual experience reminiscent of 1980s pop culture.

The application uses a client-side data layer with a local JSON dataset of movies, providing fast filtering, searching, and sorting without requiring an external API. The 80s theme is expressed through neon color palettes (hot pink, electric blue, purple), retro typography, grid-line backgrounds, and glowing UI elements inspired by synthwave art.

Architecture

Nuxt 4 Application
app.vue - Layout Shell
[diagram labels illegible]
Data Layer
[diagram labels illegible]
Styling Layer
[diagram labels illegible]

Sequence Diagrams

Movie Browsing Flow
User
pages/index.vue
useMovies()
useFilters()
movies.json
Navigate to home

Interface text:
SPEC-DRIVEN DEVELOPMENT — AIE WORLD'S FAIR · SF
Preview design.md — stirtrek
design.md
Preview design.md
New Session
.kiro/specs/mo...
.config.kiro
design.md
requirements.md
tasks.md M
.nuxt
.output
app
assets
components
composables
pages
types
app.vue
data
node_modules
public
server
tests
.env
.env.example
.gitignore
nuxt.config.ts
package-lock.json
package.json
README.md
tsconfig.json
vitest.config.ts
Let's build
Plan, search, or build anything
Vibe
Chat first, then build. Explore ideas and iterate as you discover needs.
Spec
Plan first, then build. Create requirements and design before coding starts.
Great for:
• Thinking through features in-depth
• Projects needing upfront planning
• Building features in a structured way
Ask a question or describe a task...
Claude Opus 4.6
Autopilot

### Movie browsing and detail flows

The design preview traces search and genre filtering back to grid updates, then shows a movie card click triggering an ID lookup. The speaker says they iterated on the generated Mermaid diagrams.

[15:34](https://www.youtube.com/watch?v=IddXPepIAS4&t=934s) [Design preview showing portions of sequence diagrams for movie browsing and movie details.](https://assets.ai.engineer/sites/aiecode2025/sha256/218ca9aea1a68dc7fd0f8085b84ce4bcaecafce2b312675f7a2ada9da5e03e2d.webp)

search(query)
Filter by title/description
Filtered Movie[]
Update grid with results
Select genre filter
setGenre(genre)
applyFilters()
Filtered Movie[]
Update grid with filtered results

User
pages/index.vue
useMovies()
useFilters()
movies.json

Movie Detail Flow

User
pages/movies/[id].vue
useMovies()
movies.json

Click movie card
getMovieById(id)
Lookup by ID
Movie | undefined
Movie data

Interface text:
SPEC-DRIVEN DEVELOPMENT — AIE WORLD'S FAIR · SF
Preview design.md — stirtrek
design.md
Preview design.md
New Session
.kiro/specs/mo...
.config.kiro
design.md
requirements.md
tasks.md M
.nuxt
.output
app
assets
components
composables
pages
types
app.vue
data
node_modules
public
server
tests
.env
.env.example
.gitignore
nuxt.config.ts
package-lock.json
package.json
README.md
tsconfig.json
vitest.config.ts

Let's build
Plan, search, or build anything
Vibe
Chat first, then build. Explore ideas and iterate as you discover needs.
Spec
Plan first, then build. Create requirements and design before coding starts.
Great for:
• Thinking through features in-depth
• Projects needing upfront planning
• Building features in a structured way
Ask a question or describe a task...
Claude Opus 4.6
Autopilot

### Movie database requirements

The requirements document defines the movie database’s components and startup behavior: when the application initializes, the filter engine loads the local dataset into the reactive movie list.

[16:05](https://www.youtube.com/watch?v=IddXPepIAS4&t=965s) [Kiro displays the requirements document source, including its introduction, glossary, and movie data loading requirement.](https://assets.ai.engineer/sites/aiecode2025/sha256/b3f2c74298754822fa7c34af783cf823849f3f2f526e883461a22eaf681e9c3e.webp)

Requirements Document

Introduction

This document defines the requirements for a retro-styled movie database application built with Nuxt 4 and Tailwind CSS v4. The application allows users to browse, search, filter, and view details about movies, all presented with an immersive 80s synthwave aesthetic featuring neon colors, glow effects, and retro typography. The data layer is entirely client-side, using a local JSON dataset for fast filtering, searching, and sorting without an external API.

Glossary

- Application: The Nuxt 4 movie database web application
- Movie_Grid: The main page layout displaying movies as a responsive grid of MovieCard components
- MovieCard: A UI component that displays a single movie's poster, title, year, and rating in the browsing grid
- SearchBar: A text input component for entering search queries to filter movies
- GenreFilter: A UI component displaying genre chips/buttons for filtering movies by genre
- MovieDetail: A full-page component displaying all information about a single movie
- AppHeader: The top navigation bar component with the application title and navigation links
- AppFooter: The bottom footer component for the application
- Filter_Engine: The composable logic (useMovies, useSearch, useFilters) responsible for filtering, searching, and sorting the movie dataset
- Movie_Dataset: The local JSON file containing the complete collection of movie records
- Movie: A data record with id, title, year, genre, rating, director, cast, plot, poster, and runtime fields
- FilterState: The current combination of search query, selected genre, sort field, and sort order
- Neon_Theme: The 80s synthwave visual design system using neon pink (#FF2D95), electric blue (#00F0FF), neon purple (#B026FF), dark backgrounds, glow effects, and retro typography

Requirements

Requirement 1: Movie Data Loading

User Story: As a user, I want the application to load the movie dataset on startup, so that I can immediately browse available movies.

Acceptance Criteria

1. WHEN the Application initializes, THE [illegible] the Movie_Dataset from the local JSON file and populate the reactive movie list
2. WHILE the Movie_Dataset is loading, THE Application SHALL display a loading indicator styled with the Neon_Theme

Interface text:
SPEC-DRIVEN DEVELOPMENT — AIE WORLD'S FAIR · SF
requirements.md — stirtrek
requirements.md
Preview requirements.md
movie-database
1 Design
2 Requirements
3 Task list
Sync Files
Continue
.kiro/specs/mo...
.config.kiro
design.md
requirements.md
tasks.md M
.nuxt
.output
app
assets
components
composables
pages
types
app.vue
data
node_modules
public
server
tests
.env
.env.example
.gitignore
nuxt.config.ts
package-lock.json
package.json
README.md
tsconfig.json
vitest.config.ts
New Session
Let's build
Plan, search, or build anything
Vibe
Chat first, then build. Explore ideas and iterate as you discover needs.
Spec
Plan first, then build. Create requirements and design before coding starts.
Great for:
- Thinking through features in-depth
- Projects needing upfront planning
- Building features in a structured way
Open Preview
Ask a question or describe a task...
Claude Opus 4.6
Autopilot

### Movie database requirements

The presenter opens the requirements preview. On startup, the specified filter engine loads a local JSON dataset into the reactive movie list.

[16:12](https://www.youtube.com/watch?v=IddXPepIAS4&t=972s) [Requirements source shows the glossary and the beginning of movie data loading acceptance criteria.](https://assets.ai.engineer/sites/aiecode2025/sha256/5c1d099ec65bd6dfa972693da64614b7f8ebc73b98beeefd71fb07f34b6b62fe.webp)

Requirements Document

Introduction
[illegible] CSS v4. The application allows users to browse, search, filter, and view details about movies, all presented with an immersive 80s synthwave aesthetic featuring neon colors, glow effects, and retro typography. The data layer is entirely client-side, using a local JSON dataset for fast filtering, searching, and sorting without an external API.

Glossary
- Application: The Nuxt 4 movie database web application
- Movie_Grid: The main page layout displaying movies as a responsive grid of MovieCard components
- MovieCard: A UI component that displays a single movie's poster, title, year, and rating in the browsing grid
- SearchBar: A text input component for entering search queries to filter movies
- GenreFilter: A UI component displaying genre chips/buttons for filtering movies by genre
- MovieDetail: A full-page component displaying all information about a single movie
- AppHeader: The top navigation bar component with the application title and navigation links
- AppFooter: The bottom footer component for the application
- Filter_Engine: The composable logic (useMovies, useSearch, useFilters) responsible for filtering, searching, and sorting the movie dataset
- Movie_Dataset: The local JSON file containing the complete collection of movie records
- Movie: A data record with id, title, year, genre, rating, director, cast, plot, poster, and runtime fields
- FilterState: The current combination of search query, selected genre, sort field, and sort order
- Neon_Theme: The 80s synthwave visual design system using neon pink (#FF2D95), electric blue (#00F0FF), neon purple (#B026FF), dark backgrounds, glow effects, and retro typography

Requirements

Requirement 1: Movie Data Loading

User Story: As a user, I want the application to load the movie dataset on startup, so that I can immediately browse available movies.

Acceptance Criteria
1. WHEN the Application initializes, THE Filter_Engine SHALL load the Movie_Dataset from the local JSON file and populate the reactive movie list
2. WHILE the Movie_Dataset is loading, THE Application SHALL display a loading indicator styled with the Neon_Theme
3. WHEN the Movie_Dataset has loaded succ[illegible] SHALL render the Movie_Grid with all movies displayed
4. IF the Movie_Dataset fails to load, THEN THE Application SHALL display an error message styled with the [cut off]

Interface text:
SPEC-DRIVEN DEVELOPMENT — AIE WORLD'S FAIR · SF
requirements.md — stirtrek
requirements.md; Preview requirements.md
movie-database; 1 Design; 2 Requirements; 3 Task list; Sync Files; Continue
.kiro/specs/mo...; .config.kiro; design.md; requirements.md; tasks.md; .nuxt; .output; app; assets; components; composables; pages; types; app.vue; data; node_modules; public; server; tests; .env; .env.example; .gitignore; nuxt.config.ts; package-lock.json; package.json; README.md; tsconfig.json; vitest.config.ts
New Session
Let's build
Plan, search, or build anything
Vibe: Chat first, then build. Explore ideas and iterate as you discover needs.
Spec: Plan first, then build. Create requirements and design before coding starts.
Great for:
- Thinking through features in-depth
- Projects needing upfront planning
- Building features in a structured way
Open Preview
Ask a question or describe a task...
Claude Opus 4.6; Autopilot

[16:15](https://www.youtube.com/watch?v=IddXPepIAS4&t=975s) [Kiro displays a requirements document for a retro-styled movie database.](https://assets.ai.engineer/sites/aiecode2025/sha256/e1da991078c7ab71c1cecf1db19a80a850b27365e5363e7bb22985a460b2ebc7.webp)

Requirements Document

Introduction
This document defines the requirements for a retro-styled movie database application built with Nuxt 4 and Tailwind CSS v4. The application allows users to browse, search, filter, and view details about movies, all presented with an immersive 80s synthwave aesthetic featuring neon colors, glow effects, and retro typography. The data layer is entirely client-side, using a local JSON dataset for fast filtering, searching, and sorting without an external API.

Glossary
- Application: The Nuxt 4 movie database web application
- Movie_Grid: The main page layout displaying movies as a responsive grid of MovieCard components
- MovieCard: A UI component that displays a single movie's poster, title, year, and rating in the browsing grid
- SearchBar: A text input component for entering search queries to filter movies
- GenreFilter: A UI component displaying genre chips/buttons for filtering movies by genre
- MovieDetail: A full-page component displaying all information about a single movie
- AppHeader: The top navigation bar component with the application title and navigation links
- AppFooter: The bottom footer component for the application
- Filter_Engine: The composable logic (useMovies, useSearch, useFilters) responsible for filtering, searching, and sorting the movie dataset
- Movie_Dataset: The local JSON file containing the complete collection of movie records
- Movie: A data record with id, title, year, genre, rating, director, cast, plot, poster, and runtime fields
- FilterState: The current combination of search query, selected genre, sort field, and sort order
- Neon_Theme: The 80s synthwave visual design system using neon pink (#FF2D95), electric blue (#00F0FF), neon purple (#B026FF), dark backgrounds, glow effects, and retro typography

Requirements

Requirement 1: Movie Data Loading

Interface text:
SPEC-DRIVEN DEVELOPMENT — AIE WORLD'S FAIR · SF
Preview requirements.md — stirtrek
requirements.md; Preview requirements.md
.kiro/specs/mo...; .config.kiro; design.md; requirements.md; tasks.md; .nuxt; .output; app; assets; components; composables; pages; types; app.vue; data; node_modules; public; server; tests; .env; .env.example; .gitignore; nuxt.config.ts; package-lock.json; package.json; README.md; tsconfig.json; vitest.config.ts
New Session
Let's build
Plan, search, or build anything
Vibe: Chat first, then build. Explore ideas and iterate as you discover needs.
Spec: Plan first, then build. Create requirements and design before coding starts.
Great for:
- Thinking through features in-depth
- Projects needing upfront planning
- Building features in a structured way
Ask a question or describe a task...
Claude Opus 4.6; Autopilot

### Movie database implementation plan

After the presenter asked for an MVP, the task list grouped search, filtering, sorting, and the synthwave theme into tasks 1–4. The visible data-layer tasks are marked completed.

[16:33](https://www.youtube.com/watch?v=IddXPepIAS4&t=993s) [Kiro shows the implementation plan and completed data-layer tasks.](https://assets.ai.engineer/sites/aiecode2025/sha256/be8542fc4d4bcd74e26f77624347ffa8e4877dd1f17a44535000ca141cc13c86.webp)

# Implementation Plan: Movie Database (80s Theme)

## Overview

Build a retro-styled movie database application using the existing Nuxt 4 + Tailwind CSS v4 scaffold. Tasks 1–4 deliver a working MVP: browsable movie grid with search, genre filtering, sorting, and the full 80s synthwave theme. Tasks 5+ add the movie detail page, property-based tests, and final verification. All code is TypeScript. Property-based tests use fast-check with Vitest.

## Tasks

Task completed | View changes | View execution
- [x] 1. Data layer, types, and core composables

Task completed | View changes | View execution
- [x] 1.1 Create the Movie type interface and FilterState types in `app/types/movie.ts`
  - Define `Movie`, `FilterState`, and `AppState` interfaces per the design data models
  - Include JSDoc comments for validation rules (year range, rating range, etc.)
  - _Requirements: 2.1, 2.2, 2.3, 2.4, 2.5, 2.6_

Task completed | View changes | View execution
- [x] 1.2 Create the movie dataset JSON file at `data/movies.json`
  - Populate with at least 12 movies spanning multiple genres, years, and ratings
  - Each record must conform to the Movie interface schema
  - Include a variety of genres to exercise genre filtering (at least 5 distinct genres)
  - Use placeholder poster paths (e.g., `/posters/movie-id.jpg`) or public domain image URLs
  - _Requirements: 1.1, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6_

Task completed | View changes | View execution
- [x] 1.3 Create `app/composables/useSearch.ts`
  - Implement debounced search with configurable delay (default 300ms)
  - Expose `query` and `debouncedQuery` refs
  - _Requirements: 3.3_

Task completed | View changes | View execution
- [x] 1.4 Create `app/composables/useMovies.ts` with `filterMovies`, `extractGenres`, and the full `useMovies` composable
  - Implement the filtering algorithm: search filter → genre filter → sort
  - Search matches case-insensitively against title, plot, and director
  - Genre filter checks if movie's genre array includes the selected genre
  - Sort by title, year, or rating in ascending or descending order

Interface text:
SPEC-DRIVEN DEVELOPMENT — AIE WORLD'S FAIR · SF
tasks.md — stirtrek
tasks.md M
Preview tasks.md
movie-database
1 Design > 2 Requirements > 3 Task list
Sync Files
Run all tasks
.kiro/specs/mo...
.config.kiro
design.md
requirements.md
tasks.md M
.nuxt
.output
app
assets
components
composables
pages
types
app.vue
data
node_modules
public
server
tests
.env
.env.example
.gitignore
nuxt.config.ts
package-lock.json
package.json
README.md
tsconfig.json
vitest.config.ts
New Session
Let's build
Plan, search, or build anything
Vibe
Chat first, then build. Explore ideas and iterate as you discover needs.
Spec
Plan first, then build. Create requirements and design before coding starts.
Great for:
• Thinking through features in-depth
• Projects needing upfront planning
• Building features in a structured way
Ask a question or describe a task...
Claude Opus 4.6
Autopilot

### Property-based testing tasks

The movie database plan shows completed property-based testing tasks for data validation, search, and genre filtering. Each task has links to inspect its changes and execution.

[17:01](https://www.youtube.com/watch?v=IddXPepIAS4&t=1021s) [Kiro shows completed movie schema, search, and genre-filter test tasks.](https://assets.ai.engineer/sites/aiecode2025/sha256/5d26738a90bae4fe0b9b64b63738b2948c1b2483db7a364f026804f1f90e2a3e.webp)

SPEC-DRIVEN DEVELOPMENT — AIE WORLD'S FAIR · SF

Implementation Plan: Movie Database (80s Theme)

Tasks
- Requirements: 7.2, 7.3, 11.2

Task completed | View changes | View execution
- [x] 7.2 Create `app/pages/movies/[id].vue` — Movie Detail page
  - Use useMovies composable to look up movie by route param id
  - Render MovieDetail component with full movie information
  - Display "Movie not found" message with link home if id is invalid
  - Requirements: 7.1, 7.2, 7.3, 7.4

Task completed | View changes | View execution
- [x] 8. Property-based tests

Task completed | View changes | View execution
- [x] 8.1 Set up Vitest + fast-check testing infrastructure
  - Install vitest, fast-check, @vue/test-utils as dev dependencies
  - Create vitest config if needed

Task completed | View changes | View execution
- [x] 8.2 Write property tests for movie data validation
  - Property 1: Movie Schema Validation — For any Movie record, validate id is non-empty unique string, year is 1900–current year, rating is 0–10, genre has at least one element, title is non-empty, runtime is a positive integer
  - Validates: Requirements 2.1, 2.2, 2.3, 2.4, 2.5, 2.6
  - Test file: `tests/properties/movie-schema.test.ts`

Task completed | View changes | View execution
- [x] 8.3 Write property tests for search precision and completeness
  - Property 2: Search Precision — For any search query and movie list, every movie in filtered results has the query as a case-insensitive substring of title, plot, or director
  - Property 3: Search Completeness — For any search query and movie list, every movie matching the query appears in filtered results
  - Validates: Requirements 3.1, 3.5
  - Test file: `tests/properties/search.test.ts`

Task completed | View changes | View execution
- [x] 8.4 Write property tests for genre filtering
  - Property 4: Genre Extraction Exhaustiveness — Extracted genres equal the sorted unique set of all genres in the dataset
  - Property 5: Genre Filter Precision — Every movie in filtered results contains the selected genre
  - Property 6: Genre Filter Completeness — Every movie containing the selected genre appears in filtered [cut off]

Interface text:
tasks.md — stirtrek
tasks.md M
Preview tasks.md
movie-database
1 Design > 2 Requirements > 3 Task list
Sync Files
Run all tasks
.kiro/specs/mo...
.config.kiro
design.md
requirements.md
tasks.md M
.nuxt
.output
app
assets
components
composables
pages
types
app.vue
data
node_modules
public
server
tests
.env
.env.example
.gitignore
nuxt.config.ts
package-lock.json
package.json
README.md
tsconfig.json
vitest.config.ts
New Session
Let's build
Plan, search, or build anything
Vibe
Chat first, then build. Explore ideas and iterate as you discover needs.
Spec
Plan first, then build. Create requirements and design before coding starts.
Great for:
- Thinking through features in-depth
- Projects needing upfront planning
- Building features in a structured way
Ask a question or describe a task...
Claude Opus 4.6
Autopilot

### Genre-filter property test result

Hovering over the genre-filter task opens its test details: extracted genres must equal the sorted set of unique genres in the dataset. The popup reports that all property checks passed.

[17:10](https://www.youtube.com/watch?v=IddXPepIAS4&t=1030s) [A property-based test popup reports that genre extraction checks passed.](https://assets.ai.engineer/sites/aiecode2025/sha256/806bc0dc683fb6641481f9402e7215009228f3d61da42789cfb3913a3af1e4cc.webp)

# Implementation Plan: Movie Database (80s Theme)
## Tasks

Property-Based Test
Task: 8.4 Write property tests for genre filtering
Property: For any movie dataset, the extracted genres list must contain exactly the sorted set of all unique genre strings that appear in at least one movie's genre array.
Status: Passed
Test Result: All property checks passed successfully

- [x] 8.4 Write property tests for genre filtering
  - **Property 4: Genre Extraction Exhaustiveness** — Extracted genres equal the sorted unique set of all genres in the dataset
  - **Property 5: Genre Filter Precision** — Every movie in filtered results contains the selected genre
  - **Property 6: Genre Filter Completeness** — Every movie containing the selected genre appears in filtered results
  - **Validates: Requirements 4.1, 4.2, 4.5**
  - Test file: `tests/properties/genre-filter.test.ts`

Task completed | View changes | View execution
- [x] 8.5 Write property tests for sorting
  - **Property 7: Sort Ordering** — Adjacent pairs in sorted results satisfy the comparator for the chosen field and order
  - **Property 8: Sort Stability** — Movies with equal sort values preserve their original relative order
  - **Validates: Requirements 5.3, 5.4**
  - Test file: `tests/properties/sorting.test.ts`

Task completed | View changes | View execution
- [x] 8.6 Write property tests for combined filtering invariants
  - **Property 9: Filter Commutativity** — Applying search then genre filter produces the same result as genre then search
  - **Property 10: No Data Mutation** — Original movie array is unchanged after filtering
  - **Validates: Requirements 6.2, 6.4**
  - Test file: `tests/properties/combined-filters.test.ts`

Interface text:
SPEC-DRIVEN DEVELOPMENT — AIE WORLD'S FAIR · SF
tasks.md — stirtrek
Preview tasks.md | tasks.md M
movie-database | 1 Design | 2 Requirements | 3 Task list | Sync Files | Run all tasks
.kiro/specs/mo...
.config.kiro
design.md
requirements.md
tasks.md M
.nuxt
.output
app
  assets
  components
  composables
  pages
  types
  app.vue
data
node_modules
public
server
tests
.env
.env.example
.gitignore
nuxt.config.ts
package-lock.json
package.json
README.md
tsconfig.json
vitest.config.ts
New Session
Let's build
Plan, search, or build anything
Vibe
Chat first, then build. Explore ideas and iterate as you discover needs.
Spec
Plan first, then build. Create requirements and design before coding starts.
Great for:
• Thinking through features in-depth
• Projects needing upfront planning
• Building features in a structured way
Ask a question or describe a task...
Claude Opus 4.6 | Autopilot

### How to learn more

Explore Kiro on its website or join the community Discord.

[17:27](https://www.youtube.com/watch?v=IddXPepIAS4&t=1047s) [A closing slide lists the Kiro website and community Discord.](https://assets.ai.engineer/sites/aiecode2025/sha256/3052717e5a9931eb7e83f0230a52d9f058533a4c9b7f11d7d8a098e7f8a6e4f9.webp)

How to learn more!

• https://kiro.dev

https://discord.gg/kirodotdev

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Thanks!

Erik invites viewers to connect on LinkedIn, Bluesky, or X. A QR code appears beside the contact details.

[17:35](https://www.youtube.com/watch?v=IddXPepIAS4&t=1055s) [Closing thank-you slide with social contact information and a QR code.](https://assets.ai.engineer/sites/aiecode2025/sha256/f30b9eb8965e02c849800f132a8096d937c4d615ad4151202d99b942b2736acd.webp)

Thanks!

• LinkedIn: [redacted]
• X/Bluesky: [redacted]

## Full transcript

[0:00](https://www.youtube.com/watch?v=IddXPepIAS4&t=0s) Hey everyone, my name is [REDACTED:username], and today I want to tell you guys all about spec-driven development and how you might use it in your workflows today. So there's a couple of things we want to talk about.

[0:11](https://www.youtube.com/watch?v=IddXPepIAS4&t=11s) First, what is spec-driven development? And then how can it make you a better and faster coder? So we just don't want you to code faster, but we want you to actually create higher quality code from it.

[0:25](https://www.youtube.com/watch?v=IddXPepIAS4&t=25s) And I think really spec-driven development helps you with this, and I'm going to explain why and how. It's a structured-- specifications are created before any code is written. That's the definition of really the specs or the requirements of this spec-driven development, and it goes to the heart of what it is.

[0:43](https://www.youtube.com/watch?v=IddXPepIAS4&t=43s) So what we're doing is we are writing these Markdown files. We're writing the specifications and the design document before any of the code is written. And this actually works really, really well with large language models and our coding assistants that we use.

[0:59](https://www.youtube.com/watch?v=IddXPepIAS4&t=59s) And I'm going to show you exactly how that works.

[1:03](https://www.youtube.com/watch?v=IddXPepIAS4&t=63s) Now, a question I sometimes get is why? Like, why should we use this spec-driven development workflow? And then how can we do it? So to answer that why question, I kind of like to think about our coding assistants, our large language models that we're using every day as sort of like AI interns.

[1:23](https://www.youtube.com/watch?v=IddXPepIAS4&t=83s) You need to really prompt them. You really need to push them the right way, no pun intended with the prompting. So you really need to guide them because if you give them just a little bit of, of leeway, they will go off the rails.

[1:37](https://www.youtube.com/watch?v=IddXPepIAS4&t=97s) And really, the spec-driven development helps guide them in the right direction. I remember when I was an intern in one of my first jobs, we had a VP that would walk around, and he would just come up with random ideas off the top of his head.

[1:50](https://www.youtube.com/watch?v=IddXPepIAS4&t=110s) And when he told me it, I would drop everything and work on it. And then later my boss would be like, "Hey, Erik, why did you drop everything?" "Well, the, the VP said something."

[2:00](https://www.youtube.com/watch?v=IddXPepIAS4&t=120s) And then I learned about, well, you got to take his information that he gives you, write it down, put it in your schedule, talk to me-- talk to my manager about it.

[2:09](https://www.youtube.com/watch?v=IddXPepIAS4&t=129s) So I was a little too eager. And this is what AI, uh, interns or basically these large language models do nowadays, and we got to be careful about it.

[2:18](https://www.youtube.com/watch?v=IddXPepIAS4&t=138s) I didn't really give you too much of introduction, so I'll give it to you now. My name is [REDACTED:username]. I'm a senior developer advocate at AWS. I have over fifteen plus years of software development experience.

[2:31](https://www.youtube.com/watch?v=IddXPepIAS4&t=151s) Uh, and if you want to connect with me, you can check out LinkedIn. That's probably the best place to go. Uh, just look for [REDACTED:username] and, uh, yeah, talk to me, follow me.

[2:41](https://www.youtube.com/watch?v=IddXPepIAS4&t=161s) I'd love to talk to you more about it.

[2:44](https://www.youtube.com/watch?v=IddXPepIAS4&t=164s) Another question when I-- that people often ask me a-about spec-driven development is: Can't the latest frontier models just do everything for us already? Why do we need this? And while I do say that the models are getting better and better every year and, and every release, sometimes incrementally, sometimes by leaps and bounds, it's still not perfect.

[3:05](https://www.youtube.com/watch?v=IddXPepIAS4&t=185s) And giving the large language model, these models more context is actually really important because it does help guide it in the right direction. And with our software com-- always changing and with the requirements always changing, uh, and with new paradigms and shifts, you always need to kind of guide it where it needs to go.

[3:23](https://www.youtube.com/watch?v=IddXPepIAS4&t=203s) Some large language models, some harnesses are starting to think more about this and adding in a little bit more of a thinking or planning mode before it jumps into when it writes code.

[3:34](https://www.youtube.com/watch?v=IddXPepIAS4&t=214s) But there's nothing better than actually having those documents created and having you be in the middle before it jumps into the n- that next part with it creating code.

[3:46](https://www.youtube.com/watch?v=IddXPepIAS4&t=226s) So let's keep a few things in mind before we get too far. There is quite a lot of information out there. I have some opinions. These are my opinions.

[3:56](https://www.youtube.com/watch?v=IddXPepIAS4&t=236s) Uh, let me know. Connect with me on LinkedIn if you agree or disagree, but I think you need to keep these in mind before using spec-driven development or vibe coding or anything in between.

[4:06](https://www.youtube.com/watch?v=IddXPepIAS4&t=246s) We have to-- You have to be careful with context. Now, I told you before that spec-driven development gives you a lot of context that gets fed into that large language model, but sometimes you have too much of a good thing.

[4:17](https://www.youtube.com/watch?v=IddXPepIAS4&t=257s) Uh, what you need to do is when you are working with these large language models, usually you create like an AGENTS.md or CLAUDE.md at the beginning with some information in it.

[4:28](https://www.youtube.com/watch?v=IddXPepIAS4&t=268s) I would be very careful not to put too much information or too little information in that. Kind of like that Goldilocks zone of information is what you need. So you just need to give it enough rules and guidelines that it knows what to do.

[4:41](https://www.youtube.com/watch?v=IddXPepIAS4&t=281s) Uh, we call it steering docs in Kiro, which I'll mention about in a minute, but you just got to be very careful what you put in those documents. I also highly recommend when you're using spec-driven development to use skills.

[4:54](https://www.youtube.com/watch?v=IddXPepIAS4&t=294s) Skills are like instruction files that you can give to your coding agents that are ran on demand. So usually they have keywords in them, and when the coding assistant sees those keywords, they'll activate the skill, or you can do slash and the skill name and then run it.

[5:10](https://www.youtube.com/watch?v=IddXPepIAS4&t=310s) But this actually really helps when you're doing the spec-driven development process. You can actually add skills, um, when it creates your design documents or whatever else. You can use those in parallel or with the spec-driven development or when you actually implement the tasks.

[5:26](https://www.youtube.com/watch?v=IddXPepIAS4&t=326s) And just be careful about giving too much trust. Uh, remember everything in the spec-driven development flow is you, meaning that you are the human in the loop, so to speak.

[5:38](https://www.youtube.com/watch?v=IddXPepIAS4&t=338s) You need to be the code reviewer of all the code that's generated through this process. You need to be interactively looking at the design documents and the requirements documents that are created because at the end of the day, if something goes wrong, you are the person that are going to be blamed for it, not the agent.

[5:59](https://www.youtube.com/watch?v=IddXPepIAS4&t=359s) And, uh, that's not to say that we don't use tools to help do code reviews. Someone once told me like, "Are you saying you're the human in the loop?

[6:06](https://www.youtube.com/watch?v=IddXPepIAS4&t=366s) You do the code review and no one else?" Of course, we might have multiple be doing-- people doing code reviews and definitely use your normal AI coding

[6:14](https://www.youtube.com/watch?v=IddXPepIAS4&t=374s) assistants and, and review tools to help you review any pull requests that you create

[6:20](https://www.youtube.com/watch?v=IddXPepIAS4&t=380s) or CRs. So let me give you a little bit of a history lesson of where we have been, especially at AWS. We, uh, saw this need, especially from our teams and our customers, that they were vibe coding, they were using these coding assistants, but they weren't getting the outputs that they wanted.

[6:42](https://www.youtube.com/watch?v=IddXPepIAS4&t=402s) And what we saw is this, these customers were using this bespoke pattern of having the agents, the coding assistants create, uh, these full-blown requirements documents and these di- design documents.

[6:55](https://www.youtube.com/watch?v=IddXPepIAS4&t=415s) And we decided to create a application to kind of do this all for them. So we released Kiro, uh, l- earl- late last year in a general availability. It's our new AI IDE coding assistant.

[7:11](https://www.youtube.com/watch?v=IddXPepIAS4&t=431s) We also have a command line interface or CLI version, which is just as popular. I think right now it's switching. Most people are starting to use CLIs more often than IDEs, so if you like to do that, you can use the CLI.

[7:25](https://www.youtube.com/watch?v=IddXPepIAS4&t=445s) But what we really focused in on with Kiro is, you can see in these screenshots, is this Vibe and Spec mode. So s- we're gonna jump into Spec mode in a little bit, but we really thought this really encompassed what we were hearing from our customers.

[7:38](https://www.youtube.com/watch?v=IddXPepIAS4&t=458s) That people wanted more ways to work with larger features and more complex projects, and they really needed the coding assistant to know exactly what their project was doing.

[7:52](https://www.youtube.com/watch?v=IddXPepIAS4&t=472s) We also released the website at kiro.dev. Feel free to, after this presentation, to go check it out. You can download our CLI, our IDE, and give it a whirl 'cause, uh, you know, we're really proud of it.

[8:04](https://www.youtube.com/watch?v=IddXPepIAS4&t=484s) It's fun. When we released this, it actually went a little bit viral. We got tens of thousands of downloads. A lot of people were asking us, asking us about Kiro, so we were really happy to, to release this.

[8:14](https://www.youtube.com/watch?v=IddXPepIAS4&t=494s) And we actually, uh, we... When we set it up in preview, we had so many downloads we had to put a gate in front of it. And then people found ar- around the gate, but now it is publicly available for everyone to try and, and, and give it a shot.

[8:28](https://www.youtube.com/watch?v=IddXPepIAS4&t=508s) But I don't want this to be, uh, a half-hour pitch for Kiro. You can do this process, spec-driven development, without Kiro, and there's a few, few ways. One is that you, um, basically you have to just...

[8:41](https://www.youtube.com/watch?v=IddXPepIAS4&t=521s) You could do this manually with anything. You could tell the, your assistant, your large language model to include the following. First is the user requirements. You would tell them, "Please, based on XYZ, create a whole set of user requirements."

[8:55](https://www.youtube.com/watch?v=IddXPepIAS4&t=535s) Now, you can feed it your own user requirements beforehand and say, "Okay, use this as a basis," or you can have the editor or the AI IDE, uh, go ahead and create it for you.

[9:07](https://www.youtube.com/watch?v=IddXPepIAS4&t=547s) Then you look back and forth with it, make sure it's okay. Then you tell the assistant to create the design document. Then you look back at that, and then you have it create the implementation details.

[9:18](https://www.youtube.com/watch?v=IddXPepIAS4&t=558s) These are the, the tasks list, the tasks one by one to actually implement it based on the requirements and the design document you created. So you could do this kind of a manual way if you like.

[9:30](https://www.youtube.com/watch?v=IddXPepIAS4&t=570s) I'll give a shout-out to Spec Kit. This is GitHub's open source way of doing this process. You can install in a, in a variety of different coding assistants.

[9:41](https://www.youtube.com/watch?v=IddXPepIAS4&t=581s) Now in Kiro, you have this la... This is the IDE version. We have Plan mode inside the CLI if you prefer the CLI. But in the IDE, you would choose Spec, and then you would go ahead and give it a prompt.

[9:54](https://www.youtube.com/watch?v=IddXPepIAS4&t=594s) So in this case, I could say like, "Build a movie MCP server to keep track of movies I've watched," or, "Build an, a movie website," whatever you want. Now, you're probably thinking, "Is this spec only good for greenfield brand-new projects?"

[10:07](https://www.youtube.com/watch?v=IddXPepIAS4&t=607s) And I would say absolutely not. I've seen existing apps that are years old have dozens and dozens of these different spec files in them. In this example, it's kind of more of a greenfield, but you can definitely use it for existing legacy projects as well.

[10:22](https://www.youtube.com/watch?v=IddXPepIAS4&t=622s) It thinks... It, it works very well. And I would just say that these are really good for when you're doing in-depth features, when you n- your project needs a little more upfront planning, uh, and you just wanna build things in a structured way for-- definitely works really well with complex projects.

[10:38](https://www.youtube.com/watch?v=IddXPepIAS4&t=638s) We actually added a spec mode for bug fixes too, so you can use it for smaller things, though you may wanna just kinda vibe code those things instead.

[10:49](https://www.youtube.com/watch?v=IddXPepIAS4&t=649s) Here's what our requirements document looks like. So in the first part, it creates this, uh, requirements phase, where it's in this EARS format, and it gives you the introduction, like the requirements, the user stories.

[11:01](https://www.youtube.com/watch?v=IddXPepIAS4&t=661s) Uh, we also have a process where it asks you questions beforehand. So we added in some extra question and answer. So as you put your prompt in, it'll ask you some clarifying questions before it creates this requirements phase.

[11:14](https://www.youtube.com/watch?v=IddXPepIAS4&t=674s) You can also do this quick plan mode we just added which, uh, will go ahead and just generate all these documents quickly for you based on the questions and answers you give.

[11:23](https://www.youtube.com/watch?v=IddXPepIAS4&t=683s) So there's a lot of different ways you can do this.

[11:26](https://www.youtube.com/watch?v=IddXPepIAS4&t=686s) Then it'll create a design document, which is a higher level design document. You can also start with the design document first. Some people kind of take this design and requirements, combine them.

[11:35](https://www.youtube.com/watch?v=IddXPepIAS4&t=695s) But typically with, with our spec-driven deve- development flow, you could either start one or the other. And then you might have Mermaid diagrams here, ASCII art, uh, with all the information.

[11:45](https://www.youtube.com/watch?v=IddXPepIAS4&t=705s) Now, this is at the point I would highly recommend if you're trying this at home to stop and go in and update it with your knowledge and expertise and taste to exactly what you're looking for.

[11:56](https://www.youtube.com/watch?v=IddXPepIAS4&t=716s) Because it's only as good as what you put in. But you'll find out that it, even with a smaller prompt it, and with the clarifying questions, it does a pretty good job.

[12:07](https://www.youtube.com/watch?v=IddXPepIAS4&t=727s) And of course, you always wanna review it for Markdown, the Markdown files for inconsistencies, hallucinations, and errors. And then finally you get to the implementation phase. This will be a list of tasks Uh, it also has something called property-based tests in them, which are tests that are against the requirements document and design document.

[12:26](https://www.youtube.com/watch?v=IddXPepIAS4&t=746s) You can a- additionally have those created and ran. I would highly recommend it, so that way it makes sure that the, the tasks actually are implemented correctly. Uh, I usually also-- a quick tip here, once it creates this task list, I tell it, "Please take the top four tasks, put them at the top, and create an MVP

[12:45](https://www.youtube.com/watch?v=IddXPepIAS4&t=765s) for me first." So that way I can actually see it working, and then I'll implement them. I'll implement the MVP version first.

[12:55](https://www.youtube.com/watch?v=IddXPepIAS4&t=775s) Now, I love Model Context Protocol. I'm not gonna go into exactly all the details of it, but it's a way essentially for your model providers to connect to different data sources.

[13:05](https://www.youtube.com/watch?v=IddXPepIAS4&t=785s) So in this case, I'm using Kiro, and maybe I'm using, like, OpenAI or Anthropic, and we wanna connect to different data sources. So we have this MCP protocol in the middle, and it connects everything together for us, which is awesome.

[13:23](https://www.youtube.com/watch?v=IddXPepIAS4&t=803s) Now, I get this question, uh, "Isn't MCP six months old a- and it's dead now?" Now, a lot of people on the internet have opinions that change every other day, and some people were saying that, "Well, you can do a lot of stuff with MCP just with command line tools."

[13:38](https://www.youtube.com/watch?v=IddXPepIAS4&t=818s) I really think MCP is still maturing. There's a lot, uh, a, a long road ahead for it, especially with some of the security stuff it's doing. I would keep an eye out for MCP, but one of the main reasons I like it, especially for the spec-driven development flow, is you can have something like in Jira or Asana,

[13:56](https://www.youtube.com/watch?v=IddXPepIAS4&t=836s) all your tickets, all your, uh, large requirements docs, and then you can have it being pulled into your spec-driven development flow when it creates your specs, which makes it much easier to work with.

[14:08](https://www.youtube.com/watch?v=IddXPepIAS4&t=848s) So if you have a product manager that has actually written a requirements document, you can pull that in.

[14:16](https://www.youtube.com/watch?v=IddXPepIAS4&t=856s) And, uh, it just makes it a little bit easier, and I'm, I'm talking about any, any kind of project management service and grab technical details for it.

[14:25](https://www.youtube.com/watch?v=IddXPepIAS4&t=865s) You can also put additional rules in your steering or your AGENTS.md files that tells it, "So if you're using spec-driven development flow, make sure you grab the information out of this MCP server," and that way it knows where to look.

[14:37](https://www.youtube.com/watch?v=IddXPepIAS4&t=877s) Or you can just specify it in the first step, like, "Hey, look at this MCP server when you create the requirements."

[14:45](https://www.youtube.com/watch?v=IddXPepIAS4&t=885s) So let me show you a quick demo. This is the latest version of Kiro, the IDE version, and let me give you a, a quick show of it. Now, just for the sake of time, I don't have time to actually go in and create a brand-new project from scratch, but I used this one.

[15:03](https://www.youtube.com/watch?v=IddXPepIAS4&t=903s) It's a movie database, so this is more of a greenfield brand-new project, but I think you'll still get the idea. I was in the Spec mode here. I said, "Please create me a movie website."

[15:14](https://www.youtube.com/watch?v=IddXPepIAS4&t=914s) So what it did is it started with this design document, and in this case, in this case, I actually told it to start with design instead of requirements. And then this shows the actual preview of the Markdown file.

[15:27](https://www.youtube.com/watch?v=IddXPepIAS4&t=927s) So you can see it created a bunch of different Mermaid diagrams that show the architecture of it, gives you sequence diagrams. And so I went back and forth with this and updated and edited it, and it created this all for me.

[15:39](https://www.youtube.com/watch?v=IddXPepIAS4&t=939s) If I scroll down to the bottom of this document it created, you can see here it created a bunch of property tests, tests, and these are really special tests.

[15:48](https://www.youtube.com/watch?v=IddXPepIAS4&t=948s) It uses fast-check in this TypeScript in the Node world to do these tests, which actually run dozens, if not hundreds of times with different values to make sure that it's, uh, these requirements are satisfied correctly, which is really nice.

[16:04](https://www.youtube.com/watch?v=IddXPepIAS4&t=964s) And then it created this requirements document in, once again, this EARS format, so it's really, uh, very simple with these user stories, requirements. Uh, let me see if I can open it up again.

[16:14](https://www.youtube.com/watch?v=IddXPepIAS4&t=974s) Here's it in preview. Uh, so here's the requirements document. Requirements one, movie data loading. When the application initialize, the filter engine shall load. So it kinda gives you step-by-step exactly what's, uh, what it's doing here.

[16:29](https://www.youtube.com/watch?v=IddXPepIAS4&t=989s) And then when I went back and forth with this, I got to the task list and I asked it, "Hey, in the task list, can we create like an MVP?"

[16:35](https://www.youtube.com/watch?v=IddXPepIAS4&t=995s) So it went ahead and updated the task list and even says right here, "Tasks one through four deliver a working MVP, browsable movie grid with search, genre filtering, sorting, and the full '80s synthwave theme."

[16:47](https://www.youtube.com/watch?v=IddXPepIAS4&t=1007s) So it actually redid all the requirements and to get this, uh, basically MVP up and running out of the door, which I really enjoyed. I went ahead and just implemented all of them after that, but you could see how it works.

[17:01](https://www.youtube.com/watch?v=IddXPepIAS4&t=1021s) You can also see it created this property based, based tests, which are nice, which I can go back in and take a look at the execution. You can also-- let me see if I scroll to the bottom here.

[17:11](https://www.youtube.com/watch?v=IddXPepIAS4&t=1031s) Here it is. So if I just kinda hover, it shows like a little bit of information about the property-based test. Like with property test, test for genre filtering. For any movie dataset, the extracted genres list must contain exactly the sorted set of unique genres.

[17:26](https://www.youtube.com/watch?v=IddXPepIAS4&t=1046s) So it tells me exactly what it did at this point. So if you wanna learn more, you can go to kiro.dev, or you can join our Discord at discord.gg/kiro.dev.

[17:34](https://www.youtube.com/watch?v=IddXPepIAS4&t=1054s) I highly recommend everyone watching check it out and make sure you connect with me on LinkedIn at [REDACTED:username]. Love to just connect with as many people as I can, and also on Bluesky [REDACTED:username] or X.

[17:45](https://www.youtube.com/watch?v=IddXPepIAS4&t=1065s) Thanks.
