🍳 The WAT framework

WAT is the course name: Workflow (recipe), Agent (cook), and Tools (ingredients/appliances).

It establishes the mental model that supports the entire course — without it, each subsequent track feels disconnected.

Workflow, Agent, Tools, distinct roles.

A sequence of steps in plain text (markdown) explaining what to do and in what order.

It's the piece that preserves the intent—without it, the agent reinvents the process with every request.

Markdown, step by step, not code.

Claude Code: reads the workflow, chooses the right tool, runs it, and adjusts if something turns out differently.

It's the piece that brings judgment to the process—it interprets the recipe instead of just repeating it.

Interpretation, tool selection, correction.

The concrete actions the agent triggers: reading a file, running a command, sending an email, calling an API.

Without tools, the agent would only have opinions—learning paths 2 and 4 cover providing and connecting tools.

Tool, API, real execution.

Each piece serves a different role: intent (workflow), judgment (agent), and capability (tools).

Separation is what makes the system predictable and flexible at the same time.

Separation of responsibilities.

An agent without a recipe gets expensive and erratic; a tool without a recipe or a cook just sits there, useless.

Understanding these two failure points helps you avoid asking for automation before preparing the recipe.

Cost, unpredictability, idle tool.

Read the step, choose the tool, execute, observe the result, decide on the next step.

It's this repeated loop that turns the written recipe into real work done.

Cycle, loop, repeat until done.

The agent identifies where it is in the process, using the conversation and the existing files.

Without knowing “where it is,” the agent can’t correctly decide what to do next.

State, context, session memory.

Given the step and the available tools menu, the agent chooses the most suitable one.

The clearer the available tools, the better the choice — a topic covered in Tracks 2 and 3.

Tool selection, options menu.

After running it, the agent reads the result: it worked, it errored, or it came out differently than expected.

This check is what triggers the correction — without it, errors would go unnoticed.

Observation, result verification.

Repeating after fixing a temporary error is normal; repeating without changing strategy means it’s stuck.

Recognizing the difference keeps you from getting stuck in a costly loop without realizing it.

Healthy loop, stuck loop, cost.

Success, pause to ask something only you know, or a hang-up that needs intervention.

Knowing how to recognize which of the three is happening is a skill you develop with practice.

Success, pause, hang-up.

Self-correction is real, but it’s marketed as more than it is: an AI thinking on its own forever.

Confusing the two phases is the source of most broken expectations about AI.

Self-correction, marketing exaggeration.

In Claude Code, the agent tries a step, reads the error, adjusts, and tries again several times.

It's the phase behind the reputation of “AI that corrects itself”—and here, that's true.

Trial, error, correction, supervision.

Once published and scheduled, the agent runs the fixed workflow, like any traditional automation.

Predictability is what you want from an automation that runs on its own every day.

Determinism, fixed workflow.

Inside interactive Claude Code: flexible. Published and scheduled: fixed.

It’s not about “how smart” the agent is—it’s about where it’s running.

Publishing as a dividing line.

Demonstrations show the build phase and imply that it continues forever.

Understanding this helps avoid two frustrations: expecting too much or losing faith in the entire course.

Overgeneralization, broken expectations.

Use the build process to make the workflow robust; monitor it in production instead of waiting for self-correction.

Helps you plan the right amount of testing before publishing something for real.

Monitoring, manual maintenance.

Workflow that doesn't tell the agent enough to decide without guessing.

It’s not that the agent “didn’t understand”—the instructions just didn’t say enough.

Vagueness, wrong assumption.

Tools require an API key or permission—without it, the step can't be executed.

The solution is never to rewrite the workflow; it’s to configure the missing credential.

API key, permission, credential.

The agent makes the wrong decision because context is missing — examples and rules from the CLAUDE.md.

The CLAUDE.md exists precisely to carry this context persistently.

Context, CLAUDE.md, examples.

Instructions that conflict with each other allow more than one reasonable interpretation.

Unlike vague instructions, ambiguous instructions have too many conflicting rules.

Ambiguity, undefined priority.

Different result, password prompt, deviation from the norm, or inconsistency across sessions.

Learning to read the clues helps you avoid “arguing” with the agent without understanding why.

Behavior-based diagnosis.

Clear recipe? Key configured? Enough context? No competing instructions?

Going through the checklist resolves most failures before you rewrite everything from scratch.

Checklist, quick diagnosis.

A newsletter automation: researches a topic, drafts a piece, and prepares it to send.

Small enough to fit in one session, complete enough to exercise everything.

Research, writing, sending.

Write the recipe in 5 steps, avoiding the vague-recipe mistake.

This is the investment that saves the most time and tokens for the rest of the build.

Workflow written down, safety brake.

A complete prompt, ready to paste, with the variable parts marked.

Actually copying and running it is what makes the learning stick—not just reading about it.

Copy-run prompt, variables marked.

Read the draft, give specific feedback, ask for only the part that failed to be redone.

Practices the build phase of module 1.3.

Specific feedback, targeted correction.

The three mistakes in module 1.4 show up almost every time on the first attempt at this build.

Recognizing common errors speeds up the fix on the first try.

Recurring errors, quick diagnosis.

Provide access to the real email tool (Path 2) and publish/schedule (Paths 4 and 6).

Closes the loop by showing where this build leads as the next tracks are added.

Deploy, scheduling, next steps.