Skip to content

Part 4, Writing useful specs & personas โ€‹

Knowledge-share outline โ€‹

A short talk (about 7โ€“8 slides) sets up the lab:

  1. Spec-Driven Development (SDD): what it is and why specs become the source of truth.
  2. Spec Kit: the open-source toolkit that turns SDD into runnable slash commands.
  3. The command chain: constitution โ†’ specify โ†’ plan โ†’ tasks โ†’ implement.
  4. What makes a functional requirement useful: specific, testable, bounded.
  5. Personas as requirements, not flavor text: roles in your domain, each with a bounded behavior change.
  6. Writing memory requirements: using the what / why / for-whom / how-long template from Part 3, now applied to your own application.
  7. Good vs. bad requirements: see the examples below.
  8. What you will build in the lab: the checklist you are about to work through.

At a glance โ€‹

Start stateEnd stateFallback baseline
The order-memory middleware from Part 3 and the workshop requirements for your applicationA project constitution, a spec.md and plan.md for your own business operations tracker, with memory requirements and bounded personasbaseline/04-1-spec.md

Learning goals โ€‹

  • Explain Spec-Driven Development (SDD): specifications are the source of truth; code is their generated expression.
  • Learn the Spec Kit framework and its core slash commands: /speckit.constitution โ†’ /speckit.specify โ†’ /speckit.plan โ†’ /speckit.tasks โ†’ /speckit.implement, and know when to reach for each.
  • Install the Specify CLI and run the four core lab commands in order.
  • Produce a project constitution, a feature spec, and an implementation plan for your own business operations tracker.
  • Write memory requirements using the what / why / for-whom / how-long template: specify what your application's memory behavior must guarantee.
  • Express personas as bounded, behavior-shaping requirements for the roles in your domain that never override safety, privacy, or correctness.

Why it matters โ€‹

In Part 3 you added memory to the Dunder Mifflin agent: a warm-up exercise to make the concept concrete. That work introduced the core memory model and the remember / forget / retrieve / ignore choice. We will come back to memory as a full implementation concern when you wire agents to your own application in the later parts.

This part is where you step back from code and design the system those agents will operate against for the rest of the workshop. You will pick your own domain (package delivery, support tickets, repair orders, whatever you can reason about naturally) and produce a specification that is specific, testable, and bounded, before any of it is built.

Personas matter here because they are where real systems behave unsafely if requirements are vague. Useful personalization makes a system feel built for its users; vague personalization produces agents that hide errors, ignore boundaries, or behave differently for different people in ways nobody intended. Writing personas as bounded requirements, not flavor text, is how you prevent that.

See the workshop requirements for the full list of functional and non-functional requirements your application 'must' meet.

What is Spec Kit? โ€‹

Spec-Driven Development (SDD) inverts traditional software development: instead of code being the source of truth, specifications are. The spec defines what to build; the plan translates it into technical decisions; code is the generated output. When requirements change, you update the spec and regenerate; you don't manually patch code that has drifted away from intent.

Spec Kit is the open-source toolkit that makes SDD practical with AI coding agents. It installs a set of slash commands into your project so that Copilot (and other AI agents) follow a structured workflow:

text
/speckit.constitution  โ†’  establish project principles
/speckit.specify       โ†’  define what to build (the PRD / spec)
/speckit.plan          โ†’  translate into a technical implementation plan
/speckit.tasks         โ†’  split up in manageable and logically-ordered chunks
/speckit.implement     โ†’  execute the plan (generate the code)

Each command produces a versioned Markdown artifact under specs/ or .specify/memory/. Because the artifacts are plain Markdown files in your repo, they are diff-able, reviewable, and portable across AI agents.

Install the Specify CLI โ€‹

Spec Kit requires Python 3.11+ (check with python --version; your Part 1 setup already ensured Python 3.12) and uv (a fast Python package manager). If you installed uv during prerequisites, you are ready. If not, install it first:

bash
# Install uv (if not already present)
winget install astral-sh.uv
bash
# Install uv (if not already present)
curl -LsSf https://astral.sh/uv/install.sh | sh

Then install the Specify CLI:

bash
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

Verify the install:

bash
specify --version

Expected output: specify, version X.Y.Z (or similar). If the command is not found, make sure the uv tool bin directory is on your PATH (uv prints the path at install time).

pipx alternative

If you prefer pipx over uv, use: pipx install git+https://github.com/github/spec-kit.git. Both work; uv is faster.

Add Spec Kit to your repo โ€‹

