Anthropic’s Prompt Engineering Tutorial, Mapped

There is exactly one prompt engineering course taught by the company whose model you are prompting, and it is free in a notebook repository. Anthropic’s interactive tutorial, at anthropics/prompt-eng-interactive-tutorial with 38,282 stars, walks you from your first structured prompt to legal and financial-services grade constructions, with exercises you actually complete rather than skim.

This walkthrough maps the course as it stands in 2026: what each chapter teaches, how to run it, which exercises carry the lessons, and where the material needs supplementing now that prompting lives inside agent loops and skill files rather than standalone text boxes.

Prompt engineering: what the tutorial covers

The course is nine chapters plus an appendix, sequenced deliberately from mechanics to judgment. The progression assumes no prior experience and ends at prompts a professional would ship:

Level	Chapters	What you learn to do
Beginner	1 to 3	Basic prompt structure, being clear and direct, assigning roles
Intermediate	4 to 6	Separating data from instructions, formatting output, thinking step by step
Advanced	7 to 9	Using examples, avoiding hallucinations, building complex prompts for industry use cases

The two most undervalued chapters are 4 and 8. Separating data from instructions is the habit that keeps prompts maintainable as they grow, the difference between a prompt you can reason about and one you debug by vibes, and it maps directly onto modern practice where context and instructions live in separate files. Avoiding hallucinations teaches the honest techniques, letting the model say no, providing grounding, checking its own work, that remain the core of trustworthy output regardless of model generation.

How to run it: three surfaces

The tutorial ships in three forms and the choice matters less than starting. The Jupyter path is the canonical one: run the notebooks in order, complete each chapter’s exercises, and use the Example Playground at the bottom of every lesson, a scratch area where you mutate the lesson’s prompts and watch Claude’s responses change. The answer key is published, and the course’s stated expectation is that you work through chapters in order, because later chapters assume the vocabulary of earlier ones.

The second surface is the Claude for Sheets edition, a Google Sheets version using Anthropic’s spreadsheet extension, which Anthropic itself describes as the more user-friendly option and which removes every barrier except a Google account. The third is simply reading, which works for review but wastes the course’s central mechanic: the exercises are where the lessons land, and a read-only pass produces the feeling of understanding rather than the thing itself.

The exercises are the course

What separates this repository from a prompt-engineering blog post is the exercise design. Each chapter closes with problems of graded difficulty, and the playground lets you test your answer immediately against the model, with the answer key one tab away when you are genuinely stuck rather than lazily curious. The failing grade for a prompt is concrete: wrong format, missed instruction, hallucinated detail, and the retry loop builds the reflexes that transfer to real work.

The industry chapter makes the transfer explicit. Its worked examples build a chatbot and a legal-services prompt from scratch, and the closing exercises hand you financial services and coding scenarios to construct on your own. Those two exercises are the course’s final exam in practice, and completing them without the answer key is a reasonable bar for calling yourself through.

A worked plan: two weeks, an hour a day

Here is the realistic completion plan we would hand a colleague. Days one to three cover chapters 1 through 3, one chapter per day, with every playground experiment executed rather than read. Days four to six cover chapters 4 through 6, spending double time on chapter 4, whose data-instruction separation deserves slow absorption. Days seven and eight cover example usage and hallucination avoidance, and days nine and ten build the chapter 9 industry prompts from scratch.

Two rules make the plan work. First, write your answers before opening the answer key, every time, because the gap between your attempt and the reference answer is the actual lesson. Second, keep a personal prompt journal of your failures with one line on why each failed, because the failure catalog is the artifact you will still be using a year from now when the course details have faded.

What the tutorial cannot teach in 2026

The course’s age shows in what it does not cover, and being clear about the gap makes it more useful rather than less. It teaches prompting as a standalone skill, one human composing one prompt for one response, while 2026 practice embeds prompts inside agent loops, skill files, and system contexts that accumulate across turns. It predates the current model families entirely, shipping written against Claude 3 Haiku as its cheap teaching model, so costs and behaviors have moved under it, though the techniques themselves have aged unusually well because they address how attention and instruction-following work rather than one model’s quirks.

