Chapter 12 — Reps

Eleven reps to turn a pile of one-off prompts into a real, tested, reusable library. They move from rescuing your best prompts, to designing variables, to organizing and naming, to versioning, to evaluating quality on the rubric. The keyboard is the gym. Don’t read these — build them.

Ground rules

• Type it yourself. Write your templates and your fills by hand, in your own document. Copy-pasting the examples teaches your eyes, not your fingers. A library you didn’t build is a library you won’t use.
• Run/try everything. Every template gets used in a real AI tool at least once. A template you never ran is a guess, not an asset.
• Predict before you measure. Before you run a template three times, write down what you expect the output to look like. The gap between your prediction and the actual output is where the learning lives.
• AI usage note (every AI rep). You may use an AI assistant to help draft, critique, and improve your templates — that’s smart. But end every AI-using rep with one honest line: what you asked, what it got wrong or missed, and what you decided. You choose the tool; you own the verdict.
• Keep a reps.txt. One short written reflection per rep. And keep a growing my-prompt-library document — the reps build it, and it becomes your project.

Reps 1–3: Rescue and template

Rep 1 — Archaeology: dig three good prompts out of your history

Open your ChatGPT / Claude / Gemini chat history (or your sent folder). Find three prompts you wrote in the past that genuinely worked — ones that produced output you actually used. Copy each into your my-prompt-library document, raw, exactly as you first wrote it.

Reflection: For each of the three, why did it work? Name the one specific thing (a clear objective, a good example, a role) that made the output usable. That “one thing” is what you must preserve when you templatize it.

Rep 2 — Templatize: pull out the specifics

Take the three raw prompts from Rep 1. For each, rewrite it as a template using the field structure from code/prompt-library-starter.txt (Name, Role/Task, When to use, Variables, Template, Example, Model hint, Quality, Version). Replace every today-specific detail with a {{placeholder}}.

Reflection: Which was hardest to templatize, and why? Usually it’s the one that was most welded to a single situation. What did you have to generalize to make it reusable?

Rep 3 — Fill in the “Quality” field for real

For each of your three templates, write the Quality field — the specific things you must check in the output before you trust it. Be concrete: “check that every meeting owner was actually named in the source,” not “make sure it’s good.”

Reflection: Look at your three Quality fields. What’s the most common failure you’re guarding against across all three? That recurring risk is the one to watch hardest this week. AI usage note.

Reps 4–6: Design good variables

Rep 4 — The bake-in / variable split

Take one template. Make two lists: everything you baked into the fixed skeleton (role, format, guardrails) and everything you made a {{variable}}. Then defend the split in a sentence each.

BAKED IN (same every time):        VARIABLE (changes each use):
  - role: "experienced support..."   - {{customer_message}}
  - format: "under 150 words"        - {{tone}}
  - guardrail: "no promises beyond"  - {{what_we_can_offer}}

Reflection: Is there anything you baked in that should be a variable, or vice versa? How would you know? (Hint: you find out by using the template on a genuinely different input — that’s Rep 5.)

Rep 5 — Stress-test the variables on fresh inputs

Take that same template and use it on a genuinely different real input than the one you designed it for. Did the {{variables}} absorb the difference, or did you have to rewrite the skeleton? If you rewrote, fix the variable design and try again.

Reflection: Over-variabled prompts become blank forms; under-variabled prompts only work once. Where did this template land, and what did you change to get the balance right?

Rep 6 — Ask AI to critique your variable design

Paste one of your templates into an AI assistant and ask: “What variation in real use would this template fail to handle? What should be a variable that currently isn’t?” Weigh its suggestions — accept the good ones, reject the ones that would over-complicate.

Reflection: Which suggestion did you take, and which did you reject and why? Rejecting a bad AI suggestion is a rep in owning the verdict. AI usage note.

Reps 7–9: Organize, name, version

Rep 7 — Organize by role and task

You should have 5–8 templates now. Organize them into a two-level outline: role, then task (§12.4). Add a one-line index at the top of your document listing every template name.

Reflection: Did organizing reveal any duplicates or near-duplicates — two templates doing almost the same job? Merge them. What did you learn about how you actually reach for a prompt?

Rep 8 — Name for stressed-future-you

Rename every template so the name is specific, leads with the task, and uses a word you’d actually search for under pressure. Then test it: close your eyes, imagine a real trigger situation, and Cmd-F the word that comes to mind. Did it land on the right template?

Reflection: Which name did you have to change the most? What was wrong with the old one — too vague, wrong keyword, a clever word instead of the obvious one?

Rep 9 — Version an improvement

Pick your most-used template. Use it, notice something to improve, and make the change. Now version it properly: bump to v2 with today’s date and write one line saying why you changed it. Keep the old version below, marked “OLD.”

Reflection: Why does the why-note matter more than the version number? Describe a realistic future moment where that one line would stop you from un-fixing your own prompt.

Reps 10–11: Evaluate quality

Rep 10 — Score a template on the rubric

Pick your strongest template. Score it on code/prompt-quality-rubric.txt: run it three times on the same inputs, then once on different inputs, and score all eight criteria (0/1/2). Record the total out of 16 and the weakest criterion.

Template: ________________   Runs: 3 same + 1 different
Total: ____/16   Weakest criterion: ________________

Reflection: Were the three same-input runs consistent, or did they swing? A swing means the prompt is under-specified. What one change would raise your weakest criterion? AI usage note.

Rep 11 — Hunt for a fabrication

Run one of your templates on real input and read the output like an editor, not a fan. Find at least one thing you would need to verify before trusting — a fact, a name, an owner, a date, a claim. If the template didn’t already have an anti-fabrication guardrail, add one (“do not invent… flag what you could not confirm”) and re-run.

Reflection: Did the guardrail change the output? This is the spine rule made concrete: the template got better, and you still verified. Why are those two different jobs, and why does the second one never go away?

Done? One Last Thing.

A miniature of Project 12, end to end. In your my-prompt-library document, make sure you have:

1. At least five templates, each with all the fields filled — including a real Quality checklist.
2. Organized by role and task, with a name index at the top.
3. One template versioned through an improvement, with a why-note.
4. One template scored on the rubric, with its total and weakest criterion recorded.

If you can do this for five templates tonight, you can do the full 10–15 for the project. That is the whole discipline in miniature: rescue the good prompt, pull out the variables, name it so you can find it, test it so you can trust it, version it so it keeps getting better — and never let the polish of the library talk you out of reading the output.

Up next: Project 12 — Project P12: Your Prompt Library.