Skip to content
/

094459/sdd-workshop

094459-sdd-workshop · 094459/sdd-workshop · ★ 18 · last commit 2026-01-22

Primitive shape
No installable primitives
00

Summary

094459/sdd-workshop — Summary

A self-guided, hands-on workshop teaching spec-driven development using the Kiro IDE as the primary tool. The workshop is structured as five sequential labs covering the SDD lifecycle: requirements, design, and tasks — for both greenfield (new project) and brownfield (existing codebase) scenarios. It does not ship prompts, CLI tools, or runnable scripts; its entire value is in the workshop Markdown narrative and the accompanying Kiro walkthrough instructions.

Target audience is AWS-adjacent developers attending a facilitated session or working through it self-service. The repo is a documentation/tutorial repository, not a methodology framework with installable components. It ships zero slash commands, zero skills, zero hooks, and zero MCP servers.

As a teaching artifact for Kiro's SDD implementation, it sits closest to the Kiro seed in archetype (Archetype 5 — closed IDE with proprietary primitives), but functions only as a companion tutorial rather than an independent framework. It differs from spec-kit (Archetype 2) and openspec (Archetype 2) in having no installable components whatsoever, and from spec-driver (Archetype 1) in not shipping any skills or CLI.

01

Overview

094459/sdd-workshop — Overview

Origin

Created by an AWS Developer Advocate (GitHub handle 094459) as a companion workshop to the Kiro IDE launch. The repository description is "A hands on, self guided tutorial to help you get started with specification driven development." It was published in 2025 alongside Kiro's public availability.

Philosophy

The workshop teaches SDD as a disciplined practice centered on three documents: requirements, design, and tasks. It treats these documents as the "spec" and defines a spec lifecycle (create, iterate, update). The framing is pedagogical: the content explains why each phase matters before asking students to try it.

Manifesto-style quotes

From workshop/02-getting-started.md:

"Spec driven development (SDD) is a systematic approach to software feature development that emphasizes thorough planning, clear documentation, and structured implementation. This methodology transforms rough feature ideas into well-defined, implementable solutions through a three-phase process that ensures quality, maintainability, and successful delivery."

On steering documents:

"Providing the right context is key to getting the best out of AI coding assistants, and steering documents help provide context... Instead of explaining your conventions in every chat, steering files ensure your AI coding assistant consistently follows your established patterns, libraries, and standards."

On context hygiene:

"Edit your context files ruthlessly so that they are as small as you can make them."

Structure

Five workshop modules:

  1. 01-intro.md — Historical evolution from raw AI to SDD
  2. 02-getting-started.md — SDD concepts: spec structure, steering docs, inclusion modes
  3. 03-greenfield.md — Building new applications end-to-end with Kiro
  4. 04-brownfield.md — Applying SDD to existing codebases
  5. 05-tools-and-resources.md — Kiro deep-dive and additional resources

Target audience

Workshop attendees (in-person or self-service) who want a structured introduction to Kiro's SDD workflow. The author is AWS DevRel; the workshop references an AWS survey link.

02

Architecture

094459/sdd-workshop — Architecture

Distribution

  • Type: Methodology documentation / tutorial repository
  • Install: No installation required. Clone or browse on GitHub.
  • Install complexity: clone-and-configure (clone + open Kiro IDE)

Directory tree

sdd-workshop/
├── README.md            ← Entry point + lab navigation
├── images/              ← Workshop screenshots (header, kiro UI, lifecycle diagrams)
├── updates/
│   └── changelog.md
└── workshop/
    ├── 01-intro.md          ← History and motivation
    ├── 02-getting-started.md ← SDD concepts + steering docs
    ├── 03-greenfield.md     ← Hands-on lab: new application
    ├── 04-brownfield.md     ← Hands-on lab: existing codebase
    └── 05-tools-and-resources.md ← Kiro features + resources

Dependencies

  • Required runtime: None (documentation only)
  • Required tooling: Kiro IDE (proprietary, downloadable from kiro.dev), Python 3.10+, uv (for the lab exercises), git