The supplement for the gap is our own coverage: the technique-by-technique prompt engineering guide for breadth beyond one vendor’s course, and the Claude Fable developer guide for how current Claude models want to be driven. Together the three cover past, present, and practice.

Prompt engineering: common mistakes the course corrects

• Writing instructions as prose soup instead of structure. Chapters 1 and 4 teach the discipline of separated, labeled sections.
• Demonstrating by describing rather than showing. Chapter 7’s few-shot patterns show how examples outperform explanations.
• Forcing an answer the model cannot support. Chapter 8’s permission to say no is the single highest-value habit in the course.
• Tuning one prompt forever instead of testing variations. The playground mechanic trains the compare-and-iterate loop.
• Copying answer-key prompts without writing your own first, which converts the course into reading.

Prompt engineering: best practices for working through the tutorial

• Do the chapters in order; the vocabulary is cumulative and chapter 9 assumes all of it.
• Use the cheapest model tier while learning; the techniques are model-independent and your budget is not.
• After each chapter, apply its technique to one real prompt from your own work the same day.
• Keep your exercise answers in your own notebook file so the playground becomes a personal corpus.
• When you finish, rebuild your most-used production prompt using chapters 4, 7, and 8 together.

Prompt engineering: frequently asked questions

Is the tutorial still worth taking given its age?

Yes, because the fundamentals it teaches, structure, clarity, separation of data from instructions, examples, hallucination guards, have survived every model generation since it was written. Treat the model-specific details as dated and the techniques as current.

Do I need to know Python or Jupyter to take it?

No. The notebooks require nothing beyond running cells, and the Claude for Sheets edition removes even that, running the entire course inside a spreadsheet. Programming background helps nowhere and lacks nowhere in this course.

How long does the full course take?

Roughly ten to fifteen hours for the nine chapters with exercises done honestly, comfortably two weeks at an hour a day. Compressed weekend runs work for review but undermine the exercise loop the course is built around.

Does completing it make me a prompt engineer?

It makes you fluent in the fundamentals, which is the prerequisite, not the profession. Real proficiency comes from applying the patterns to your own domains, which is why the same-day application habit matters more than the certificate of completion.

What should I take after finishing?

Move from single prompts to systems: chaining techniques from the appendix, then the agent-era patterns in our related guides below, where prompts compose into loops with tools and memory.

Why does the course teach with the oldest, cheapest model?

Haiku-class models are the right teaching instruments for a reason worth understanding. A small model exposes technique: when the model has less raw capability, the difference between a sloppy prompt and a structured one is dramatic and immediate, which makes the lessons vivid. On a frontier model, brute capability can mask mediocre prompting, the output looks fine while being fragile, and the student learns less from the same exercise. The economics also matter for adoption; a course whose exercises cost cents to run gets completed, and one that burns dollars per lesson gets abandoned. The trade is that some failure modes, particularly subtle hallucination, are easier to trigger and study on bigger models, so after finishing the course it is worth re-running your three hardest exercises on a frontier model to see which lessons hold and which become less critical with scale. The reverse experiment teaches too: run your best frontier-tuned prompt on a small model and watch it collapse, which is the cheapest available demonstration that structure, not model size, is doing a share of the work you attributed to intelligence.

How do the techniques map onto agent-era prompting?

More directly than the course’s age suggests. Separating data from instructions is chapter 4’s lesson and also the architecture of every agent system, where persistent instructions, retrieved context, and per-turn user input are distinct layers that must not bleed into each other. Assigning roles prefigures system prompts and persona definitions. The step-by-step thinking chapter is the ancestor of what became extended reasoning modes. Using examples became few-shot seeding of skill files. What genuinely changed is scope: the course optimizes a single exchange, while an agent prompt author optimizes a loop that runs hundreds of exchanges, which adds concerns the course lacks, context budget management, state tracking, and graceful degradation when the loop drifts. Learn the fundamentals here, then learn the loop-level concerns in agent-specific material. The order matters more than it appears: engineers who start with loops and no fundamentals build elaborate scaffolds around bad prompts, and the scaffolding hides the problem until production traffic finds it.