With the CLI installed, initialize Spec Kit inside your workshop fork. Run this from the repo root (dm-ws/):

bash
cd dm-ws
specify init --here --integration copilot

What this does:

  • Creates a .specify/ directory with templates, memory, and configuration files.
  • Writes slash-command prompt files into .github/prompts/ (one per /speckit.* command).
  • Writes agent definition files into .github/agents/.

Expected output: Spec Kit prints a summary of the files it created. Verify the key ones:

bash
ls .github/prompts/speckit.*.prompt.md
bash
ls .github/prompts/speckit.*.prompt.md

Expected output: a list of files including speckit.constitution.prompt.md, speckit.specify.prompt.md, speckit.plan.prompt.md, and speckit.implement.prompt.md. These are the prompt definitions GitHub Copilot loads when you type a /speckit.* command in agent mode.

Commit the generated files to your fork so they are available in every session:

bash
git add .specify .github/prompts .github/agents
git commit -m "chore: add Spec Kit"

All slash commands at a glance โ€‹

After initialization, your AI agent has access to these slash commands.

spec-kit development

Do not be surprised by additional slash commands during the workshop, or when installing a future version. Spec-kit is in active development and new releases sometimes feature new commands to explore. Definitely always check out the spec-kit repo.

Core commands (the main workflow) โ€‹

CommandWhat it doesWhen to run
/speckit.constitutionCreate or update the project's governing principlesOnce per project; update when principles change
/speckit.specifyTurn a natural-language description into a structured feature spec (spec.md)Once per feature
/speckit.planTranslate the spec into a technical implementation plan (plan.md)After /speckit.specify
/speckit.tasksBreak the plan into a dependency-ordered task list (tasks.md)After /speckit.plan, before /speckit.implement
/speckit.implementExecute all tasks in tasks.md and build the featureAfter /speckit.tasks

Intermediate commands (explained here; not required in lab) โ€‹

These fit between the core steps and improve quality:

CommandWhat it doesWhen to run
/speckit.clarifyAsk up to 5 targeted questions to resolve ambiguities in the specAfter /speckit.specify, before /speckit.plan
/speckit.analyzeCross-artifact consistency check across spec, plan, and tasksAfter /speckit.tasks, before /speckit.implement
/speckit.taskstoissuesConvert tasks.md entries to GitHub IssuesWhen tracking work on a project board
/speckit.convergeCompare the codebase to spec/plan/tasks and add any remaining workWhen implementation is partial or stale

Advanced / extra commands โ€‹

CommandWhat it does
/speckit.checklistGenerate a custom quality checklist ("unit tests for English") that validates requirement completeness and clarity
/speckit.agent-context.updateRefresh the managed Spec Kit section in agent context files after spec or plan changes

Recommended order for a new feature

/speckit.constitution (once) โ†’ /speckit.specify โ†’ /speckit.clarify (optional) โ†’ /speckit.plan โ†’ /speckit.tasks โ†’ /speckit.analyze (optional) โ†’ /speckit.implement

Persona examples (as requirements) โ€‹

Personas belong in the spec as behavior-shaping requirements with explicit boundaries. The examples below use the Dunder Mifflin scenario; replace the names and roles with those from your own domain:

PersonaPreferenceBehavior change (requirement)Hard boundary
StanleyMinimize visual noiseWhen Stanley views a package list, the system MUST de-emphasize or collapse the statuses he marked low-interest (for example, deliveries completed more than 7 days ago).MUST NOT hide safety- or compliance-critical statuses (damaged, recalled, on hold); minimizing is a display preference, never deletion, and the audit record is unchanged.
DwightPriority handlingDwight MAY flag an order as priority; the system applies an escalation policy and, for routine orders below the priority threshold, MUST confirm with him before escalating.MUST NOT let a persona force escalation that bypasses approval or routing rules; routine orders are not silently force-escalated.
KevinRoute triviaFor Kevin, route summaries MUST include an additive "points of interest: donut shops" annotation when that data is available.The annotation is informational only; it MUST NOT change routing, delivery priority, or any correctness-bearing decision.
Warehouse staffOperational clarityFor the warehouse-staff role, responses MUST use concise, action-first operational language with no jokes or persona flair.Tone preference only; it MUST NOT omit required warnings or alter the underlying facts.

Personas never win over safety, privacy, or correctness

A persona personalizes how information is presented or prioritized within set limits. If a persona preference ever conflicts with a safety, privacy, or correctness rule, the rule wins.

What you will build โ€‹

