Chapter 11 Exercises: Prompt Engineering Patterns

These exercises progress from understanding existing patterns to building and maintaining your own library. Complete the Core exercises first; Extension exercises go deeper.

Section A: Understanding and Testing the 15 Patterns

Exercise 1 — Pattern Identification (Core)

Goal: Build fluency in recognizing which pattern applies to which task.

For each of the following tasks, identify the primary pattern from the chapter's 15 that applies, and briefly explain why. Some tasks may suit more than one pattern — identify the primary one and note any secondary options.

"Review this proposal as a skeptical potential client and identify the objections they might raise."
"Convert these 15 pages of meeting notes into a structured project status report."
"Create an outline for a 6-month marketing strategy document."
"We need 10 different taglines for our new product launch."
"Sort these 50 customer comments into 4 categories."
"Rewrite this press release in plain language for a non-technical audience."
"What's the best onboarding platform — Appcues, Intercom, or Pendo? Compare them."
"Write a reply to this angry client email."
"Pull all the pricing information from these 4 competitor websites."
"Check this contract for any clauses that could create liability."

Exercise 2 — Template Fill-In: The Analyzer (Core)

Goal: Practice using a pattern template with real content.

Using Pattern 3 (The Analyzer), write a complete filled-in prompt for this task:

You need to analyze your team's weekly standup meeting format for effectiveness. The meetings are 30 minutes, have 6 people, and commonly run over time with low actionability.

Fill in all bracket variables. Be specific: don't leave vague placeholders. Run the prompt and assess: did the specificity of your criteria produce specific, useful output?

Exercise 3 — Template Fill-In: The Generator (Core)

Goal: Practice the Generator pattern with a diversity constraint.

Using Pattern 4 (The Generator), build a complete prompt for this task:

Generate naming options for a new productivity app targeting remote workers.

Specific requirements for your prompt: - Request at least 8 names - Specify 3 diversity requirements (name types, tone ranges, or other dimensions) - Require a brief rationale for each name

Run the prompt. Evaluate: did the diversity constraints produce a genuinely varied set? Which names would you never have thought of yourself?

Exercise 4 — Template Fill-In: The Responder (Core)

Goal: Practice the highest-stakes pattern with attention to risk parameters.

Using Pattern 13 (The Responder), write a complete prompt for responding to this message:

"I've been a customer for 3 years and my account was inexplicably suspended last week with no notice and no explanation. I've contacted support 4 times. No one has responded. I am absolutely furious and I'm going to post about this everywhere."

Your response should: - Acknowledge the situation specifically (not generically) - Not make promises about timeline or compensation (add this to your "do not" list) - Propose a specific next step

Run the prompt. Review the output carefully: does it make any promises your "do not" list prohibited? Does it sound genuine or scripted?

Exercise 5 — Pattern Comparison (Core)

Goal: Understand when similar patterns produce different results.

The Summarizer and the Extractor might seem similar (both take source content and produce condensed output). Run both patterns on the same source document.

Choose a document 3-5 pages long (a report, a proposal, a long email chain, meeting notes).

