This is the synthesis module. Every concept from the previous seven modules comes together in one deliverable: a complete, working scaffolding system for a project of your choice — real or imagined.
A complete scaffolding system is not a collection of files. It's a coherent architecture where each piece has a defined role, the pieces relate to each other without contradiction, and the whole can be handed to any AI session and produce consistent, governed behavior. You know what's missing from a system when the AI misbehaves and you can't explain why by reading the files.
The final artifact integrates all four NIST AI RMF functions: GOVERN (accountability structure), MAP (context documentation), MEASURE (scope and consistency), and MANAGE (continuity and failure response). Your governance summary must name which function each component of your system addresses. That's what makes it a governed system rather than a folder of markdown files.
A senior developer is leaving a two-person startup. Before they go, they have two weeks to document everything the incoming developer will need — not the codebase, which is well-tested and readable, but the scaffolding: the constraints, the conventions, the decisions made and why, the patterns that work and the patterns that don't.
The new developer will be working with AI coding tools from day one. The scaffolding doesn't just need to inform a human — it needs to inform an AI that has no prior context about the project, no access to the departing developer, and no ability to ask follow-up questions about history. The files are all it has.
The departing developer starts writing. The first version of the CLAUDE.md takes two hours and covers the obvious: tech stack, deployment, branch conventions. They show it to a colleague who asks: "If an AI reads this tomorrow and something goes wrong, would you know which file was missing?" The developer stares at the screen. They don't know.
The problem isn't that the scaffolding is wrong. It's that there's no framework for evaluating whether it's complete. The developer knows the project well enough that they can feel the gaps — but they can't name them systematically. Without a systematic completeness check, the scaffolding will look finished while leaving the most important knowledge undocumented.
The framework for that completeness check is what this course has been building toward. The final module puts it to work.
A scaffolding system is complete when every layer is covered and every component maps to a governance function. Use the three-layer model from Module 1 and the four NIST functions as the evaluation framework.
Does the CLAUDE.md answer: what are we building, what are the technical constraints, what architectural decisions are locked in, what is explicitly banned, and what are the workflow rules? If any of these five questions can't be answered by reading the CLAUDE.md, the structural layer is incomplete. The GOVERN function owns this layer: it establishes accountability by making the AI's constraints explicit.
Does the ai-context.md answer: what domain facts are always true, what vocabulary is specific to this project, what invariants must never be violated? Does the rules file answer: what conventions are derived from incidents, what must always be done, what process is required? The MAP function owns this layer: it makes tacit knowledge explicit and documentable.
Does the HANDOFF.md template cover all five required fields? Does the session start and end protocol exist and is it in the CLAUDE.md? Does the maintenance protocol define how to detect and respond to conflicts, drift, and gaps? MANAGE owns the continuity and recovery aspects. MEASURE owns the consistency and scoping aspects — making sure context stays accurate and focused.
A governance summary is a one-page document that explains the scaffolding system to a non-technical reviewer. It lists every component, names the NIST function it addresses, and states what the component prevents. "CLAUDE.md — GOVERN — prevents the AI from making architectural decisions that violate project constraints." "HANDOFF.md protocol — MANAGE — prevents context loss across sessions, ensuring AI decisions remain auditable and recoverable." A reviewer reading the summary should understand how the system maintains accountability, completeness, consistency, and continuity without reading any of the actual files.
Who is accountable for what the AI does? CLAUDE.md makes accountability explicit: the AI operates under these constraints, these workflow rules, and this autonomy boundary. If something goes wrong, the CLAUDE.md is the accountability document.
What does the AI need to know about the problem space? ai-context.md and rules files make tacit knowledge explicit — the domain facts and team conventions that would otherwise exist only in developer memory.
Is the context accurate and appropriately scoped? The layered architecture (root + package) prevents context noise. The consistency audit prevents contradictions. Staleness dating prevents drift from going undetected.
How does the system stay reliable over time? The HANDOFF.md protocol prevents context loss. The failure mode detection protocols (consistency audit, symbol grep, decision review) prevent conflicts, drift, and gaps from reaching production.
A scaffolding system is more than files. It's the relationships between the files — who overrides whom, what triggers what, which components depend on which. Coherence means those relationships are explicit and intentional.
Read all the files together. Is there any sentence in one file that contradicts a sentence in another? If yes, the system is not coherent — it's a collection of files with unresolved conflicts. Resolve every contradiction before calling the system complete.
Every rule in the system should be in exactly one file — the file that owns its type. A domain fact in the CLAUDE.md instead of ai-context.md isn't wrong, but it's in the wrong home. Misplaced rules become stale faster because they're not maintained by the process designed for their type.
What happens when the AI encounters a situation not covered by any file? A coherent system has an explicit default: "When in doubt, ask before acting." That default should be in the CLAUDE.md. Without it, the AI will invent a default from training data — which may be reasonable, or may violate everything you've built.
Will this system survive a month of rapid development when nobody has time to write documentation? The maintenance burden must be low enough that it actually happens. If updating the scaffolding takes thirty minutes, it won't happen. If it takes three, it will. Design for the reality of development pressure, not the ideal of perfect documentation.