Target AI tools

  • Primary: Kiro IDE (the only tool used in the workshop)
  • Other: None — the workshop does not reference Claude Code, Cursor, or any other agent

Config files

None — the repo ships no config files for any AI framework. The .kiro/steering/ directory is created by the student during the lab exercises, not by the repo.

Notes

The workshop is a Kiro-specific tutorial. Students install Kiro, follow the lab instructions, and produce the standard Kiro SDD artifacts (requirements.md, design.md, tasks.md) within the Kiro IDE UI. The repository itself contains only the tutorial narrative.

03

Components

094459/sdd-workshop — Components

Commands

None. The repo ships zero slash commands.

Skills

None.

Subagents

None.

Hooks

None.

MCP Servers

None.

Scripts

None.

Templates

None shipped as reusable templates. The workshop Markdown files describe what artifacts students will create during the hands-on labs (requirements.md, design.md, tasks.md), but the repo does not provide those as blank templates.

Workshop Modules (the only shipped primitives)

File Purpose
workshop/01-intro.md Historical context for SDD adoption
workshop/02-getting-started.md Core SDD concepts: spec lifecycle, steering docs, inclusion modes
workshop/03-greenfield.md Step-by-step greenfield lab with Kiro
workshop/04-brownfield.md Brownfield lab: existing codebase discovery + spec retrofit
workshop/05-tools-and-resources.md Kiro IDE feature tour and resource links

Summary

The framework's entire component inventory is five Markdown tutorial files and one image directory. This is a documentation-only repository with no executable, installable, or programmatic primitives.

05

Prompts

094459/sdd-workshop — Prompts

The repository ships no prompt files. It is a tutorial, not a prompt library. However, the workshop text contains instructional language that shapes how students interact with Kiro.

Excerpt 1 — Defining a spec (from workshop/02-getting-started.md)

"Creating a spec starts with intent - what are trying to do? We use an initial prompt to bootstrap the spec creation and start the workflow. Working with specs about iterating and refining. It is not too important whether your spec is perfect when it is initially created as you will be spending lots of time reviewing and editing them."

Prompting technique: Permissive-start / iterate-later. Students are told to give rough initial prompts and refine iteratively, lowering the barrier to starting.

Excerpt 2 — Steering document reload instruction (from workshop/02-getting-started.md)

"If you do make edits and changes, make sure you ask Kiro to reload these files into its context window. If you fail to do this, it will retain the original versions in its 'memory'. The prompt I use is as follows (changing it based on which steering doc was updated): 'I have updated the steering document xx.md - please reload'"

Prompting technique: Explicit cache-bust pattern. The user is taught to proactively force context refresh after editing files, working around Kiro's stale-context behavior.

Excerpt 3 — Steering document content guidance (from workshop/02-getting-started.md)

"Here are some strategies to help you add the right steering docs to your project: Start small and include just the core needs you want to influence... Edit your context files ruthlessly so that they are as small as you can make them... Provide examples - use code snippets, example input/outputs, style and structure guides... Security first - make sure you do NOT include sensitive information in your steering docs. Never include API keys, passwords, or sensitive data."

Prompting technique: Context hygiene rules. Prescriptive guidance on what should and should not be in persistent context files.

Note

All prompt guidance in this repo is pedagogical prose, not machine-executable prompt files. The actual Kiro prompt interface is proprietary and not shipped in this repository.

09

Uniqueness

094459/sdd-workshop — Uniqueness

differs_from_seeds

This repo is closest to the kiro seed — it is literally a tutorial for Kiro's native SDD implementation. The architectural delta is that it adds zero framework machinery: no skills, no commands, no hooks, no CLI, and no templates. Where kiro itself is the tool (Archetype 5 — closed IDE with proprietary primitives), 094459/sdd-workshop is a teaching companion that walks students through using that tool. It differs from spec-kit (Archetype 2 — mirror commands+skills) by having no installable components, and from spec-driver (Archetype 1 — skills-only behavioral framework) by being purely documentation. It is arguably the most minimal entry in the entire corpus: 5 Markdown files and a set of images, shipping nothing a machine can execute.

Positioning