Three Spec Kit artifacts for your own business operations tracker:

  1. A project constitution at .specify/memory/constitution.md: the governing principles for your application.
  2. A feature spec (spec.md) generated by /speckit.specify and enriched with memory requirements and bounded personas for the roles in your domain.
  3. An implementation plan (plan.md) generated by /speckit.plan from your spec.
  4. Optionally, generated code from /speckit.implement that follows the plan.

Before you start, read the workshop requirements. They define what your application must be capable of. Your spec should address all the functional requirements listed there.

Requirement examples: good vs. bad โ€‹

Bad (vague or untestable)Good (specific, testable, bounded)
"The system tracks entities.""A package moves through created, in-transit, out-for-delivery, delivered, and cancelled; transitions to delivered from any state except cancelled are allowed; cancelled is terminal."
"Personalize for the manager role.""Manager users may force a status override; the override records the actor, reason, and timestamp in the audit log; other roles receive 403 Forbidden."
"Emit events when things happen.""Every status transition publishes a domain event with type, entity ID, actor, and ISO-8601 timestamp; the feed is queryable via GET /events and via WebSocket."
"The API should be easy to use.""Every entity ID returned in a list response is usable as a path parameter; every error response includes a human-readable message field."

Prepare your prompts โ€‹

The quality of each Spec Kit artifact depends almost entirely on the quality of the prompt you give it. Before opening the Copilot agent panel, write your three prompts as plain text notes. This forces the decisions into the open before the AI fills in gaps for you.

Work through each prompt below. Use your own notes, the workshop requirements, and the good/bad examples above as guides.


Constitution prompt โ€‹

The constitution captures what is always true about your project: principles that every spec, plan, and implementation must follow. It is evaluated before every other command.

Decide before you write:

  • What must the application always do to be trustworthy? (think role enforcement, audit logging, observable state changes)
  • What must it never do under any circumstances? (autonomous writes without confirmation, bypassing role checks, storing sensitive data)
  • How must agents behave when they operate against it? (propose before acting, explain rejections, stay within role boundaries)

Draft your constitution prompt:

/speckit.constitution _______

What makes a good principle

A principle is not a wish. "Be safe" is a wish. "All status-changing operations require an explicit actor declared in the request; no anonymous writes are permitted" is a principle: testable, specific, and enforceable by a reviewer.


Specify prompt โ€‹

The specify prompt is your pitch: what are you building, for whom, and what must it do? It becomes the input for every downstream artifact.

Work through these questions before writing it:

  • Domain: what is your chosen domain and what is the primary entity? (not "a tracker" but "a support ticket that moves through open, triaged, in-progress, resolved, and closed")
  • Roles: who uses the system? Name the three or more roles and identify which one is privileged.
  • Key behaviors: what are the four or five things the system absolutely must do? (lifecycle with transition rules, domain events, audit trail, exceptions, privileged overrides)
  • Agent contract: how will an AI agent use this system? (read the OpenAPI spec, call endpoints, observe the event feed)
  • Non-goals: what is explicitly out of scope? (real authentication, cloud services in local dev, autonomous writes)

Draft your specify prompt:

/speckit.specify _______

Domain first, tech stack never

Name your domain, entity, roles, and behaviors clearly. Do not mention a tech stack here; that belongs in the plan prompt. The spec should describe what and why, not how.


Plan prompt โ€‹

The plan translates your spec into a technical blueprint. This is where you declare your stack choices, and where the constitution's constraints get evaluated against your architecture.

Decide before you write:

  • Backend language and framework: Python + FastAPI? Node.js + Express? C# + ASP.NET Core?
  • Database: SQLite, PostgreSQL, or in-memory? Local dev only at this stage.
  • Real-time event feed: WebSocket, Server-Sent Events, or a polling endpoint?
  • Identity mechanism: which request header will callers use to declare their role?
  • Local dev: are you using Docker Compose to bring the whole stack up with one command?

Draft your plan prompt:

/speckit.plan _______

One decision per sentence

Each explicit choice in your plan prompt becomes an architecture decision record in plan.md. The more specific you are, the less the AI has to guess, and the more reviewable the output.

Lab steps โ€‹

Running commands

All terminal commands below must be executed in a terminal. If you are not sure how to open one in VS Code, see VS Code tips. All /speckit.* commands are run in the Copilot agent panel (not the terminal), using agent mode.

Complete the CLI installation and repo initialization steps above before continuing here.

Review is where quality is made

