Week 5 Self-Paced Module: Advanced Techniques

Overview

This module develops three things today's lecture introduced but didn't have time to cover in depth: self-correction, task decomposition, and a pair of techniques that work above the level of a single prompt — Automatic Prompt Engineering (APE) and self-consistency. You saw self-correction work in the lab; this module explains what makes the loop reliable and where it breaks. Task decomposition covers what to do when a task is too complex for a single prompt. APE and self-consistency are qualitatively different from everything else covered so far: with APE the model participates in writing its own prompt, and with self-consistency you run the same prompt many times and treat the outputs statistically rather than individually.

Why This Matters

Self-correction's most common failure is sycophantic approval — a vague critique produces a model that says “this looks great” and changes nothing. Week 6 explains why this happens at the training level; this module gives you the practical fix now, so you can design around it before you've built a system that depends on it. Task decomposition matters because any project with a multi-step AI process is almost certainly better off decomposed — it is the difference between “the AI got the wrong answer” and “step 2 of the AI pipeline got the wrong answer,” which is the difference between a demo and something you can debug. APE and self-consistency are higher-cost techniques you won't use in most places, but knowing precisely when they help — and, just as importantly, when they actively mislead you — is what lets you reach for them deliberately instead of hoping they work.

Format and Timing

• Framing video (~20 minutes, posted on E3) — link coming soon; check back before starting the module.
• Required reading — two short sections of Lilian Weng's “Prompt Engineering” plus one Claude model card (~25 minutes combined). Linked below.
• Multiple choice questions (單一選擇題) — four questions on E3, about 10 minutes. Submit by the end of this Sunday to mark the module complete.
• Total estimated time: ~60 minutes

What You'll Learn

• Self-correction in depth — three requirements for a loop that produces genuine improvement instead of sycophantic approval: specific, binary critique criteria; a critique prompt that's harder to approve than to reject (“identify the most significant problem, assuming there is one”); and a narrow revision instruction (“fix only the identified issue”). Always cap the iteration count — after two cycles, the output is either done or needs human review, not a third attempt.
• Where self-correction fails — four failure modes: sycophantic critique, a revision that fixes one thing and breaks another, a problem the model genuinely can't solve regardless of iterations, and systematic errors that the same model can't catch in itself because it doesn't know what it doesn't know.
• Task decomposition — least-to-most prompting (you pre-define the sub-steps: requirements → edge cases → implementation) versus successive prompting (each step is determined by what the previous one produced, with a human checkpoint in between). The signs you need it: “it gets the first part right and the second part wrong,” or “I can't tell why it got the wrong answer.” Decomposition's biggest gift isn't better outputs — it's knowing exactly which step failed.
• APE in depth — treating prompt-writing as a search problem: the model generates candidate instructions from input/output examples, scores them, and refines the best ones. The step most people skip: testing the winning candidate on a held-out set it wasn't selected on, for the same train/test reason this matters in machine learning generally.
• Self-consistency in depth — sampling the same chain-of-thought prompt many times at temperature > 0 and taking the majority answer, because correct reasoning paths tend to converge while wrong ones scatter. This only works when errors are random — if the model makes the same systematic mistake every time, majority vote just gives you confident agreement on the wrong answer.
• Reliability vs. performance — two different goals that call for different techniques. Reliability means consistent, acceptable output across the real range of inputs (sensitivity testing, regression testing, decomposition). Performance means the best possible output on a specific input (self-correction, APE, self-consistency) — and performance tuned on a narrow set of examples can quietly degrade reliability everywhere else.

Required Materials

• Framing video: posted on E3 under Week 5 Self-paced Module.
• Reading: Lilian Weng, “Prompt Engineering” — read only the “Self-Consistency Sampling” and “Automatic Prompt Design” sections. In Automatic Prompt Design, focus on the APE description and its three numbered steps; the gradient-based methods at the start and the CoT-construction methods at the end are context you can skim.
• Reading: Claude model card — pick one model (e.g., Claude Opus 5.5 System Card) and focus on the training section.
• Multiple choice questions: posted on E3 under Week 5 Self-paced Module Questions.

Optional Materials

If you want to go deeper on any of these topics (not required, but helpful if you're curious):

• Anthropic, “Prompt Engineering Overview” — Anthropic's own documentation on XML tags, system prompts, and Claude-specific techniques. A practical reference you'll likely return to all semester for your project work.
• Zhou et al., “Large Language Models Are Human-Level Prompt Engineers” (2022) — the original APE paper; read just the abstract and introduction. Shows the experimental setup and the finding that model-generated instructions outperformed human-written ones on several benchmarks, with the caveat about which tasks this applies to.
• Wang et al., “Self-Consistency Improves Chain of Thought Reasoning in Language Models” (2022) — the original self-consistency paper; read just the abstract and results. The results section shows performance curves across different numbers of sampled paths, useful for calibrating how many samples are worth running.

Completion and Assessment

← Back to Calendar