How does this compare with the dair-ai prompt engineering guide?

The two resources we have covered are complements with different authors and intents. Anthropic’s course is a vendor teaching its own model’s behavior, interactive, exercise-driven, and opinionated in the best sense, because the opinions are grounded in watching their model fail. The technique reference guide is vendor-neutral breadth, a catalog of named methods with papers attached, stronger as a reference and weaker as a first course because catalog reading does not build reflexes. The efficient sequence is the Anthropic course first for the reflexes, the reference guide second for vocabulary and breadth, and the intersection, techniques both endorse, is the core curriculum of the field. Teams benefit from splitting them too: everyone does the course, and the reference guide lives on the shelf for lookups during reviews. A third resource earns a mention for completeness: the Claude for Sheets edition of this same course makes the material usable in environments where notebook tooling is blocked, which for some enterprises is the difference between a team that learns prompting and a team that argues about it However your team consumes it, the completion metric that matters is behavioral rather than ceremonial: within a month, are prompts in code review discussed using the course’s vocabulary, structure, data separation, examples, grounding, and if not, the course was consumed but not absorbed..

What do the industry chapter exercises actually ask for?

Chapter 9 closes the course by having you construct prompts for professional contexts rather than toy tasks. The worked examples walk a customer-service chatbot and a legal-services prompt from a blank page to production shape, narrating the decisions along the way, and the two closing exercises hand you financial services and coding scenarios with requirements stated the way a stakeholder would state them, incompletely. That last detail is the point of the chapter. Real prompting work begins with an ambiguous request, and the exercises train the questions you ask before writing anything, what output format, what tone, what must never appear, who consumes the result. If you take the course for professional reasons, spend disproportionate time here, and after finishing, redo the financial services exercise for your own industry, because the transfer from their domain to yours is the actual skill being tested.

How should a team use this tutorial together?

As a shared baseline rather than a solo exercise. Prompt quality varies wildly across a team because everyone improvises privately, and the fastest fix is a common vocabulary plus a common set of reflexes, which is precisely what a nine-chapter canonical course provides. The workable format: everyone completes the course over the same two weeks, one chapter discussed per team session with each member bringing their own exercise answers, disagreements about answers discussed against the answer key. The dividend shows up in review, because a team that shares chapter 4’s vocabulary can say your data and instructions are bleeding together and be understood in one sentence. Keep the answer key out of the discussions until each member has committed to an answer aloud, and let the strongest prompter on the team lose at least one exercise publicly, which sets the tone that the course humbles everyone and the vocabulary is the prize.

How much of the course transfers to non-Claude models?

Nearly all of it, with calibration differences. Structure, clarity, data-instruction separation, examples, and grounding guards are model-agnostic disciplines, and the course’s techniques predate and outlast any single vendor’s releases. What shifts across models is calibration: how much scaffolding a frontier model needs before it performs, how literal the instruction-following is, and where each model’s failure modes sit. A practitioner who learns on Claude will transfer the habits intact and re-tune the amounts, which is the correct order, since habits are expensive to acquire and amounts are cheap to adjust. Teams on mixed stacks lose nothing by standardizing on this course for fundamentals.

What deserves a second pass after finishing?

Three exercises reward revisiting with fresh eyes. Rerun your chapter 4 exercise and check whether your current production prompts still separate data from instructions cleanly, because drift accumulates quietly in live prompts the way it does in code. Redo one chapter 8 hallucination exercise against your own domain’s failure cases, since the techniques land differently when the hallucinations are ones you have actually shipped. And rewrite your most-used prompt one more time, from scratch, without consulting your first attempt, then compare the two versions, because the delta is a direct measurement of how much the course moved your instincts, and repeating that measurement quarterly keeps them honest.

Take the course in order, do every exercise before peeking at the key, and apply one technique to your own work the same day you learn it. Two weeks of that yields the prompt engineering fundamentals that every model generation has so far left intact, and the playground habit of testing variations is the part you will still be using long after the specific prompts are forgotten.