Each slash command produces a Markdown file. Read it before running the next command. Every [NEEDS CLARIFICATION] marker is a decision the AI left for you. Every vague line is a future bug. You are the human in the loop: act like it.

Step 1: Establish the project constitution โ€‹

In the Copilot agent panel, run:

/speckit.constitution [INSERT YOUR CONSTITUTION PROMPT HERE]

What changes: .specify/memory/constitution.md is created or updated with your project's governing principles. Copilot will use this file to evaluate every subsequent spec and plan for compliance.

Look for these in the output

  • Each principle gets a name, a non-negotiable rule, and a rationale.
  • The constitution version is incremented (semantic versioning: patch for wording, minor for new principles).

Read before continuing

Open .specify/memory/constitution.md and read each principle. Ask: is this testable? Would I enforce it in a code review? If a principle sounds impressive but nobody can verify it, rewrite it. As Michael Scott would put it: "It is a document I am very proud of and have never actually read." Do not be Michael.


Step 2: Generate the feature spec with /speckit.specify โ€‹

Describe your own application in plain English. Use your chosen domain; the prompt below shows the trainer baseline as an example. Focus on what and why, not the tech stack. Reference the workshop requirements to make sure you cover the key capabilities.

Workshop scope vs. real-world practice

In this workshop you write a single /speckit.specify prompt that covers the entire application. This is intentional: the goal is to experience the full Spec Kit workflow end-to-end in one session.

In a real project you would never spec an entire system in one pass. You would run /speckit.specify once per feature: one prompt for entity lifecycle, another for role-based access, another for the event feed. Each produces a focused spec.md scoped to that feature, which the plan and implementation can then target incrementally. Smaller prompts produce sharper specs and smaller, safer implementation runs.

Keep this in mind when you leave today: the workshop prompt is a learning vehicle. Production use is iterative.

Trainer baseline example (package tracking):

/speckit.specify [INSERT YOUR SPECIFY PROMPT HERE]

Replace the domain and roles with your own. Your spec should address the requirements at /requirements.

What changes:

  • A new branch is created (e.g., 001-[your-domain]-tracker).
  • specs/001-[your-domain]-tracker/spec.md is created with:
    • User stories and acceptance criteria
    • [NEEDS CLARIFICATION: โ€ฆ] markers for anything ambiguous
    • Non-functional requirements (safety, performance, privacy)
    • A "what we will not build" scope boundary

Stop. Read the spec before step 3.

Open spec.md and read it as if you are a developer who just joined the project. Check:

  • Every [NEEDS CLARIFICATION] marker is either resolved inline or sent to /speckit.clarify.
  • You can find the lifecycle statuses, the role table, at least six event types, and the scope boundary.
  • Each requirement is specific enough that a reviewer could mark it pass or fail.

Dwight Schrute once noted: "False. An unreviewed spec is not a spec. It is a wish list." He was right. The plan you generate next is only as good as the spec you review right now. Read it twice.


Step 3: Enrich the spec to cover the workshop requirements (OPTIONAL) โ€‹

The generated spec will have a starting outline. Deepen it now against the workshop requirements to make sure every key capability is captured as a specific, testable requirement.

3a. Lifecycle requirements. Define the named statuses for your primary entity, the allowed transitions between them, and the terminal states. Each transition rule must be independently testable.

Expected output: a status list, a transition table or prose rules, and at least one example of a transition the system must reject.

3b. Role-based access requirements. Define the three or more roles in your domain, what each role can do, and what only the privileged role can do. Each permission boundary must be statable as a pass/fail check.

Expected output: a role table with at least three roles and a clear statement of what the privileged role can do that others cannot.

3c. Domain event requirements. List at least six event types your application will emit. Define the envelope schema: every event must carry at minimum an event type, entity ID, actor, and timestamp.

Expected output: a named event list and a single envelope schema example that all events must follow.

3d. Personas. Using the table in Persona examples as a model, write requirements for at least three of your application's user roles. Each must change behavior in a bounded way and include a hard boundary that cannot be overridden.

Expected output: three persona requirements, each with a stated hard boundary.

3e. API and agent-readiness requirements. Verify the spec addresses: identity declared via a request header (no real auth), an OpenAPI spec served at a known URL, and every meaningful action available as a documented endpoint with a predictable response shape.

Expected output: one non-functional requirement covering each of the three points above.

3f. Scope boundary. Add a "what we will not build" section: no real authentication, no cloud services in local dev, no autonomous write actions without a human confirmation step.


Step 4: Generate the implementation plan with /speckit.plan โ€‹

With the spec complete, run:

