AACE AI SW
👤ParticipantACE AI SW
DAY 03 · WEDNESDAY · DESIGN · 2-DAY INTENSIVE

Build an AI dev team with gstack,
design with documents

On Day 2 you saw that "AI can't build what isn't in the prompt". Today you learn the answer. In Part 1 you learn gstack, a workflow that gives AI roles, order and quality standards. In Part 2 you practice document-based design: creating and checking Markdown specs with gstack.

This is an intensive course that fits 2 days into one. Sessions A–D happen in class; the advanced session continues as homework and self-study.

2-Day Content · 1-Day Intensive

Today's Schedule

First understand gstack (Part 1), then use it for document-based design (Part 2). The advanced session continues as homework after class.

SESSION A · 90 min · PART 1

Understand & install gstack

  • Day 2 retro: why AI built it differently
  • gstack's 3 principles · roles · map of 53 skills
  • Install Codex / Claude Code, register gstack
  • Make a git checkpoint
Slides P1 · 1–9
SESSION B · 90 min · PART 1

gstack planning loop lab

  • /office-hours with the Focus List example
  • Given/When/Then with /spec
  • /plan-ceo · design · eng-review
  • Review · QA · release and the 4 human approvals
Slides P1 · 10–15
SESSION C · 120 min · PART 2

From conversation to MD spec

  • Student draft + 5 questions first
  • Separate facts · assumptions · questions · decisions
  • Split responsibilities across 4 folders
  • Create screen · data · API MD with gstack
Slides P2 · 1–10
SESSION D · 90 min · PART 2

Check and confirm the docs

  • REQ→UI→DATA→API→TEST trace table
  • Find contradictions with cross-audit · plan-review
  • Design review verdict and DECISION_LOG
  • Write the build contract
Slides P2 · 11–13
Advanced · homework · self-study

Build and verify the service

  • Build by requirement ID, following the doc contract
  • Verify with /review · /qa-only · /qa
  • Defect report and re-check
  • Retro: AI suggestions vs human judgment
PBL Missions 3 · 4

HTML Presentation

Day 3 Slides

Use the tabs to switch between Part 1 (gstack) and Part 2 (document-based design). Move with ←/→, and open lecture notes with the N key or the button.

ACE AI SW Startup Training · Day 3 · Part 1

Before asking for code,
design the dev team.

gstack is not a coding model. It's a development workflow that gives AI roles · order · quality standards.

One AITHINKDefine problemPLANReview planREVIEWReview evidenceTESTVerify · release
ThinkDefine the problem and users first
PlanReview the plan from product, design and tech views
ReviewReview change risks and causes with evidence
TestVerify with real user behavior, then release
Bridge from Day 2

Why was yesterday's AI result different from my design?

Missing from promptWhat I didn't say didn't exist for AI→ Fix: pass everything on in documents (specs)
AI averagingAI filled vague parts with common patterns→ Fix: separate facts, assumptions and decisions
No verificationI believed AI when it said "done"→ Fix: check evidence with role-based review and QA
Today's answer: control the order AI works in with gstack, and remove room for AI to guess with documents.
What is gstack?

gstack = a set of role-based work guides for AI agents

An open-source skill set released by Y Combinator CEO Garry Tan (github.com/garrytan/gstack). It splits one AI into CEO, designer, engineer, reviewer and QA roles.

Claude Code (official support)

/office-hours
Summarize the target users and problem of this project.
Don't change any code yet.
  • Call directly with a slash command

OpenAI Codex

Use the gstack-office-hours skill.
Summarize the target users and problem of this project.
Don't change any code yet.
  • Call by naming the skill in plain language
Analogy · Restaurant kitchen

Think of gstack as a restaurant kitchen team

If AI does everything aloneTake ordersCookTasteServeFast but no order → mistakes found lategstackgstack: a kitchen team with rolesOwnerDecides menu & pricesCEO/office-hoursPlatingMakes it look goodDesign/plan-design-reviewChefRecipe & cookingENG/spec · buildInspectorChecks ingredients & hygieneReview/reviewTasterTastes like a customerQA/qaSame AI, but telling it which role it's in now means fewer mistakes
Where does gstack live?

gstack is not an app — it's a work manual AI reads

When you install it, a folder of guides appears on your computer, and the AI tool picks the guide that matches your command and follows it.

Me (the person)Decides what to build and approves resultsRequests in chat: /office-hours …AI coding toolConversational AI agents like Claude Code · CodexReads the matching skill guide when it gets a commandgstack skills (53 guides)~/gstack folder · each skill = a SKILL.md documentRules for "how this role should work"My projectCode · documents (MD) · git historyAI reads, writes and checks following the guide
One AI · Five hats

One slash command = one hat

Instead of memorizing commands, remember the question each role asks.

Same AICEO/office-hours"Whose problem, and what problem?"Design/plan-design-review"What about empty and error screens?"ENG/plan-eng-review"Where could it fail?"Review/review"Is there evidence for this change?"QA/qa"What if you use it like a customer?"
Why bother?