Run Pattern 1 (Summarizer): summarize for a specific audience, in a specific format
Run Pattern 9 (Extractor): extract specific structured information (action items, risks, decisions made, key figures — choose what's relevant)

Compare the outputs. What does the Summarizer produce that the Extractor doesn't, and vice versa? When would you use each? Could you combine them?

Section B: Building Your Own Patterns

Exercise 6 — Identify Your Top 5 Recurring Tasks (Core)

Goal: Discover your personal pattern library candidates.

For one week, keep a running list of every task you use AI for. At the end of the week, group similar tasks. You should have between 5 and 20 distinct task types.

For each task type, record: - What you asked for (the task) - How many times you did this type of task in the week - Your satisfaction with the AI output (1-5) - Your estimate of time spent constructing the prompt

Rank your top 5 task types by: frequency × (5 - satisfaction). High scores indicate tasks that happen often and produce poor results — your best pattern candidates.

Exercise 7 — Generalize a Real Prompt (Core)

Goal: Convert a specific one-time prompt into a reusable pattern.

Find the best prompt you have written in the last 30 days — one that produced output you were proud of, or one that required significant effort to construct.

Write out the exact prompt as you used it
Identify which elements are task-specific vs. reusable structure
Replace task-specific elements with [BRACKET VARIABLES]
Name the pattern (functional name, not specific to the original task)
Write a use case description (1-2 sentences)
Test it: run the generalized pattern on a different specific instance of the same task type

Does the generalized version produce equally good results for the new instance? If not, what needs to be adjusted in the template?

Exercise 8 — Build a 5-Pattern Library (Core)

Goal: Build the core of your personal pattern library.

Based on the task audit from Exercise 6, build 5 complete pattern entries, each including: - Pattern name (functional) - Use case (when to use) - Full template with [BRACKET VARIABLES] - One filled-in example (show the variables populated with real content) - Notes (at least 2: one tip for using it well, one warning about a failure mode)

Store all 5 patterns in a location you will actually access during work (your notes app, a shared document, your preferred tool).

Exercise 9 — Pattern Documentation Template (Core)

Goal: Create a consistent documentation format for your library.

Building on Exercise 8, create a documentation template that you will use for every pattern you add. The template should include at minimum: - Pattern name - Date created / last updated - Use case - Template (with [BRACKET VARIABLES]) - Example (filled-in) - Notes

But consider adding: related patterns, known failure modes, AI platform notes (if a pattern works better on one tool vs. another), and a version history for significant changes.

Apply this template by reformatting your 5 patterns from Exercise 8 to use the new structure.

Exercise 10 — Create a Custom Pattern Not in the Chapter (Core)

Goal: Practice the full pattern discovery and documentation process.

Think of a recurring task in your professional life that is NOT well covered by the 15 patterns in the chapter. (If every task you do fits cleanly into one of the 15, push yourself to identify a nuanced variant or combination that your specific context requires.)

Go through the full process: 1. Define the task type 2. Build a first-draft prompt for a specific instance 3. Evaluate the output — what works, what doesn't 4. Iterate the prompt until you get good results 5. Generalize into a template 6. Test on a second instance 7. Document with the template from Exercise 9

This is the full pattern discovery process. How long did it take? What was the hardest part?

Section C: Pattern Composition and Advanced Use

Exercise 11 — Two-Pattern Composition (Core)

Goal: Practice combining two patterns for a complex task.

Choose a task that naturally requires two sequential steps. Some options: - Extract information from a source, then analyze it - Analyze a situation, then generate options - Generate options, then critique them - Scaffold a structure, then generate content for one section

Design a two-pattern workflow: Pattern A produces output → that output becomes the input for Pattern B.

Run both steps. Assess: was the two-step approach better than trying to do both at once in a single prompt? What was lost and gained by separating the steps?

Exercise 12 — Three-Pattern Composition: Full Deliverable (Extension)

Goal: Build a complete professional deliverable using pattern composition.

Choose a real deliverable you need to produce: a report, a presentation outline, an analysis, a proposal, or a plan.

Design a workflow using at least 3 patterns: - Step 1: A Scaffolder or Planner to create the structure - Step 2: One or more Generators, Analyzers, or Extractors to produce content for sections - Step 3: A Critic or Checker to review the assembled result

Run the full workflow. Document: how long did the AI-assisted version take vs. how long it would have taken without AI? What was the quality of the final output?

Exercise 13 — Pattern + Advanced Technique Combination (Extension)

Goal: Combine a pattern with a technique from Chapter 10.

Take one of the 15 patterns from this chapter and enhance it by adding one of the Chapter 10 techniques: - Add CoT to a Critic or Analyzer pattern - Add few-shot examples to a Rewriter or Brainstormer pattern - Add self-critique to a Generator pattern (generate options → critique options → revise) - Add structured decomposition to a Planner pattern

Write the enhanced version. Test it against the base pattern. Document the improvement.

Exercise 14 — The "Failure Mode" Test (Extension)

Goal: Understand where your patterns break down.

Take your 5 patterns from Exercise 8. For each one, deliberately try to break it: - Provide extreme or unusual input (very long content, very short content, content in an unexpected format) - Fill in variables with unusual or edge-case values - Use the pattern on a task that's similar to but different from its intended use case

Document the failure modes you discover. For each failure: What specifically broke? Is this fixable with a small template change? Or is this a fundamental limitation of the pattern's use case?

Update your patterns to handle the failure modes you can fix.

Exercise 15 — Cross-Platform Pattern Testing (Extension)

Goal: Understand how patterns perform across different AI tools.

If you have access to more than one AI platform (ChatGPT, Claude, Gemini, Copilot, etc.), take one of your 5 core patterns and run it identically on two different platforms.

Assess: - Which platform produces better output for this specific pattern? - Does the format specification translate equally well to both? - Are there wording changes that improve results on one platform vs. the other?

Do you need platform-specific variants of this pattern, or does one version work for both?

Section D: Library Maintenance and Team Use

Exercise 16 — Pattern Audit (Core)

Goal: Build the habit of library maintenance.

Take the patterns you have built in previous exercises (or your existing prompt collection, if you have one). Apply this audit:

For each pattern: 1. Is it still current? (Has the task, audience, or tool changed?) 2. Is it actually reusable? (Does it have proper [BRACKET VARIABLES] or is it too specific?) 3. Is it documented clearly enough that you could use it after a 2-month gap? 4. Is there a better version of it you could build based on what you've learned since?

Update, archive, or delete patterns based on your audit. What percentage of your patterns needed revision?

Goal: Explore the team application of pattern libraries.

If you work in a team, identify one pattern from your personal library that would be useful for other team members. Prepare it for sharing:

Write clear documentation (not just the template — the use case, notes, and example)
Remove any personal or confidential information from the example
Add any team-specific context (your company's standard formats, typical audiences, etc.)
Share it with at least one colleague and ask them to test it

What feedback did you get? Did they need additional context? Did they use it differently than you intended?

Exercise 18 — Pattern Discovery Interview (Extension)

Goal: Build patterns by learning from others' experience.

Interview a colleague who uses AI tools regularly (doesn't need to be an expert). Ask: - What AI tasks do you do most often? - What prompts have worked really well for you? - What tasks does AI consistently fail at for you?

Based on their answers: - Build 1-2 patterns that would improve their most common failed tasks - Test the patterns with them using their actual task content - Document the patterns for potential team library inclusion

What did you learn about their AI use that surprised you?

Exercise 19 — The "One Year From Now" Pattern (Extension)

Goal: Build a pattern for professional development and reflection.

Create a Pattern specifically designed for a high-stakes recurring task you have coming up in the next month — something important, not just frequent. This might be: - A quarterly review document - A major client presentation - An important strategy proposal - An annual planning exercise

Build the pattern now, before you need it. Run a test version with placeholder content. When the real task comes up, use the pattern and compare the result to how you would have handled it without it.

Write a retrospective: what did having a prepared pattern make possible that ad hoc prompting would not have?

Exercise 20 — Build Your Pattern Library Index (Core)

Goal: Create a navigable overview of your full pattern library.

Create an index document for your pattern library that includes: - A table listing all patterns by name, use case, and date added - An organization by category (Communication, Analysis, Creation, Review/Check, Planning, etc.) - A quick reference showing the key variable for each pattern (the one variable that always changes) - A "quick start" section listing your 3 most-used patterns with direct links or quick access

This index becomes the entry point to your library. Test it: can someone who has not seen your library before find the right pattern for a task in under 30 seconds using only this index?