Occupies a unique position as a certified tutorial rather than an independent methodology. AWS DevRel published it to accelerate Kiro adoption. It teaches the same requirements→design→tasks three-document pattern seen across many seeds (agent-os, kiro, spec-kit, openspec) but delegates all implementation to Kiro's proprietary IDE.

For teams evaluating Kiro, this is the most direct on-ramp. For teams not using Kiro, the workshop provides zero value (everything requires the IDE).

Observable failure modes

  1. 100% Kiro dependency: The entire workshop fails without Kiro access. No fallback methodology exists.
  2. No standalone prompts: Students cannot apply the methodology with Claude Code, Cursor, or any non-Kiro tool — the repo provides no CLAUDE.md templates or slash commands.
  3. Stale content risk: Workshop was created at Kiro launch; as Kiro's UI evolves, screenshots and step-by-step instructions may diverge from actual Kiro behavior.
  4. No validation gates: All phase reviews are purely manual with no automated checks.
  5. Low reusability: Because the repo is pedagogical prose rather than reusable components, practitioners cannot build on top of it programmatically.
04

Workflow

094459/sdd-workshop — Workflow

Phases

The workshop defines a three-phase spec lifecycle (taught via five lab modules):

Phase Activity Artifact
1. Requirements Define WHAT using Kiro's requirements generation requirements.md (EARS-style)
2. Design Define HOW — architecture, data model, APIs design.md
3. Tasks Break into implementation steps tasks.md

Plus a setup phase:

  • Steering setup (before any spec work): Create .kiro/steering/ documents (product.md, tech.md, structure.md) to provide persistent context

Greenfield flow (Lab 3)

  1. Open Kiro IDE with a blank project
  2. Create steering documents (product.md, tech.md, structure.md)
  3. Enter initial prompt describing the feature
  4. Kiro generates requirements.md (EARS notation)
  5. Review and edit requirements.md
  6. Kiro generates design.md from requirements
  7. Review and edit design.md
  8. Kiro generates tasks.md from design
  9. Execute tasks (Kiro agent mode)
  10. Add new features: iterate through phases 1-3 again

Brownfield flow (Lab 4)

  1. Open Kiro IDE with existing codebase
  2. Click "Generate Steering" → Kiro analyzes codebase and produces product.md, tech.md, structure.md
  3. Review and edit generated steering docs
  4. Create spec for desired change/addition
  5. Follow standard requirements → design → tasks flow
  6. Execute

Approval gates

The workshop describes the following review points (but does not enforce them programmatically — all are manual):

  1. Post-requirements review: Student reads and edits requirements.md before proceeding
  2. Post-steering review: Student verifies generated steering docs are accurate
  3. Post-design review: Student reviews design.md before generating tasks
  4. Post-tasks review: Student can edit tasks before execution

Spec format

Markdown. Requirements use EARS (Easy Approach to Requirements Syntax) notation as introduced in the workshop content. Example format: "The system shall [function] when [condition]."

Steering document inclusion modes

Kiro's four modes (taught in lab):

  • Always: loaded into every interaction
  • Conditional (fileMatch): loaded only when working with matching files
  • Manual: loaded only when explicitly referenced with #steering-file-name
  • (Default = always if no header present)
06

Memory Context

094459/sdd-workshop — Memory & Context

State storage

The workshop teaches Kiro's steering-file-based context system:

  • .kiro/steering/ — workspace-level steering documents (project-scoped)
  • ~/.kiro/steering/ — global steering documents (user-global)

These are plain Markdown files, not a database or vector store.

Persistence

  • Project-level: .kiro/steering/ files persist across sessions as long as the workspace remains open. Kiro auto-loads "always" inclusion mode files.
  • Global-level: ~/.kiro/steering/ files persist globally across all Kiro projects.

Handoff mechanism

Kiro's inclusion modes control what context is loaded per interaction:

  • Always: loaded every time (for foundational standards)
  • Conditional (fileMatch): loaded when working with matching paths
  • Manual: loaded only when explicitly referenced

Compaction behavior