Is building right away faster? Fixing late costs more

Without gstack"Build me an app"Code generated right away"Done!"Bugs found when usedStart over?With gstackAsk about the problem/office-hoursSpec/specReview plan/plan-*-reviewBuild smallHuman approvalReview · QA/review /qaRelease/shipCost to fixPlanningSpecPlanBuildReviewAfter releaseFront part of gstack = today's Day 3The later you find a problem, the harder it is to fix (concept)
3 Principles

Today you learn a way of working, not just commands

01Don't build right awayBefore code, confirm the user problem and scope, and bring hidden assumptions to light."Whose pain does this solve, and what pain?"
02Split rolesRun product, design, tech, review and QA views as separate skills, without mixing them.No code changes during planning
03Verify resultsAI output is not an answer key. People check it with files, git diff and running it in the browser.No pass without evidence
Your AI development team

Split one AI into five roles

CEO · Product
"Whose problem, and what problem?"
User problem · value · scope
/office-hours/plan-ceo-review
→ Problem definition · MVP scope
Design
"What screens do users see?"
UX flow · screen states · visual direction
/plan-design-review/design-consultation
→ Screen flow · design principles
ENG · Tech
"Where could it fail?"
Structure · data flow · failure paths · tests
/spec/plan-eng-review
→ Spec · build plan
Review
"Is there evidence for this change?"
Defects in the diff · security · root cause
/review/investigate/cso
→ Review report by severity
QA & Ship
"What if you use it like a customer?"
Real user behavior · docs · release
/qa-only/qa/ship/retro
→ Verdict table · release checklist
HANDS-ON 0110 minPairs · quiz

Which role does this situation need?

GoalLook at a situation and choose for yourself which role (command) to call
CEO/office-hours"Whose problem?"
Design/plan-design-review"Screen states?"
ENG/plan-eng-review"Where will it fail?"
Review/review"Evidence for the change?"
QA/qa"What if you use it?"
1
Read the situationWho · what is the problem
2
Talk with partnerGive reasons for 30 sec
3
Choose a roleTap a button to check
4
Sum up the reasonWhy that role
Nobody checked whether students really want this app
✓ CEO — checking the user problem and value first → /office-hours
Nothing says how the menu screen should look when an item is sold out
✓ Design — missing screen states like empty, error and sold out → /plan-design-review
We don't know where it will fail if 100 people order at once
✓ ENG — data flow and failure paths → /plan-eng-review
The code AI changed uses innerHTML, and we're worried about security
✓ Review — defects and security in the change (diff) → /review
When ordering on a phone, the "Add" button doesn't work
✓ QA — check with real user behavior → /qa
Correct 0 / 5
0/4
Tick the boxes
to check yourself
Career linkA team-project interview question: "What do planning, design, development and QA each look at?" — the roles you chose today are your answer.
Standard end-to-end workflow

The most common gstack pipeline

Today's Day 3 focus area/office-hoursDefine problem/autoplanReview planBuild featureHuman approval/reviewCode review/qaUser testing/shipPR · release/land-and-deployDeploy/canaryMonitor after deployHuman step
/office-hoursSharpen the idea and product direction with YC-style questions
/autoplanCEO → design → engineering → DX review in one go
/review → /qaReview from a code view, then test the user flow in a real browser
/ship → /canaryWatch for errors and slowdowns after PR and deploy
Today's Day 3 focus: the front of the pipeline (problem definition → spec → plan review). The work you must finish before building.
gstack skill map · 53 skills

Remember 53 skills as 10 categories

Browser · QA10browse · qa · qa-only · benchmark · canary …Planning · design8office-hours · autoplan · spec · plan-*-reviewUsed todayCode quality8review · investigate · cso · health …Deploy · docs6ship · land-and-deploy · document-release …Memory · state5context-save · context-restore · learn …iOS5ios-qa · ios-fix …Safety guards4careful · freeze · guard · unfreezeDesign · build3design-consultation · design-shotgun · design-htmlDocs · visual2diagram · make-pdfUsed todayOperations2retro · gstack-upgrade
Don't memorize all 53. Just know "which stage am I in?" and look it up in the command dictionary below.
Setup · 15–60 min

Install: check tools → register gstack → check status

1. Check toolsgit · node · bun · AI tool2. Get gstackgit clone → ~/gstack3. Register · check statussetup --host · --status

macOS · Linux · WSL

# 1. Check versions
git --version && node --version && bun --version
codex --version   # or claude --version
# 2. Get gstack + register host
git clone --single-branch --depth 1 \
  https://github.com/garrytan/gstack.git ~/gstack
cd ~/gstack
./setup --host codex   # or --host claude
./setup --status

Windows (PowerShell)

