The Vibe Coder's Code

Arrived here before Session 8? The professional names below are the course's ending spoiler: read the ten rules if you like, but maybe save the names for the reveal.

Ten rules. Follow them and you can move as fast as the agent can, and each one already has a name, used on professional teams from three-person startups to billion-pound programmes:

Commit before every big prompt. Snapshots are free; regret isn't. (Version control discipline)
Always read the diff. You don't have to understand every line, you have to look, and ask about what surprises you. (Code review)
One change at a time. Small prompt → check → commit → next. (Incremental delivery) (small batches, the heart of Agile/Lean)
Say what done looks like. Acceptance criteria in every non-trivial prompt. Examples beat descriptions. (Requirements & acceptance criteria) (specification)
Verify by running, not by trusting. Give the agent a check it can run, and demand evidence, output, not "done!". (Testing & continuous integration)
Plan before building anything non-trivial. One-sentence change? Skip it. Anything bigger: plan mode first, read the plan, correct it. (Design & the software development lifecycle)
Keep sessions short and context clean. /clear between tasks; /context as a fuel gauge; two failed corrections → revert, /clear (a fresh session works too), better brief. (Managing cognitive load): why teams document, modularise, and hand over
Never put secrets in prompts or repos. Not passwords, not API keys, not once, not briefly. Git remembers deleted files. (Security hygiene / secrets management)
Debug with observations, not panic. What exactly happens? Then: "find the cause and explain it before fixing anything." (Scientific debugging & root-cause analysis)
You own what you ship. The agent wrote it; you shipped it. Review, security, and quality are yours and can't be delegated to the thing being reviewed. (Professional responsibility), the one that makes it a profession

(Rule 11, unwritten: when in doubt, re-read rule 10.)

And the second reveal, your three projects, with their real names

What you did	What the industry calls it
The one-shot (session 1)	Prototyping / spikes: cheap experiments to learn fast
Growing it in sprints, backlog, increments (sessions 2 and 3)	Iterative delivery: agile/Scrum, how most modern software ships
The capstone's spec, gates, roadmaps, baseline, closure	Plan-driven delivery: waterfall, as governed under PRINCE2/PMBOK in regulated industries
The four sign-offs in Session 5	Gate reviews (end-stage assessments)
"QA'd clean, deployed, canary green"	Definition of Done
`/land-and-deploy` + `/canary` per slice	Continuous deployment & canary releases
`/retro` + `/learn`, every sprint	Retrospectives & a lessons-learned register

You didn't learn to vibe code with some engineering sprinkled in. You learned software engineering, and ran three delivery methodologies end to end; the agent was the delivery mechanism. These habits are what interviewers mean when they say "engineering maturity", and your GitHub history is now evidence you have them.

Nothing on this list is about typing code. It never was.