/speckit.plan [INSERT YOUR PLAN PROMPT HERE]

Baseline example: Python 3.12 + FastAPI + SQLModel. SQLite database. No external auth this segment.

What changes:

  • specs/001-[your-domain]-tracker/plan.md is created with:
    • Technical architecture decisions and their rationale
    • File/folder structure showing exactly what will be created
    • Constitutional compliance gates checked against your constitution
    • References to supporting artifacts (data-model.md, contracts/, research.md) if generated
  • The plan is the input for /speckit.tasks.

Constitutional compliance gates

Look for a Phase -1: Pre-Implementation Gates section in the plan. These are automatic checks (simplicity, anti-abstraction, integration-first) derived from your constitution. If a gate fails, the plan documents why and how to address it before building.

Read the plan before generating tasks

Open plan.md and verify:

  • The file structure lists every file that will be created and nothing is missing.
  • The Phase -1 constitutional compliance gates all pass. If one failed, the plan explains why; fix the spec or constitution before continuing.
  • The architecture matches the stack you specified in the prompt.

"I am running this company like a well-oiled machine. Read the oil levels first." - Michael Scott (probably). Run /speckit.tasks only when you are satisfied with what is in the plan.


Step 5: Generate the task list with /speckit.tasks โ€‹

With the plan in place, break it into an executable task list:

/speckit.tasks

What changes: specs/001-[your-domain]-tracker/tasks.md is created with a dependency-ordered list of implementation tasks. Each task maps to a specific file or behavior from the plan. This is the direct input for /speckit.implement.


Step 6: Run /speckit.implement โ€‹

With a plan in place, run:

/speckit.implement

What changes: Copilot reads plan.md (and tasks.md if present) and begins generating the actual code, tests, and documentation. You will see files being created and edited in real time. Each task is marked complete as it finishes.

Time check

/speckit.implement can run for several minutes on a non-trivial plan. If you are short on time, stop after /speckit.plan; the spec + plan are the primary deliverables for this hour. You can run implement later or switch to the baseline.

What changes after each command โ€‹

CommandPrimary outputKey things to look for
/speckit.constitution.specify/memory/constitution.md updatedPrinciples named, rationale present, version incremented
/speckit.specifyspecs/NNN-*/spec.md createdUser stories, acceptance criteria, [NEEDS CLARIFICATION] markers, scope boundary
/speckit.planspecs/NNN-*/plan.md createdArchitecture rationale, file structure, constitutional compliance gates
/speckit.tasksspecs/NNN-*/tasks.md createdDependency-ordered task list, each task maps to a file or behavior from the plan
/speckit.implementCode, test, and doc files created/editedTasks ticked off, tests passing, no files outside the plan's file list

Checkpoint โ€‹

  • specify --version returns a version.
  • .specify/memory/constitution.md exists and has named principles.
  • specs/NNN-*/spec.md exists with user stories and acceptance criteria.
  • Your spec has a lifecycle requirement with named statuses, transition rules, and at least one rejected transition.
  • Your spec has a role table with at least three roles and a clear privileged-role boundary.
  • Your spec has at least six named domain event types and an envelope schema.
  • Your spec has at least three bounded personas.
  • Your spec has a scope boundary ("what we will not build") section.
  • specs/NNN-*/plan.md exists with a file structure and constitutional compliance gates.
  • specs/NNN-*/tasks.md exists with a dependency-ordered task list.

See How checkpoints work. If you're not there yet, switch to the baseline below.

Fallback baseline โ€‹

Try it yourself first. If you run out of time, adopt the provided baseline spec so you start the next segment in the right place:

Functional requirements (baseline) โ€‹

  • FR-PM-001 โ€” Package lookup: The system MUST return a package's current status, route, and condition given a package or order identifier. Acceptance: a known package returns exactly one record; an unknown identifier returns a clear "not found", never a guess.
  • FR-PM-002 โ€” Order status: The system MUST report an order's status (pending, in transit, delivered, exception). Acceptance: status matches the source record; ambiguous orders return a disambiguation prompt.
  • FR-PM-003 โ€” Route awareness: The system MUST identify which route a package is on and list other packages on that route when asked. Acceptance: only packages truly on the route are returned; none are invented.
  • FR-PM-004 โ€” Label interpretation: The system MUST parse a shipping label into structured fields (order, fragile flag, route). Acceptance: a valid label yields all three fields; a malformed label is rejected with a reason, not silently accepted.

