Capstone: Building Your Personal Pattern Library

Eight lessons, somewhere around thirty patterns, and a strong chance that by now a handful of them have already become the thing you reach for without thinking. This lesson is where that stops being incidental and becomes deliberate: you're going to pick the 8-10 that actually earned a permanent place in your workflow, write each one down properly, and put the whole thing somewhere you'll actually open again next month.

Not all thirty patterns apply to your job. If you don't write client proposals, Diff-Only Iteration on a proposal draft isn't yours to keep — but if you run status updates through a rubric every week, Rubric-Gated Revision almost certainly is. The first task of this capstone is triage, not memorization.

Step 1: Choose Your 8-10

Go back through Lessons 761-768 and mark every pattern you've actually used — not "could see myself using," used. For each one, ask: did this pattern touch a real task this week, or am I keeping it because it sounded useful in the lesson? Be honest here; a library padded with patterns you've never run is dead weight the first time you go looking for something under deadline pressure.

Aim for 8-10 total, spanning as many of the eight job functions as genuinely apply to your role. A researcher and a project manager will end up with almost no overlap in their libraries, and that's correct — the point isn't coverage of all eight lessons, it's coverage of the job functions you actually do.

Step 2: Write Each Entry Properly

Every pattern in your library needs four things, and skipping any one of them is what turns a library into a list of good intentions:

The job function it serves — which of the eight lessons it came from, so you can find it again by what you're trying to do, not by which lesson number you half-remember.
The pattern template with placeholders — the actual reusable prompt structure, ready to fill in, not a paraphrase of what the pattern does.
A real example run against actual work — not the lesson's example, yours. The exact prompt you ran, on the exact task you had, with the actual (possibly imperfect) output.
The failure mode to watch for — the specific way this pattern goes wrong for you, which may be narrower or different from the generic failure mode the lesson described, because it's grounded in something that actually happened.

PATTERN: [name]
JOB FUNCTION: [which lesson / job function this serves]
TEMPLATE:
[the reusable prompt structure with placeholders]

REAL EXAMPLE (run on [date] against [actual task]):
[the exact prompt you ran]
[what you got back]

FAILURE MODE:
[the specific way this breaks, based on something that actually happened
 to you — not the generic warning from the lesson]

Step 3: Compose, Don't Just Collect

The single move that elevates a pattern from "good" to "durable" is composition: layering two Prompt Engineering Mastery techniques together inside one applied pattern instead of using either alone.

A concrete example: Rubric-Gated Revision (from this track) becomes noticeably more reliable when you compose it with a Persona (from the craft track) — assign the AI a specific reviewer identity ("review this as a skeptical technical editor who has rejected work like this before") before it grades against your rubric, then layer a Critic pass on top of that so it critiques its own grading, not just the draft. The pattern didn't change; what changed is that it now self-corrects instead of running once and stopping. That's the difference between a pattern that works today and a pattern that's still trustworthy six months from now when the task is slightly different from the one you first wrote it for.

At least one entry in your library should show this kind of composition explicitly — name which two craft-track techniques you layered and why the combination outperforms either alone.

Step 4: Store It Somewhere You'll Return To

The library only has value if you open it again. A Notion page, a markdown file in a repo you already visit, a dedicated doc — anything that's already part of your existing workflow beats a one-off AI chat thread you'll never reopen, and it beats a system so elaborate you stop maintaining it after week one. Pick the boring, durable option over the impressive one.

The Baseline Comparison

Back in Lesson 760, before Lesson 761, you wrote down the five most recent AI tasks you'd done at work and noted whether you had a repeatable pattern for each one or improvised from scratch. Pull that list back out now. For each of the five, ask: do I have a named pattern in my library for this now? Count how many flipped from "improvised" to "have a pattern." That count is the most honest measure of whether this track actually changed how you work — more honest than how many lessons you finished.

Build It

The BuildChallenge below has you build validateLibrary — a registry-validation function (in the style of the approval-policy rule checker from Codex Basics Lesson 530) that checks your library against the completion-project rubric directly: at least 8 entries, every entry has a non-empty template, example, and failure mode, and at least a minimum number of distinct job-function tags are represented. It turns the rubric above from a checklist you eyeball into logic you can actually run against your own library file.

Bottom Line

The deliverable for this capstone — and for the whole track — is a document with one entry per pattern: the job function it serves, the template with placeholders, a real example you ran against actual work, and the failure mode to watch for. Eight to ten named patterns, each mapped to a job function from this track, each with both a template and a real example, each stating its failure mode, at least one composing two Prompt Engineering Mastery techniques, stored somewhere you'll actually return to. That's not a summary of the track — it's the artifact you keep using after the track is over. If you want to go deeper on any single pattern's mechanics from here, Prompt Engineering Mastery is exactly where that depth continues to live. Welcome to the other side of a blank cursor.