Week 1 — AI Fluency. Six 201-level skills. The 80% quit problem. Centaur and Cyborg.
Week 2 — Builder Orientation. First real prototype. Decomposition under fire.
Week 3 — Platform Training. Three deployed Power Platform tools.
Week 4 — Advanced Workshop. You mapped your frontier. You taught someone else.
Week 5 — Supervisor Orientation. Leaders learned to evaluate proposals and protect the apprentice pipeline.
Week 6 — Today. The frontier moves out from under Power Platform. You build the whole stack.
EDD · Week 6 · Course 6Recap
Today Format
~2 min
How today runs
Deck → editor → deck. Repeated ten times.
The deck is the map
Sets the stage for each module.
Holds the architecture diagram we'll return to after each build.
Marks every checkpoint and every break.
The editor is the ground
For each build module I will leave the deck and we will work in the editor.
You don't have to keep up live — checkpoints will catch you up.
If the AI's output doesn't work in 3 minutes, paste the error back. Don't manually debug AI code.
Switch cues are redReturn cues are goldSpeaker notes live on every slide2 breaks · 15 min each
EDD · Week 6 · Course 6Format
Operating Principles
~3 min
Six principles for the day
Carry these into every prompt, every debrief, every deploy.
1. The conversation is the IDE. The AI chat is your primary tool; the editor is for verification.
2. Scaffold → flesh out → integrate. Skeleton first. Always.
3. The 3-minute rule. Stuck for 3 minutes? Paste the error back to the AI.
4. Incremental deployment. Deploy after every major feature, not at the end.
5. Interface-first design. Define what before how.
6. Copy the error, not your frustration. Give the AI the message, not the mood.
EDD · Week 6 · Course 6Principles
Agenda
~2 min
The day at a glance
Ten modules. Two breaks. One deployed application.
0:001. The Full-Stack Frontier 30 min · framing
0:302. Environment Setup 45 min · setup
1:153. Backend from Scratch 45 min · build
2:004. Data Layer 45 min · build
2:45— BREAK — 15 min
3:005. Frontend from Scratch 45 min · build
3:456. Pages & Navigation 45 min · build
4:307. AI Chat Integration 45 min · build
5:15— BREAK — 15 min
5:308. Auth & Middleware 45 min · build
6:159. External Integrations 45 min · build
7:0010. Docker & Deployment 45 min · build
7:45Assessment & Wrap-Up 15 min · close
EDD · Week 6 · Course 6Agenda
Target
~3 min
What you walk out with today
A working full-stack app, modeled on Heywood TBS — built in one day, by you, with AI.
8.4k
Backend LOC
Go HTTP server, router, handlers, store interface, middleware.
4.4k
Frontend LOC
React + Vite + TypeScript, multi-page, role-aware UI.
35
API endpoints
Reference target — your version will start with ~5.
1
Docker container
Backend + built frontend + data, runs anywhere.
Reference: Heywood TBS — built in days, by one person, working with AI. No team, no six-month timeline, no $2M budget.
EDD · Week 6 · Course 6Target
Module
01/ 10
The Full-Stack Frontier
30 minFraming · no code
A short mental-model shift from "I build Power Apps" to "I direct AI to build whatever the problem needs." We anchor the architecture we'll grow all day.
Most Marines never need to leave the low-code envelope. Some problems do.
Limitation
Power Platform
Full-Stack
Custom AI chat with tool use
Not really possible
Build exactly what you need
Role-based dashboards
Power BI RLS, complex
One app, four views
Offline / disconnected ops
Needs internet + M365
Container runs anywhere
Data sovereignty
Lives in Microsoft cloud
Lives where you put it
Cost per user
$20+/user/mo
$0 — open source, self-hosted
Deployment flexibility
Microsoft cloud only
Azure, AWS, on-prem, ship, field
Module 1 · The Full-Stack Frontier1.1
Architecture Anchor diagram
~7 min
The four layers — empty for now
We will return to this exact diagram after every build module and color in another layer.
L1 · Frontend
React Frontend✓
What the user sees and clicks. Sends requests to the backend.
L2 · Backend
Go HTTP Server✓
Receives requests, processes data, returns JSON.
L3 · Data
Data Layer✓
Where the data lives. JSON now, SQLite or Postgres later.
L4 · External
External Services✓
OpenAI for chat, Microsoft Graph for Outlook, etc.
Module 1 · The Full-Stack FrontierArchitecture · 0/4
Module 1 · The Skill
~8 min
You will not learn to code today
You will learn to direct AI to write code, verify it works, and keep going when it doesn't.
What you actually need
What to ask for — requirements (you learned this in Courses 1–4).
How to verify — run it, check the browser, read the response.
How to debug — paste errors back to the AI.
When to move on — the 3-Minute Rule.
What changes vs. Power Platform
The conversation is your IDE.
The error message is your debugger.
The interface is your design tool.
The container is your deployment.
Module 1 · The Full-Stack Frontier1.3 · Module Complete
Module
02/ 10
Environment Setup
45 minAI-guided install
The most boring module and the most critical. If the environment isn't right, nothing else works. Today, we let the AI walk every student through their own machine.
Student prompt — use as-is
I need to set up a development environment on [Windows / Mac]. Install Go 1.22+, Node.js 20 LTS, Git, VS Code, and Docker Desktop. Give me step-by-step instructions for my OS, including how to verify each install. After installation I should be able to run go version, node --version, npm --version, git --version and see numbers for all four.
Module 2 · Environment Setup2.1 · build framing
▶ Switch to the editor
→
Install & scaffold the project
Walk through: paste the install prompt, verify the four versions, then create the project skeleton:
my-staff-app with cmd/server/, internal/, web/ (Vite + React + TypeScript), and data/.
~30 min in editor — circulate while students install
Back to deck Environment ready
~3 min
Module 2 complete — runway built
The stack is still empty. Tomorrow it grows.
L1 · Frontend
React Frontend✓
Vite + React + TypeScript scaffolded in web/.
L2 · Backend
Go HTTP Server✓
Module initialised. Empty cmd/server/ waiting for code.
L3 · Data
Data Layer✓
Empty data/ directory. No store yet.
L4 · External
External Services✓
No external services wired up.
Go, Node, Git, VS Code installed and verified.
Project directory exists with go.mod and web/package.json.
Students used AI to install — not the docs.
Diagram status: 0 of 4 layers built. Empty runway. We light the first lamp in Module 3.
First real server-side code — or rather, first time directing AI to write it. By the end, every student has a Go HTTP server returning JSON to a curl request.
Stand up a Go server with one health endpoint and one items endpoint. Get to JSON in the browser.
▶ What we're adding
A Go HTTP server on port 8080.
A /api/v1/health endpoint that returns {"status":"ok"}.
A separate internal/api/router.go with helpers.
A /api/v1/items endpoint with hardcoded JSON.
Why this fits the architecture
This is layer L2 — the Go HTTP Server. Today it serves a hardcoded array; in Module 4 we'll wire it to a real data store; in Module 5 the React frontend will call it.
Principle in play: Scaffold → flesh out → integrate. We start with a server that does almost nothing. We make sure it works. Then we add features.
Module 3 · Backend from Scratch3.1 · framing
▶ Switch to the editor
→
Build the first server
Three prompts in sequence: stand up the server, extract a router, add the items endpoint. Run each, hit it with curl or the browser, paste any error back to the AI before debugging.
~30 min in editor
Back to deck First victory
~5 min
L2 lit — your first web server
Five characters of JSON. Zero lines of code you wrote yourself. Welcome to AI-assisted backend development.
L1 · Frontend
React Frontend✓
Scaffolded but not wired. Coming in Module 5.
L2 · Backend
Go HTTP Server✓
Server, router, helpers, two endpoints. JSON over HTTP.
L3 · Data
Data Layer✓
Hardcoded array for now. Real store in Module 4.
L4 · External
External Services✓
Nothing external yet.
go run ./cmd/server -dev runs cleanly.
Browser hits return real JSON on both endpoints.
Code is split: cmd/server/main.go + internal/api/router.go.
Each student ran the prompt → verify → iterate cycle at least twice.
Architecture status: 1 of 4 layers built (L2). The first lamp is on.
Define the contract — list, get, create, update — before you pick a backend.
▶ What we're adding
A DataStore Go interface in internal/data/store.go.
An Item struct with proper JSON tags.
A JSONStore implementation reading data/items.json.
The items endpoint rewired to read from the store.
Why interfaces are the lever
The Heywood DataStore has 27 methods and 5 backends — JSON, SQLite, Postgres, Excel, Hybrid. The rest of the application doesn't know which one is active. Define the interface today and you can:
Start with JSON files (no setup).
Upgrade to SQLite later (no other code changes).
Switch to Postgres for prod (config change).
Module 4 · Data Layer4.1 · framing
▶ Switch to the editor
→
Define the DataStore interface
Three prompts: define DataStore + Item + JSONStore; generate 20 realistic seed items in data/items.json; rewire main.go to load the store and serve from it. Add /api/v1/items/{id}.
~30 min in editor
Back to deck Data layer live
~3 min
L3 lit — real data, behind a contract
The frontend doesn't exist yet, but the data path is real and the interface is the door.
L1 · Frontend
React Frontend✓
Scaffolded. Wires up in Module 5.
L2 · Backend
Go HTTP Server✓
Reads from the store now, not hardcoded data.
L3 · Data
Data Layer✓
DataStore interface + JSONStore + 20 seed items.
L4 · External
External Services✓
Nothing external yet.
Interface defined with 4+ methods.
JSONStore reads from data/items.json.
API serves real data; /items and /items/{id} both work.
Each student can define "interface" in one sentence.
Architecture status: 2 of 4 layers built (L2 + L3).
Module 4 · Data LayerModule 4 complete · Architecture 2/4
Break · Be back at H+3:00
15min
Stretch. Drink water. Don't open Slack. The next stretch is the longest of the day.
Module · Build
05/ 10
Frontend from Scratch
Build module45 min
Stand up React + Vite + TypeScript, configure a proxy to the Go backend, and render the items table in a styled UI. The first end-to-end full-stack moment of the day.
React fetches your Go API and renders a styled table. JSON file → Go server → React → browser.
▶ What we're adding
Tailwind CSS configured in web/.
Vite proxy: /api → localhost:8080.
API client at web/src/lib/api.ts.
ItemsPage.tsx — table with status / priority color-coding, loading + error states.
Why this fits the architecture
This module connects L1 to L2 — the frontend pulls data from your server through the proxy. Two terminals running side by side. From the user's point of view, this is the first time the application "exists."
Principle in play: Scaffold first. We are not styling. We are not adding features. We are getting any data on screen.
Module 5 · Frontend from Scratch5.1 · framing
▶ Switch to the editor
→
Wire the frontend to the backend
Two terminals: backend in one, npm run dev in the other.
Configure Tailwind, set up the Vite proxy, build the API client, and render the items table at localhost:5173.
~30 min in editor
Back to deck Second victory
~5 min
L1 lit — full stack, end to end
JSON file → Go server → React → browser. Three of four layers are now real.
L1 · Frontend
React Frontend✓
Items table at localhost:5173, color-coded.
L2 · Backend
Go HTTP Server✓
Serving JSON to the proxied frontend.
L3 · Data
Data Layer✓
JSON store backing the items endpoint.
L4 · External
External Services✓
Coming online in Module 7 (OpenAI).
React app loads at localhost:5173.
Items table fetches and renders Go data.
Status + priority columns color-coded.
No console errors in dev tools.
Architecture status: 3 of 4 layers built. The application now exists from a user's point of view.
Sidebar layout, client-side routing, dashboard with stats, item detail page. Turn the prototype into something that looks and feels like an application.
Layout, routes, dashboard, detail page. The shape of every internal tool you'll ever build.
▶ What we're adding
react-router-dom with Layout, Dashboard, Items, Settings.
Dark sidebar (navy #1a1f36) with nav highlighting.
Item detail page at /items/:id.
Dashboard stat cards, recent items, quick actions.
Why this fits the architecture
L1 is now a real frontend, not a single page. We're not adding new layers — we're filling out the one we just lit.
Principle in play: Iterative refinement. The first prompt gets you 70% there; the next two prompts get you to 95%.
Module 6 · Pages & Navigation6.1 · framing
▶ Switch to the editor
→
Build the multi-page UI
Three prompts in sequence: routing + sidebar layout, item detail page, dashboard with stats and recent items.
Use Tailwind defaults. Active nav highlighting. Make titles in the items table click through to detail.
~30 min in editor
Back to deck Real application shape
~3 min
L1 fleshed out — the prototype is gone
Same diagram. The frontend layer is now a real multi-page app, not a one-page demo.
L1 · Frontend
React Frontend✓
Sidebar, routing, dashboard, items, detail. Looks like an app.
L2 · Backend
Go HTTP Server✓
Same endpoints, more callers.
L3 · Data
Data Layer✓
JSON store still backing everything.
L4 · External
External Services✓
Next module — OpenAI.
Sidebar nav works without page reload.
Dashboard shows stats from API data.
Detail page loads from items list.
Active page highlighted in sidebar.
Architecture status: 3 of 4 layers built — L1 fully fleshed out.
When a user asks "how many high-priority items do I have?", the AI doesn't guess. It calls your lookup_items tool and reports the real count.
▶ What we're adding
Chat service in internal/ai/chat.go calling gpt-4o.
A lookup_items tool with status / priority / query params.
POST /api/v1/chat endpoint.
ChatPage.tsx with markdown rendering and loading states.
What is tool use?
Function calling lets the AI invoke functions in your application. The AI sees a list of tools you've offered, decides which to call, and uses the result in its answer.
This is what makes Heywood real. It does not hallucinate about student data. It queries the database and reports facts.
Module 7 · AI Chat Integration7.1 · framing
▶ Switch to the editor
→
Build the chat with tool use
Three prompts: chat service against OpenAI; lookup_items tool definition; chat page with markdown rendering. End: ask "what are my high-priority items?" and watch the AI call your code.
~30 min in editor
Back to deck AI on board
~5 min
L4 lit — the brain comes online
All four layers built. Your application can now answer questions about itself, grounded in real data.
L1 · Frontend
React Frontend✓
+ ChatPage with markdown rendering.
L2 · Backend
Go HTTP Server✓
+ /chat endpoint and chat service.
L3 · Data
Data Layer✓
Now consumed by humans and the AI tool.
L4 · External
External Services✓
OpenAI gpt-4o with tool use.
Chat sends and receives messages.
AI uses tool calling to query the DataStore.
Responses contain real data, not hallucinated items.
Markdown renders correctly.
Architecture status: 4 of 4 layers built. Every layer is real. The rest of the day is hardening.
Halfway through the back half. Stretch, water, kill any zombie servers in your terminal.
Module · Build
08/ 10
Auth & Middleware
Build module45 min
Different users see different data. Middleware is the gate guard that runs before every request reaches your handler. Today we build the role-aware version.
Choose your path. Path A — replace JSON with SQLite (no external accounts). Path B — connect to Outlook via Microsoft Graph (Azure AD required). Both prove the integration pattern.
A multi-stage Dockerfile bundles backend, frontend, and data into one container. It runs identically on a laptop, a server, Azure, a ship, or a field TOC.
Go server serves the React build in production mode.
SPA fallback for non-API routes.
docker build + docker run locally on port 8080.
Optional: push to ACR and deploy to Azure Container Apps.
Why this fits the architecture
The container collapses L1, L2, and L3 into a single artifact. L4 (OpenAI, Graph) stays external — you pass keys via environment variables.
Principle in play: Incremental deployment. We are not waiting until "the end" to ship. The container is the end.
Module 10 · Docker & Deployment10.1 · framing
▶ Switch to the editor
→
Build & run the container
Generate the multi-stage Dockerfile. docker build -t my-staff-app .. docker run -p 8080:8080 -e OPENAI_API_KEY=…. Open localhost:8080 — full app from a single container. Optional: deploy to Azure.
~30 min in editor
Back to deck Third victory — the big one
~5 min
All four layers, packaged and shipped
The application now exists outside your laptop. Same bytes, any machine, any environment.
L1 · Frontend
React Frontend✓
Built bundle, served by Go in prod mode.
L2 · Backend
Go HTTP Server✓
Single binary. Serves the API and the SPA.
L3 · Data
Data Layer✓
Bundled into the image (or mounted as a volume).
L4 · External
External Services✓
Wired via environment variables — OpenAI, Graph, etc.
Image builds successfully.
Container runs and serves the full application.
Students understand: one container = entire application.
(Bonus) Deployed to Azure with a public URL.
Architecture status: 4 of 4 layers — packaged. The application now lives anywhere.
The finished reference for today's build lives in this repo at heywood-inventory/. Use it after the 3-Minute Rule fires twice on the same prompt — never before.
How to use it: open the file for the module you're stuck in, read it top to bottom, then re-prompt your AI with the gap. Don't copy — close the reference once you see the missing piece. Full guidance in heywood-inventory/docs/STUDENT_GUIDE.md.
W1AI Fluency Fundamentals You learned the management framing. The 80% quit problem.
W2Builder Orientation Your first prototype. Decomposition under pressure.
W3Platform Training Three deployed Power Platform tools. Centaur and Cyborg.
W4Advanced Workshop You mapped your frontier. You taught someone else.
W5Supervisor Orientation Leaders learned to evaluate proposals and protect the apprentice pipeline.
W6Full-Stack (today) You shipped a containerized application built end-to-end with AI.
Program CloseC.1 · Journey
Closing thought The apprentice problem
~3 min
What you owe forward
The pipeline only stays open if you choose to hold it open.
“That training pipeline that was always implicit has broken, and it has to be reconstructed.”
— Mollick, on the apprenticeship crisis (Course 1)
Three commitments
Make a junior Marine review your AI output before you ship it. They learn judgment by reading good work and bad.
Share your failure cases. Where AI degrades your work is as valuable as where it accelerates it.
Teach the next cohort. Co-teach a course. Run a section meeting. Write up one tool.
The line you do not cross
Don't cut a junior role because AI handled the routine work.
Architects who never laid a brick build buildings that fall down.
Your bench in five years is the room you protect today.
Program CloseC.2 · Owe forward
Continue Resources
~1 min
Where to keep going
Bookmark these. Use them in the order that fits the next problem you pick.
On the EDD site
SOP — the operating doctrine for AI-assisted builds.
Toolkit — interactive worksheets and checklists.
Templates — Problem Definition, Documentation Package, prompt patterns.
Resources — readings, references, links to the underlying research.
Practice
Rebuild today's app from scratch. No prompts. No notes.
Find a real unit problem. Define it. Build it.
Co-teach one course. Anyone in this room is qualified to start.
Push your work to the EDD GitHub. Other units learn from it.
Program CloseC.3 · Continue
Course 6 · Capstone Complete
You wrote the requirements. AI wrote the code. You shipped the container.
That is not “learning to code.” That is Expert-Driven Development at the highest level — domain experts building exactly what they need, at the speed of conversation. Now go build something your unit actually needs.
Expert-Driven Development · Week 6 of 6 · MCD-Monterey