Not discussed in the workshop — Kiro's internal context management is proprietary. The workshop notes that context can go stale and advises the "please reload" workaround (see 05-prompts.md).

Cross-session handoff

Kiro maintains spec state by tracking requirements.md, design.md, and tasks.md files. The workshop describes iterating on specs across sessions by returning to the relevant phase's file and editing it.

Memory type

File-based. Three generated standard steering files (product.md, tech.md, structure.md) plus custom user-defined steering files. All are plain Markdown.

State files (created by students during lab)

File Content
.kiro/steering/product.md Product purpose, users, key features
.kiro/steering/tech.md Technology stack, frameworks, tools
.kiro/steering/structure.md File organization, naming conventions
requirements.md Feature requirements (EARS notation)
design.md Technical design document
tasks.md Implementation task list
07

Orchestration

094459/sdd-workshop — Orchestration

Multi-agent support

None. The workshop teaches single-agent Kiro sessions. No multi-agent patterns are discussed.

Orchestration pattern

Sequential. The three-phase workflow (requirements → design → tasks) is explicitly sequential, with each phase depending on the previous.

Isolation mechanism

None beyond Kiro's native IDE isolation. No worktrees, containers, or sandboxes are mentioned.

Execution mode

Interactive-loop. Students interact with Kiro in a conversational interface within the IDE. There is no CLI, no background daemon, and no scheduled execution.

Multi-model routing

None. The workshop uses Kiro's built-in model selection; model routing is not discussed.

Consensus mechanism

None.

Prompt chaining

Implicit. The workshop describes a sequence where each phase's output becomes the input to the next:

  • Feature intent → requirements.md
  • requirements.md → design.md
  • design.md → tasks.md

This is described narratively but implemented by Kiro's IDE, not by any scripted chaining mechanism.

Parallel execution

None discussed.

Crash recovery

Not addressed. Kiro's IDE handles session state; the workshop does not cover error recovery.

08

Ui Cli Surface

094459/sdd-workshop — UI / CLI Surface

Dedicated CLI binary

None. The repository ships no CLI binary.

Local web dashboard

None.

IDE integration

Primary tool: Kiro IDE (proprietary VS Code fork by AWS).

The workshop teaches Kiro's built-in SDD UI:

  • Specs panel: View and navigate between specs
  • Agent Steering widget: Create, list, and delete steering documents; choose inclusion mode (Always / Conditional / Manual)
  • Requirements, Design, Tasks tabs: Phase-specific UI within each spec
  • Agent mode: Execute tasks within Kiro

From the workshop:

"Kiro provides an opinionated UI that walks you through the specs driven development workflow... Kiro simplifies working with spec driven development by integrating into its user interface how to create a spec, and then walking you through the workflow."

Observability

None shipped by this repository. Kiro's IDE has its own session history and file-based traceability (via spec artifacts).

Shell completion

None.

Installation surface

Students follow:

  1. Download Kiro from kiro.dev
  2. Install Python 3.10+ and uv
  3. Clone a sample project (for brownfield lab)
  4. Open project in Kiro

No npm install, no pip install, no shell scripts from this repo.

Related frameworks

same archetype · same primary tool · same memory type

Context-Engineering Handbook ★ 9.0k

Provides a first-principles, research-grounded vocabulary and learning path for context engineering — the discipline of designing…

walkinglabs/learn-harness-engineering ★ 6.6k

Teach harness engineering from first principles (12 lectures + 6 projects) and provide a scaffolding skill (harness-creator) that…

Awesome Harness Engineering (walkinglabs) ★ 2.7k

Curate the authoritative reference list of articles, benchmarks, and tools for harness engineering — the practice of shaping the…

cline-memory-bank (nickbaumann98) ★ 581

Custom instructions + 6-file hierarchical Markdown memory bank so Cline maintains full project context across sessions, with a…

FPF (First Principles Framework) ★ 372

Provides a formal pattern language for making reasoning explicit, traceable, and publishable in mixed human/AI engineering work —…

nexu-io/harness-engineering-guide ★ 134

Provide a practical, code-first reference guide to harness engineering — from first principles to production patterns —…