Memory requirements (baseline) โ€‹

  • MR-001 โ€” User preference memory: The system MAY remember a user's display preferences (for example, Stanley's collapsed statuses) across sessions. For whom: that user only. For how long: until the user changes or clears it.
  • MR-002 โ€” Role-based behavior: The system MUST apply role-based response rules (for example, warehouse-staff concise tone) from the user's role, not from stored personal data.
  • MR-003 โ€” Working memory: Within a conversation, the system MUST remember the order or route currently under discussion so the user need not repeat it.

Never store โ€‹

  • Real customer or employee personally identifiable information (PII).
  • Credentials, tokens, or secrets of any kind.
  • Anything a persona would use to hide safety- or compliance-critical information.

Show for confirmation โ€‹

  • Before persisting a new long-term preference, the system MUST show the user what it will remember and ask for confirmation.
  • Before acting on a remembered preference that changes a consequential outcome (for example, escalation), the system MUST surface the remembered value for review.

Acceptance criteria for memory use โ€‹

  • Correct use: A remembered display preference changes only presentation; the user can inspect and clear it; nothing on the "never store" list is persisted.
  • Incorrect use (must fail review): Storing PII, persisting a preference without confirmation, or letting a remembered preference hide a safety-critical status.

baseline/04-1-spec.md contains a reference spec you can use as-is. With it in hand you are ready to continue toward MCP (Model Context Protocol) later in the day.

Troubleshooting โ€‹

  • specify: command not found: Make sure the uv tool bin directory is on your PATH. Run uv tool dir to find it, then add it to your shell profile. Or use the full path: ~/.local/bin/specify.
  • /speckit.specify produces a mostly-empty spec: Add more detail to your description. Include actors, key actions, and one or two constraints. The more specific the prompt, the richer the spec.
  • [NEEDS CLARIFICATION] markers left in spec: Either resolve them inline or run /speckit.clarify to let Copilot ask targeted questions and update the spec.
  • "My requirement isn't testable": Rewrite it so a reviewer could mark it pass or fail; add an acceptance line. See the good/bad table above. More help on Troubleshooting.
  • "I can't tell memory from retrieval": If it's a fact about the domain system (statuses, records, routes), it's domain knowledge you retrieve; if it's a fact about a user, it's memory you must scope. See Part 3, Memory for the full distinction.
  • "My persona feels like it could hide problems": Add a hard boundary: personas never override safety, privacy, or correctness.

Optional stretch task โ€‹

Intermediate: Run /speckit.clarify on your spec and resolve at least two [NEEDS CLARIFICATION] markers before planning.

Advanced: Run /speckit.analyze after /speckit.tasks to check for consistency across spec, plan, and tasks. Fix any gaps it identifies before running /speckit.implement.

Expert: Sketch a policy/middleware layer requirement in your spec: one place every request passes through that enforces the "never store" list, the persona boundaries, and role-based access rules. Describe its inputs, what it blocks, and what it logs, still as a requirement, not code. This previews the governance layer you will need when agents operate against your application in the later parts.

Source-backed background โ€‹

  • Spec Kit: github.com/github/spec-kit. The README, spec-driven.md, and official docs at github.github.io/spec-kit are the primary sources for all SDD concepts and slash-command behavior.
  • Microsoft Agent Framework (used in Plan and Implement): Microsoft Learn and the official repository.
  • Microsoft Foundry (formerly Azure AI Foundry): Microsoft Learn.
  • Treat the Spec Kit memory model as design choices and trade-offs; the frameworks offer building blocks (conversation state, stores, policies), not a single mandated architecture. Verify any specific capability against the official docs before relying on it.

Apply it: De LeesLantaarn โ€‹

Apply it to your own solution

Model a slice of De LeesLantaarn with the same tools. What are the roles (member, librarian/ admin) and their hard boundaries? Name at least six domain events (for example loan.created, loan.returned, backorder.placed, backorder.available, subscription.changed, recommendation.generated). Write one persona (say, a member-facing advisor) and the one thing it is explicitly not allowed to do.

What we will not cover โ€‹

  • Installing or configuring uv beyond the install step above; see the uv docs for advanced usage.
  • Building persistent memory stores; we specify memory behavior this hour and implement it properly in later parts when the full application is in place.
  • Connecting to a real user database (covered in later parts).
  • Implementing authentication or authorization.
  • Letting personas override safety, privacy, or correctness.
  • Prescribing one universal memory architecture.
  • Spec Kit extensions, presets, or bundles (advanced customization beyond the core commands).

Previous: Part 3, Memory ยท Next: Part 5, MCP fundamentals