Software Engineering Fundamentals for AI-Assisted Development
A deep-track course covering setup, planning, versioning, QA/QC, and specs — with the CS theory underneath. Built for someone developing in VS Code + Claude and Antigravity, working steadily over a few weeks.
How to use this course. Each module has three parts: Concepts (the theory and the why), Practice (what to do), and Milestone (something concrete you produce). Two projects run alongside the modules — a proposal/fee web app I’ve spec’d out (built incrementally as you learn), and your own 3D-viewer idea as the graduation project. Do the reading, then immediately apply it to a project. The application is where it sticks.
The two projects
Section titled “The two projects”Project B — “FeeForge” (my spec, built as you learn). A web app that automates proposal writing and fee development. A user creates a proposal for a project, defines the fee model (phases × disciplines × hours × rates, plus multipliers and contingencies), and the app computes the fee, stores reusable templates and historical project data, and drafts proposal narrative sections via the Anthropic API. It’s deliberately chosen because it exercises every theme in the course at the right difficulty: a typed schema as a spec (the fee model), correctness that genuinely matters (a fee calculator you can unit-test hard), a real database and migrations (versioning of data, not just code), evolving requirements, CI, and “Claude in your app” as a first-class feature. We build it incrementally, one module at a time.
Stack: Next.js (React + TypeScript) · Postgres (via Supabase or Neon) · Prisma or Drizzle ORM · Zod for schema/validation · the Anthropic API for draft generation · Vitest/Playwright for tests. TypeScript throughout, so the “encode invariants in types” theme is lived, not just discussed.
Project A — Your 3D viewer (graduation project). A browser-based 3D viewer with markup, linked to structural analysis models: load geometry (ideally IFC), let the user pick and annotate elements, and tie each element to its analysis-model counterpart via a stable shared identifier. This is the harder, more exciting build, deliberately placed last — by Module 6 you’ll have the engineering discipline to tackle its real complexity without the fundamentals and the 3D learning curve fighting for attention. We lock a one-paragraph problem statement early (Module 1) and build it fully at the end.
Likely stack: TypeScript · React Three Fiber (Three.js) + drei + three-mesh-bvh · web-ifc / ThatOpen Components for IFC · a shared-ID mapping layer to link geometry ↔ analysis results (from ETABS/SAP2000/RAM exports or their APIs). We’ll pin this down when we design it.
Modules
Section titled “Modules”| # | Module | Est. | Milestone | Done |
|---|---|---|---|---|
| 0 | Orientation & mental models | ½ wk | One-page “what makes code good?” | ☐ |
| 1 | Planning & design | 1 wk | Two design docs + first ADR | ☐ |
| 2 | Project setup & reproducibility | 1 wk | clone → install → dev → test works | ☐ |
| 3 | Version control in depth | 1 wk | Clean git log + tagged release |
☐ |
| 4 | Specs, rules & AI-assisted dev | 1 wk | Zod schema, spec doc, CLAUDE.md, fee calculator | ☐ |
| 5 | QA/QC & testing in depth | 1–1.5 wk | Green CI + trusted test suite | ☐ |
| 6 | Bringing it together & Project A | 1 wk | 3D viewer at v0.1.0, green CI |
☐ |
Reading list (deep track)
Section titled “Reading list (deep track)”- Fred Brooks — The Mythical Man-Month, esp. “No Silver Bullet” (essential vs. accidental complexity)
- David Parnas — “On the Criteria To Be Used in Decomposing Systems into Modules” (1972)
- Pro Git (free online) — esp. Git Internals
- Bertrand Meyer — Object-Oriented Software Construction (design by contract chapters)
- Martin Fowler — Refactoring (2nd ed.) and his site’s articles on CI, testing, and tradeoffs
- Titus Winters et al. — Software Engineering at Google (how these ideas scale; the time/scale/tradeoffs framing)
- Andrew Hunt & David Thomas — The Pragmatic Programmer
Stack-specific (as you need them, not up front):
- TypeScript Handbook — esp. the sections on
strictmode and narrowing - Zod docs — schema definition and type inference (schema-as-spec in practice)
- Next.js docs — App Router, route handlers, server vs. client components
- Prisma or Drizzle docs — schema modeling and migrations
- Three.js Journey / React Three Fiber docs — for Project A when you reach it
Suggested cadence (steady, ~6 weeks)
Section titled “Suggested cadence (steady, ~6 weeks)”| Week | Module | Project focus |
|---|---|---|
| 1 | 0 + 1 | Both design docs (FeeForge + 3D viewer), first ADR |
| 2 | 2 | FeeForge scaffolded & reproducible; pure-domain boundary set |
| 3 | 3 | FeeForge under clean version control; migration history started |
| 4 | 4 | FeeForge spec, Zod schema, CLAUDE.md, fee engine |
| 5 | 5 | FeeForge test pyramid + CI green |
| 6 | 6 | 3D viewer start-to-finish; course review |
Adjust freely — depth over schedule.