winget install --id Git.Git -e
winget install OpenJS.NodeJS.LTS
powershell -c "irm bun.sh/install.ps1|iex"
git clone --single-branch --depth 1 `
  https://github.com/garrytan/gstack.git "$HOME\gstack"
cd "$HOME\gstack"
.\setup.ps1 --host codex
.\setup.ps1 --status
  • If setup.ps1 is blocked: -ExecutionPolicy Bypass -File .\setup.ps1
  • If skills don't show: close the tool → new terminal → check --status again
Golden rule

Before and after AI work, always check with git

Make a save pointgit commitLike a save point in a gameGive AI the taskRun a gstack skillAI changes filesWhat changed?git status · git diffCheck evidence, not wordsIf you don't like itgit restoreGo back to the save point

Lab starting checkpoint

cd lab-folder/project
git init
git add .
git commit -m "Lab start state"
# After AI work
git status
git diff

4 checks in the AI approval window

  • ① Is it running git clone / setup right now?
  • ② Is the repo the official garrytan/gstack?
  • ③ Does it work only inside my home folder?
  • ④ Are there no delete or force-overwrite commands?
Verify AI's explanation with real files · git diff · browser results. Evidence, not words.
HANDS-ON 0215 minSolo · terminal

Make a git save point yourself

GoalSet things up so that even if AI changes files, you can check and undo at any time
1
Save pointgit commit
2
AI workRun a gstack skill
3
Check changesgit status · git diff
4
Roll backgit restore
AnalogyJust like saving before a boss fight in a game, always save before giving AI a task.

Run in order · use the copy buttons

1
Make a save pointgit init && git add . git commit -m "Lab start state"
2
Give AI the task/office-hours (… don't change any files yet)
3
Check what changedgit status && git diff
4
Roll back if you don't like itgit restore .

4 checks in the AI approval window

0 / 4
0/4
Tick the boxes
to check yourself
Career linkUsing git is the most basic skill for developer jobs. Your GitHub commit history becomes your portfolio.
Step 01 · DISCOVER · no code changes

/office-hours — ask why before what to build

ProblemSpecPlanBuildReviewQARelease← You are here

prompt

/office-hours
Summarize Focus List's target users, current alternatives,
core problem and minimum feature to test.
Don't change any files yet.

Example result

  • Target user: learners managing classes and assignments at the same time
  • Core problem: hard to quickly pick the one thing to do now
  • Minimum feature to test: add a task and mark it done within 3 seconds
  • Assumption to test: they want fast input more than categories
Output: 1-sentence problem definition · 1 user · 3 assumptions → becomes PROJECT_BRIEF.md in Part 2.
HANDS-ON 0315 minPairs → solo · judge

/office-hours result: pass or fail?

GoalDon't just trust the AI result — judge it by user · problem · assumption

✓ Pass rule

The target user is specific
The problem is written as a real pain
There is at least 1 assumption to test

✗ Fail signs

Only lists feature names ("notifications, categories…")
Vague words like "everyone" or "productivity"
No questions or assumptions to check
1
Judge 3 examplesTap pass / fail
2
Get my resultRun /office-hours
3
With the same ruleJudge my result
4
Sum up in 1 sentenceWrite the problem definition
AI result A
To-do app for students
Features: add · delete tasks
          categories · reminders
Only feature names — no whose pain or what pain, and no assumption to test.
AI result B
Target: learners managing
        classes and assignments at once
Problem: hard to quickly pick
         the one thing to do now
Assumption: fast input over categories
User · problem · assumption to test are all visible. Pass!
AI result C
Target: everyone
Problem: low productivity
Solution: AI schedule recommendations
The target is too broad, the problem is vague, and there's no assumption to test.
0/4
Tick the boxes
to check yourself
Startup tipThe first slide of a startup pitch is always "whose problem, and what problem". A pitch that starts with a feature list won't convince investors.
Step 02 · SPEC · no code changes

/spec — turn it into testable requirements

ProblemSpecPlanBuildReviewQARelease← You are here

prompt

/spec
Write normal/exception scenarios and acceptance criteria
for empty input, duplicate items and long titles
in Given/When/Then.
Don't build anything yet.

Example result · Given / When / Then

GivenSituationWhen only spaces are typed
WhenActionand you press "Add"
ThenResultthe item count stays the same · "Please enter text" is shown
Out of scope login · server storage · categories
Test: can a third person look at the screen and judge pass/fail the same way?
HANDS-ON 0415 minSolo → pairs · write

Write Given / When / Then yourself

GoalWrite acceptance criteria anyone can judge pass/fail the same way
GivenIn what situation — when only spaces are typed
WhenDo what — press the "Add" button
ThenWhat you see — the item count stays the same and "Please enter text" is shown

✗ Can't judge

Then: handles errors well

✓ Can judge

Then: the item count stays the same and "Please enter text" is shown

Pick a scenario

Acceptance-criteria card · live

Given…
When…
Then…
Fill the blanks and it tells you whether it can be judged
0/4
Tick the boxes
to check yourself
Career linkWriting testable requirements is a practical skill used right away in QA, planning and developer jobs.
Step 03 · PLAN · no code changes

The same spec, reviewed through three lenses

Same specCEODesignENG
ProblemSpecPlanBuildReviewQARelease← You are here
/plan-ceo-reviewProduct value · scope · priority. "What do we cut from this release?"
/plan-design-reviewUI/UX plan. Check for missing empty, error and mobile flows
/plan-eng-reviewChanged files, data flow, failure paths, tests, build order
Example plan-eng-review result
Data flowInput → trim → empty check → duplicate check → add to array → render
Failure pathsSpaces, case-insensitive duplicates, titles over 100 characters, fast repeated clicks
Build orderInput validation → duplicate rule → screen states → regression tests
Step 04–08 · BUILD → REVIEW → QA → SHIP

After building: build small, verify in parts

ProblemSpecPlanBuildReviewQARelease← You are here
BuildBuild one feature at a time from the approved spec → git diff → commitChanges allowed from here
/review · /investigateSeverity, file evidence and how to reproduce in the diff. Reproduce before finding the causee.g. innerHTML → textContent
/qa-only → /qaFirst a verdict table without changes, then fix after approvalNormal · empty · duplicate · mobile
/cso · /ship · /retroSecurity · performance · doc sync → release → retro/document-release
qa-only verdict tableExpected resultActual resultVerdict
Spaces onlyNot addedEmpty item addedFAIL
Normal input1 item added1 item addedPASS
Human checkpoints

Four points where AI stops and a person decides

/office-hours/spec · planBuild/review · /qa/ship① Problem approvalConfirm whose problem and what problem② Scope approvalDecide what to cut from this release③ Defect approvalDecide what to fix now④ Release approvalDecide whether to accept the remaining risksYellow door = where AI stops and a person decides → record in DECISION_LOG.md
Record every approval in DECISION_LOG.md with the reason, owner and review criteria. (Written in Part 2)
Part 1 wrap-up

Done means not "I ran it" but
evidence and human judgment

EnvironmentCheck tools and gstack registration
Skill choiceCall the role that fits the stage's goal
Evidence checkVerify with files, diffs and real behavior
Quality reportReproducible review and QA results
Human judgmentSeparate AI assumptions from final decisions
Define problem→Requirement spec→Multi-view plan→Confirm in docs (Part 2)→Small build→Review · QA
Day 3 · Part 2 · Document-driven design

From conversation to spec,
from spec to service.

Organize requirement conversations into Markdown contracts people can review, check them with gstack, and build using only those documents as the basis.

01 · Sort the conversationFACT · QUESTION · DECISION25 pts · 3–4h
02 · Design the specUX · DATA · API · QA25 pts · 4–6h
03 · Build the serviceBUILD · TRACE · TEST30 pts · 6–9h (advanced)
04 · Verify design & serviceVERIFY · EVIDENCE · RETRO20 pts · 3–5h (advanced)
01 Sort conversation · 25 pts3–4h02 Design spec · 25 pts4–6h03 Build service · 30 pts6–9h · advanced04 Verify · 20 pts3–5h · advanced100 points totalToday's Day 3 covers up to here (50 pts)
Why documents?

A doc is not a report — it's a build contract with AI

Grey out sold-out items?Can people pay too?Admin on PCAre options required?Cancelling orders…?About 100 orders a day?Scattered conversation · AI guesses the blanksREQ-009Sold-out items can't be orderedUI-C02 · TEST-011REQ-004Can't add to cart without required optionsUI-C03 · TEST-007DEC-003Payment is out of the MVPReason · owner · reviewContracts with IDs · everyone judges the same way

Developing by chat only

  • Requirements are scattered across chat history
  • AI fills the blanks as it likes (assumptions become facts)
  • Customer and admin screens don't share the same data
  • Nobody can judge "what counts as done"

Document-based development

  • Every requirement has an ID linked to screens, data and tests
  • Facts, assumptions and decisions are separated, so guesses show up
  • Both screens share a common data contract
  • PASS/FAIL is judged by acceptance criteria
Project scenario

Lab service: mobile ordering + PC admin

"Customers order sandwiches and drinks on their phones, and the admin manages the menu, stock and order status on a PC."
OrderCustomer · mobileCreate orderShared datamenu · orderChange statusReceivedCookingReady for pickupCompletedAdmin · PC

📱 Customer ordering (Mobile 360–430px)

  • Browse menu → details · choose options
  • Add to cart · change quantity
  • Complete order and see order number
  • Handle sold out · missing required option · empty cart

🖥️ Store admin (PC 1280px+)

  • Live new-order alerts and list
  • Change status: received → cooking → ready for pickup → done
  • Menu & sold-out management, sales stats
  • Permissions and confirm steps to prevent mistakes
Mission 01 · Student-first rule

Before opening AI, start with your draft and 5 questions

① One-sentence definitionTarget user · problem · key action · out of scope, in your own words
② Core flow draftDraw 3–5 customer steps and 3–5 admin steps yourself
③ 5 unknown questionse.g. Who changes sold-out status, and when? Can orders be cancelled?
Without a draft, you have no standard to judge the AI result. The student owns the decisions, not AI.
HANDS-ON 0515 minSolo · draft

Before opening AI: your draft and 5 questions

GoalFirst create your own standard (draft + questions) for judging the AI result
1
One-sentence definitionWho · what · why
2
Core flow3–5 customer steps
3
5 unknown questionsThings to check
4
Then AICompare with draft

Good question examples

① One-sentence definition

…

② 5 unknown questions

0 / 5
0/4
Tick the boxes
to check yourself
Career linkThe habit of writing a draft first is the difference between "someone who uses AI" and "someone dragged along by AI".
Mission 01 · Frame

Split the conversation into facts · assumptions · questions · decisions

Requirements conversationFACTFact · stated in the conversation"The admin changesorder status on a PC"ASSUMPTIONAssumption · guess by AI or team"There will be under100 orders a day"QUESTIONQuestion · needs checking"Can customers cancelafter the order is received?"DECISIONDecision · reason · owner · review"Payment is outof the MVP (DEC-003)"
/office-hours
Sort the following requirements conversation into [Fact], [Assumption], [Question] and [Decision].
Don't invent new facts, and separate customer-mobile and PC-admin requirements.
Suggest missing exception and data-consistency questions with priorities. Don't create any files yet.
HANDS-ON 0615 minTeam · sorting game

Sort conversation sentences into four boxes

GoalSeparate facts from guesses in a requirements conversation so AI can't turn guesses into facts
FACTFactStated in the conversation
ASSUMPTIONAssumptionGuess by AI or team
QUESTIONQuestionNeeds more checking
DECISIONDecisionReason · owner · review
HintIn the meeting notes → fact · "probably…" → assumption · question mark → question · has owner and review → decision
Meeting notes: "Customers order on their phones"
Answer: FACT
Orders will probably pile up at lunchtime
Answer: ASSUMPTION
Can customers cancel after the order is received?
Answer: QUESTION
Payment is out of the MVP — owner PM, review in 2 weeks
Answer: DECISION
Meeting notes: "The admin changes sold-out status on a PC"
Answer: FACT
Drinks will probably need size options
Answer: ASSUMPTION
0 / 6 sorted
0/4
Tick the boxes
to check yourself
Career linkPeople who separate facts from guesses in meetings become trusted teammates on any team.
Project structure

Four folders, four responsibilities

kiosk-pbl/
├── PROJECT_BRIEF.md · DECISION_LOG.md        # Mission 1 output
├── service-planning/      # Planning · spec: requirements, shared policy, screen specs, design concept
│   ├── common/service-policies.md
│   ├── customer-order/  mobile-screen-spec.md · order-flow.md
│   ├── admin/           pc-screen-spec.md · admin-features.md
│   └── design-concept.md
├── service-analysis/      # Metrics · analysis: KPIs, event definitions, analytics API
│   └── analysis-definition.md · analytics-api-definition.md
├── service-implementation/ # Build: customer · admin · shared data store
└── service-validation/    # Verification: design check · service check · test data · reports
    └── design-validation-plan.md · service-validation-plan.md · test-data.md
Planning · specservice-planning/Requirements · policy · screen specsMetrics · analysisservice-analysis/KPIs · events · analytics APIBuildservice-implementation/customer · admin · sharedVerificationservice-validation/Design · service checks · reports
Mission 02 · MD blueprint package

A buildable Markdown spec package

DocumentContentsDone signal
mobile-screen-spec.mdMenu browse · details · options · cart · done + loading · empty · sold out · error · recovery states8 screens, acceptance criteria per screen
pc-screen-spec.mdOrder board · state transitions · menu/sold-out management · permissionsState transition rules stated
design-concept.mdColors · type · spacing · status colors, principles to borrow / assets not to copyFresh Route principles
MENU_DATA10+ made-up menu items: menu_id, category, base_price, options, stock, is_availableUnique IDs · option groups · stock rules
analysis-definition.mdEVT IDs, trigger conditions, properties, metrics (no personal data)menu_viewed → order_completed
analytics-api-definition.mdRequests · responses · error codes, order state transitionsAPI-### definitions
design-validation-plan.mdRules for checking consistency between docsHow to judge each verification item
How to write a screen spec

One screen = purpose · info · actions · next state · acceptance criteria

## UI-C03 — Menu detail · choose options  (REQ-004, REQ-005)
- Purpose: customer picks bread, sauce and size and sees the final price
- Info shown: menu name, description, base price, option groups (required/optional), live total
- Actions: choose options, quantity +/-, [Add to cart]
- Next state: added → toast + cart badge goes up (UI-C04)
- States: normal / sold out (add button disabled) / required option not chosen (message) / save failed (retry)
- Acceptance criteria:
  - Given required option not chosen When [Add] Then not added + "Please choose bread" shown
  - Total = (base_price + option extras) × quantity
Menu imageChicken sandwich₦3,500Choose bread (required)WhiteWhole wheatSauce (optional)Chili +200Mayo− 1 +Total ₦3,700Add to cartRequired option not chosen → messageOption extras includedTotal = (base + extras) × quantityButton disabled if sold outUI-C03 wireframe (made-up menu)
HANDS-ON 0720 minTeam · write spec

Fill in the screen spec: 5 elements + 5 states

GoalSpec one screen so AI can build it without guessing
PurposeWhat this screen achieves
InfoWhat it shows
ActionsWhat you tap
Next stateWhere it goes
AcceptanceGiven/When/Then

Not just normal · 5 states

Normal
Empty list
Sold out
Error
Recovery

UI-C02 · Menu list (REQ-001, REQ-009)

Mark the states written in the doc

Completeness
0 / 10
0/4
Tick the boxes
to check yourself
Career linkA screen spec is output you can put straight into a product designer or PM portfolio.
Traceability

Every requirement is linked by ID all the way through

REQ-009Requirement · sold-out items can't be orderedUI-C02Screen · sold-out mark · button disabledDATAData · is_available · stockAPI-004API · stock check responseTEST-011Test · try ordering sold-out item → blocked
REQRequirementUIDATAAPITEST
REQ-004Can't add to cart without choosing required optionsUI-C03menu.options[].required—TEST-007
REQ-009Sold-out items can't be orderedUI-C02, UI-A05menu.is_available, stockAPI-004TEST-011
REQ-012Admin changes order status only in orderUI-A03order.statusAPI-006TEST-015
A blank cell? → where the doc breaks = where AI will fill in by guessing.
HANDS-ON 0810 minPairs · find game

Find broken chains in the trace table

GoalKnow that a blank in the trace table = where AI will guess, and find and block them first
1
Read the trace tableREQ → UI → DATA → API → TEST
2
Find blanksRows with "?"
3
Check answerWhat's missing
4
Check our tableThe same way
WarningIf you give AI a requirement with blanks, AI fills them with an average guess.
REQRequirementUIDATAAPITEST
REQ-009Sold-out items can't be orderedUI-C02is_availableAPI-004?Tap to mark
REQ-012Status changes only in order?order.statusAPI-006TEST-015Tap to mark
REQ-015Show order numberUI-C05order.numberAPI-002TEST-018Tap to mark
REQ-017Only admin can change sold-outUI-A05??TEST-020Tap to mark
Tap the broken rows to mark them
0/4
Tick the boxes
to check yourself
Career linkManaging a trace table is especially valued in government, finance and large-company projects.
gstack × Markdown · Session C

The order for making MD specs with gstack

stagesgstackMD producedWhat people do
1/office-hoursPROJECT_BRIEF.mdCompare with my draft, approve the problem
2/office-hours (sorting)DECISION_LOG.mdConfirm facts · assumptions · questions · decisions
3/specREQUIREMENTS · screen spec MDCheck acceptance criteria can be judged
4/plan-design-reviewdesign-concept.md · add statesCheck the no-copy boundary
5/plan-eng-reviewMENU_DATA · API · analytics definitionsFix the data contract
6/diagramOrder flow · state transition diagramsCheck docs and diagrams match
7/plan-ceo-reviewUpdate MVP in/out scopeApprove scope → record DEC
Validate the design · Session D

Verify documents with gstack

Cross-audit prompt

/plan-eng-review
Cross-review the service-planning, service-analysis
and service-validation documents.
Don't add new requirements; only find:
1. Mismatched terms, IDs and order status values
2. Features on screens with no DATA/API
3. Vague done criteria that can't be measured
4. Privacy, payment and permission risks, and questions people must decide
Don't change any files.

Design verification check

  • Terms, REQ IDs, status values and field names match in every doc
  • Every key REQ links to acceptance criteria and a TEST
  • Data flow is unbroken from customer order creation to admin status change
  • No missing permissions, privacy exclusions or exception handling
  • Record the accept / change / reject reason for every AI finding
Build contract · prep for the advanced session

Build one requirement ID at a time, docs first

Use only the approved MD documents in service-planning and service-analysis as the basis for building.
This build covers only [REQ-___ / screen ID].
Before writing code, report the related doc paths, files to change and anything unclear;
after building, summarize the changed files, how to run it and results per acceptance criterion.
Check doc ID→Build minimum scope→/review · /qa-only→AI_WORK_LOG→Next REQ
Need to build something different from the docs? Fix the DECISION_LOG and spec before the code.
Day 3 deliverables & takeaway

Today's outputs → the only basis for tomorrow's build

gstack logoffice-hours · spec · plan-review results and my judgment
FramingPROJECT_BRIEF.md · DECISION_LOG.md
Spec package2 screen types · menu data · analytics/API · design
VerificationTrace table · design review result · AI accept/reject log
AI is the fast hands. gstack gives those hands order, docs give direction, and people make the final call.
AIFast hands+gstackOrder+DocumentDirection+PeopleFinal call=Service
P1 · 1 / 15
LECTURE NOTE

Hands-on Lab Guide

Lab guide: creating and verifying MD with gstack

Copy each step's prompt and paste it into Claude Code (/command) or Codex (use the gstack-command skill). After every step, a person reads and fixes the result before moving on.

stagesgstackInputOutput (MD)Human check · pass condition
0. Preparegit initkiosk-pbl folder, 4 subfoldersREADME.mdCommit a git checkpoint · write 1 line per folder's responsibility
1. My draft— (no AI)Service in one sentenceMY_DRAFT.mdUsers · core flow · out of scope · 5 questions
2. Define problem/office-hoursMY_DRAFT.md · requirements conversationPROJECT_BRIEF.mdIs it explained as user pain, not feature names?
3. Sort conversation/office-hoursRequirements conversation logDECISION_LOG.mdFacts · assumptions · questions · decisions separated · each decision has reason and owner
4. Requirement spec/specBRIEF · DECISION_LOGREQUIREMENTS.md · mobile/pc-screen-spec.mdREQ IDs · Given/When/Then · normal, empty, sold-out, error states
5. Design review/plan-design-reviewScreen specsdesign-concept.mdPrinciples to borrow / assets not to copy · accessibility standards
6. Tech review/plan-eng-reviewRequirements · screen specsMENU_DATA · analytics-api-definition.md10+ menu items · state transitions · error codes · no personal data
7. Visualize/diagramOrder flow · state transitionsorder-flow.md (Mermaid)Do the status values in the diagrams match the docs?
8. Confirm scope/plan-ceo-reviewFull specUpdate DECISION_LOG.mdMVP in/out · scope approval
9. Trace table/spec or by handAll MDTRACEABILITY.md0 blanks in REQ→UI→DATA→API→TEST
10. Design check/plan-eng-review (audit)All MDdesign-validation-plan.md · resultsRecord accept/change/reject reason for each AI finding

① Sort conversation → DECISION_LOG

/office-hours (Codex: gstack-office-hours skill)

/office-hours
Read the requirements conversation below and my draft (MY_DRAFT.md)
and create a DECISION_LOG.md draft.
- Sort each item into [Fact] [Assumption] [Question] [Decision]
- Don't invent facts that aren't in the conversation
- Separate customer (mobile) / admin (PC) / operations requirements
- Leave the reason · owner · review-criteria fields blank for [Decision]
- Suggest missing exception and data questions with priorities
Don't write any code.

② Requirement spec → screen spec MD

/spec (Codex: gstack-spec skill)

/spec
Using only PROJECT_BRIEF.md and the [Decision] items in DECISION_LOG.md,
write service-planning/customer-order/mobile-screen-spec.md.
- For each screen, a UI-C## ID and linked REQ-### IDs
- Purpose / info shown / actions / next state / acceptance criteria
- Normal · loading · empty · sold out · missing required option · save failed · recovery states
- Acceptance criteria in Given/When/Then, judgeable by a third person
- Mark anything that is an [Assumption] as "needs checking"
Don't build anything yet.

③ Data · API contract

/plan-eng-review (Codex: gstack-plan-eng-review skill)

/plan-eng-review
Review the mobile and PC screen specs and propose:
1. MENU_DATA: at least 10 made-up menu items
   (menu_id, category, name, base_price, options, stock, is_available)
2. Order state transitions: received → cooking → ready for pickup → done / cancel rules
3. API-### requests · responses · error codes
4. The data contract the customer and admin screens must share
5. Analytics events (EVT-###) — no names, phone numbers, addresses or raw payment data
Show me only the doc drafts, and save files after I approve.

④ Cross-audit docs (design verification)

/plan-eng-review or /plan-ceo-review

Cross-review all MD in the service-planning, service-analysis
and service-validation folders. Don't add new requirements; find:
1. Mismatched terms · IDs · order status values between docs
2. Features in screen specs with no DATA/API definition
3. Blanks and broken links in TRACEABILITY.md
4. Vague acceptance criteria that can't be observed or measured
5. Privacy · payment · permission · copyright risks and questions people must decide
Show results as a table (doc / location / problem / suggestion / severity) and don't change any files.

DECISION_LOG.md template

## DEC-001 — [decision title]
- Type: fact / assumption / question / decision
- Source: conversation line n · MY_DRAFT · /office-hours result
- Content:
- Reason:
- Owner:
- Alternatives and why rejected:
- AI suggestion handling: accept / change / reject + reason
- Review criteria: (when to look at this decision again)

TRACEABILITY.md template

| REQ | Requirement (one sentence) | UI | DATA | API | EVT | TEST | Status |
|---|---|---|---|---|---|---|---|
| REQ-001 | Customers browse menu by category | UI-C02 | menu.category | API-001 | EVT-001 | TEST-001 | Designed |
| REQ-004 | Can't add to cart without required option | UI-C03 | menu.options[].required | — | — | TEST-007 | Designed |
| REQ-009 | Sold-out items can't be ordered | UI-C02 · UI-A05 | menu.is_available | API-004 | — | TEST-011 | Needs check |

Command Cheat Sheet

gstack Commands Used Today

In Claude Code use /command; in Codex say "use the gstack-command skill to …". For all 53, see the command dictionary in the gstack classroom.

CommandUseWhen we use it today
/office-hoursSharpen the idea and product direction with YC-style questionsProblem definition · sorting the conversation
/specTurn vague requirements into a detailed, actionable specWriting requirement and screen specs
/plan-ceo-reviewReview product value, scope and priority from a CEO viewConfirming MVP scope
/plan-design-reviewReview the UI/UX plan from a designer's viewAdding screen states · design concept
/plan-eng-reviewReview architecture, data flow, exceptions and test planData/API contract · cross-audit
/autoplanRun CEO → design → engineering → DX review in one goAfter you're used to the individual reviews
/plan-devex-reviewReview the developer-experience plan for APIs, CLIs, SDKs and docsCheck API docs (optional)
/diagramTurn descriptions into Mermaid, Excalidraw, SVG or PNG diagramsOrder flow · state transition diagram
/make-pdfConvert Markdown to PDF, HTML or DOCXSpec package for submission
/design-consultationPropose a product design system and visual directionDesign concept (optional)
/document-generateWrite missing docs using the Diataxis approachImprove README · guides
/reviewCode review of the current branch or changesAdvanced: after building
/investigateInvestigate the root cause of a bug, then fix itAdvanced: defect cause analysis
/qa-onlyWrite only a QA report, without changesAdvanced: service verification table
/qaTest a web app and fix the bugs foundAdvanced: fix after approval
/careful · /freezeWarn about risky commands · block edits outside the chosen folderProtect code during planning
/context-save · /context-restoreSave and restore work progressWhen continuing the 2-day work
/ship · /retroTests · review · create PR · write retroAdvanced: wrap-up

10-Day Course Navigation

Click the buttons above to go to the Day 1–10 learning pages.

Learning Workspace

gstack Planning Videos & Day 3 AI Helper

Videos are ordered: understanding gstack → installation → planning workflow → document (spec)-based development.

Related YouTube VideosDay 3 recommended materials
  • Understanding gstack
  • 1. Harness engineering – getting Claude Code and Codex to work properly with gstackgstack role splitting and using both toolsKR
  • 2. How to Make Claude Code Your AI Engineering TeamRunning AI as a dev team with rolesEN
  • 3. gstack Explained: Is It Right for You?gstack's skill set and whether it fits youEN
  • 4. YC’s Garry Tan: Use this Claude skill to Build 10x FasterHow gstack's creator uses itEN
  • 5. YC CEO Shipped 100 PRs/Week — His 8 Claude Code Skills (gstack)The 8 key skills explainedEN
  • 6. Gstack Is Not What I Expected — Non-Engineer ReviewA review from a non-developer's viewEN
  • Install · setup
  • 7. How to Set Up Gstack Locally in VSCode Using Claude CodeLocal install with VS Code + Claude CodeEN
  • 8. GStack GitHub Install Guide: Garry Tan’s AI Workflow for Claude CodeGitHub install · browser QA · LinuxEN
  • Planning workflow
  • 9. [Korean subs] A workflow using GStack + GSD + Superpowers togetherCombining plan → execute → verify workflowsKR
  • 10. How GStack + Superpowers completely changed my Claude Code useReal-use review and changes in work styleKR
  • 11. The Y Combinator CEO Just Open-Sourced His Entire AI SetupIntro to the office-hours → plan → review flowEN
  • Doc · spec-based development
  • 12. Why you end up rewriting when you ask AI for code firstThe rework that comes from coding without designKR
  • 13. Vibe coding with AI like a pro – a SpecKit guideHands-on with a spec-driven dev toolKR
  • 14. Spec-Driven Development with Claude Code: A Practical GuidePractical guide: spec → plan → buildEN
  • 15. Create PRDs in Minutes with Claude Code & Codex (4 Proven Workflows)4 ways to write PRDs with AIEN
  • 16. Stop Vibe Coding Without a Plan (Do This First)Why a plan document matters before buildingEN

Videos are embedded public YouTube videos. If playback is restricted by the uploader, open them directly on YouTube.

Day 3 · Daily Feedback

Today's Course Satisfaction Survey

After Day 3 class, please answer a short survey. Your answers help us improve the next class and the course.

Open Day 3 SurveyJoin with the button or QR code
Day 3 Daily Feedback Survey QR codeSCAN TO OPENNigeria AI Training · Day 3