Rethinking Full Stack Application Development with Kiro by Alessandra Pasini & Romain Jourdan
(link)Summary
This talk introduces **spec-driven development** as an alternative to prompt-first AI coding. Alessandra Pasini and Romain Jourdan demonstrate Kiro, AWS’s agentic development environment, using an existing full-stack marketplace application built with **Spring Boot/Java 25** and **React/Next.js**. The demo shows how Kiro helps developers move from intent to **requirements**, **design**, and **task lists** before code is generated. The speakers also cover **agent steering** documents for project context, **agent hooks** for automated checks, **MCP servers** for tool integrations, and **Kiro powers** for dynamic tool loading. They use the workflow to add a seller review feature, iterate on the spec, and split implementation work between front end and back end. The talk also covers team usage, brownfield codebases, custom agents, and running Kiro through different interfaces including IDE integration and CLI.
Key Takeaways
- Spec-driven development shifts iteration from code to requirements and design documents before implementation starts.
- Kiro uses steering documents to give agents shared context about the codebase, tech stack, and design system.
- Agent hooks can automate checks such as design-system compliance and UI verification with tools like Playwright.
- MCP servers and Kiro powers let the IDE connect to external tools and load them dynamically when needed.
- The workflow supports brownfield development: adding features to an existing marketplace app rather than starting from scratch.
- Custom agents can be tailored for roles like backend implementation, infrastructure work, or code review.
- The speakers emphasize that specs, design docs, and task lists become part of the repository alongside code.
Sections
What spec-driven development means
The presenters argue that AI coding is most useful when the developer’s intent is made explicit first. Instead of starting with a vague prompt and iterating on generated code, Kiro starts from structured specs that describe the feature in a way the agent can follow. The goal is to reduce ambiguity, align expectations earlier, and avoid wasting time and tokens on repeated code rewrites.
Demo app: brownfield full-stack marketplace
The demo uses an existing marketplace application with a **Spring Boot** backend, **Java 25**, and a **React/Next.js** frontend. The app already includes listings, seller pages, orders, S3 image uploads, and a database. The team uses it as a brownfield project to add a new feature: **user rating and reviews** for sellers.
Steering documents and shared project context
Kiro generates and consumes steering documents that capture project conventions such as the technology stack, design system, light/dark mode support, and other architectural context. These documents give the AI a common baseline for working inside an existing codebase and help keep generated changes aligned with the team’s standards.
Requirements, design, and task flow
The spec workflow proceeds through three stages: **requirements**, **design**, and **tasks**. The demo shows Kiro creating a requirements document with user stories, acceptance criteria, and a glossary. The speakers then trim the scope by keeping only selected requirements and moving the rest to the backlog. Once the requirements are accepted, Kiro produces a design document and then a task list for implementation.
Using Figma and design system inputs
For the frontend work, the team feeds selected **Figma** components into the design phase so the generated design doc matches the actual UI direction instead of inventing generic components. This is presented as a way to align implementation with an existing design system and reduce drift between mockups and code.
Agent hooks, MCP, and Kiro powers
The talk covers several integration points: **agent hooks** for automated workflows, **MCP servers** such as GitHub and Playwright, and **Kiro powers** for dynamic tool activation. The speakers show how hooks can enforce design-system compliance or trigger UI validation, and how powers can load the right external tool only when needed.
Custom agents and parallel implementation
On the backend side, the presenters show a custom agent configured for backend engineering tasks, including code changes, testing, and container-based verification. They also demonstrate using sub-agents to split work into phases and parallel groups so different parts of the implementation can be handled without file conflicts. The idea is to support team workflows, not just solo prompting.
IDE and CLI usage
Kiro is shown as more than a single IDE: it has an IDE experience, a web experience, and a CLI. The team also demonstrates integrating Kiro CLI into **IntelliJ** via **ACP** support, so developers can keep their existing editor while using Kiro’s agentic workflow. The presenters note that this approach is useful for teams that do not want to switch tooling.
Positioning for production work
The speakers stress that spec-driven development is aimed at production-ready software rather than just quick prototypes. They acknowledge that ambiguous specs still need iteration, but argue that refining text documents is faster and cheaper than generating and discarding code. They also mention using a related AWS transformation tool to migrate an earlier backend from Python/FastAPI to Spring Boot/Java 25.
Keywords: spec-driven development, kiro, aws kiro, agentic development environment, structured ai coding, full-stack application development, spring boot, java 25, react next.js, brownfield development, requirements design tasks workflow, agent steering, mcp servers, agent hooks, kiro powers, custom agents, playwright integration, github mcp, figma integration, intellij acp, cli agent integration, software delivery lifecycle, production-ready ai coding, marketplace application, design system compliance