P.1 · Agent as Tutor

P.1 · 30 min

Agent as Tutor

Last month you asked Claude to explain webhooks. It wrote four beautiful paragraphs. You read them, thought "that makes sense," and closed the tab. Two weeks later a client asked you how their GHL webhook actually reaches Zapier, and you discovered that "that makes sense" and "I can explain this" are two different states of knowledge. You had rented the understanding. The rental expired when the tab closed.

This lesson fixes that. It teaches the one meta-skill the rest of Part P runs on: driving Claude as a tutor that forces you to know things, instead of a vending machine that dispenses explanations you will forget.

Where do you actually stand?

Before you spend ten hours on fundamentals, find out which of them you already have. This diagnostic scores five areas separately and recommends, per area, whether to take the lesson or skip it. It never blocks you. Answer honestly: fooling a quiz you grade yourself is the least profitable crime available.

Entrance diagnostic

Answer every area to get a per-area skip/take recommendation. Nothing here is locked; the prequel is always available.

Terminal

Q1You open a terminal and want to know which directory you are in right now. Which command tells you?
Q2A script fails with 'permission denied' when you run ./backup.sh. Which command makes it runnable?
Q3You want to count how many lines in server.log contain the word ERROR. Which pipeline does it?
Q4What is the difference between > and >> when redirecting output into a file?
Q5You run a tool you know is installed and get 'command not found'. Most likely cause?

Git

Q1You edited three files but want only notes.md in the next commit. What do you run?
Q2Your last commit message has a typo and you have not pushed. Cleanest fix?
Q3git status shows 'modified: app.js' under 'Changes not staged for commit'. What does that mean?
Q4You want to throw away your uncommitted edits to notes.md and get back the committed version. What do you run?
Q5Mid-merge, chili.txt contains lines with <<<<<<< and >>>>>>> in it. What is the correct move?

JavaScript / TypeScript

Q1What does [1, 2, 3].map(n => n * 2) evaluate to?
Q2What does calling an async function return, immediately, before any await inside it finishes?
Q3Your script crashes with: TypeError: Cannot read properties of undefined (reading 'email') on the line user.email. What is true?
Q4In TypeScript, greet is declared as function greet(name: string). You write greet(42). What happens?
Q5What does const { email } = contact; do?

SQL

Q1Which query returns only the contacts named exactly Dana?
Q2The opportunities table has a contact_id column. You want each opportunity listed with its contact's name. What do you need?
Q3You run DELETE FROM contacts; with no WHERE clause. What happens?
Q4What does a primary key guarantee?
Q5Queries filtering opportunities by stage_id got slow as the table grew to 200k rows. The standard first fix?

How the Web Works

Q1Your Zapier webhook calls an API endpoint and gets a 404. What does that tell you?
Q2You are creating a new contact through a REST API. Which HTTP verb does the request almost certainly use?
Q3An API responds with the JSON body {"contact": {"id": 42, "tags": ["hot"]}}. Where is the id?
Q4Right after rotating an API key, your requests start returning 401. Most likely cause?
Q5You type a URL into a browser and press enter. What happens first?

Take the lessons it recommends. Skim the ones it clears you on, or skip them outright. Every Part P lesson stands alone.

The map: why explanations do not stick

Reading an explanation produces recognition: the feeling of "yes, that follows." Recognition is real, but it is stored shallow. What survives is the memory that an explanation exists, not the ability to rebuild it. The states you actually move through look like this:

Rendering diagram...

Almost everyone using AI to learn parks at the second box and believes they reached the fourth. The tutor loop exists to force the last two transitions, and Claude is unusually good at running it, for one reason: it never gets tired of your questions, never judges the basic ones, and is available at your kitchen table at 11pm when no human expert is.

One warning before the prompts. Claude's default failure mode as a teacher is agreeableness. Ask "so it's basically like a phone number for a server, right?" and it will often say "exactly!" even when your analogy is 70% right and the missing 30% will bite you later. You correct for this by instructing it, explicitly, to be adversarial about your understanding. Every prompt below does that.

The tutor prompt library

These four prompts are the toolkit you will use through all of Part P, and honestly, forever. Copy them somewhere permanent. Any Claude surface works for tutoring: the claude.ai chat interface is fine for now. From Part 0 onward you will live in Claude Code in the terminal, which also has a built-in Learning output style that asks you to write small pieces of the code yourself. Worth switching on when you get there.

Mode 1: Socratic. For learning something new. The instruction that matters is the ban on answers.

PromptSocratic mode

I want to learn TOPIC. Do not explain it to me and do not give me answers. Instead, teach me by asking me one question at a time, starting from what I already know. Use my answers to find the edge of my understanding and ask the next question just past that edge. If I am wrong, do not correct me directly: ask a question that makes the contradiction obvious.

Context about me: I know X and Y already. I am learning this because Z.

Start with your first question.

Mode 2: Explain-back. For testing whether recognition became ownership. You produce the explanation; Claude grades it like a skeptic.

PromptExplain-back mode

I am going to explain TOPIC to you in my own words. Grade my explanation harshly. Do not be polite about it. Specifically:

  1. List anything I said that is wrong, with what is actually true.
  2. List anything importantly incomplete, and why the gap matters in practice.
  3. Ask me the one follow-up question most likely to expose whether I actually understand this or memorized the shape of it.

Here is my explanation:

Mode 3: Quiz-me. For drilling. The escalation instruction is what separates this from a trivia game.

PromptQuiz-me mode

Quiz me on TOPIC, one question at a time. Rules:

  1. Every question must be applied: a scenario or a prediction, never a definition. "What will this print" beats "what does this term mean."
  2. After I answer, tell me if I am right and why, briefly.
  3. If I get one right, make the next one harder. If I miss, drop one level and come at the same idea from a different angle.
  4. Stop after 8 questions and tell me exactly which concepts I am weak on, ranked, with no encouragement padding.

Mode 4: The prove-it protocol. The exit exam you give yourself. This one is less a prompt than a discipline, and it is the one people skip.

PromptProve-it protocol

I just finished learning TOPIC with you. Set me a small practical task that proves I can apply it: something I can do in under 15 minutes in my own terminal or editor, with a way to check my own result. Give me only the task and the success criteria. Do not include hints, steps, or the solution. After you give it to me, I am closing this chat and doing it cold. When I come back with my result, review it against what I was supposed to learn.

The closing of the chat is not theater. It removes the safety net that was quietly doing your thinking. If you cannot do the task without reopening the conversation, you did not learn the thing. You learned where the thing was written down, which is worth much less.

Detecting the nod-along state in yourself

You cannot always run the full loop, so learn the tells. You are nodding along, not learning, when:

  • You read Claude's answer and your next message is a new question instead of a restatement. Restating is how you find out the answer did not fully land.
  • You could not, right now, explain the thing to a colleague without looking at the chat.
  • The phrase "yeah, that makes sense" occurs to you. That phrase is recognition congratulating itself. Treat it as an alarm, and answer it with explain-back mode.

The reverse tell also matters. When you can predict what Claude will say before it says it, stop drilling that topic. You own it. Part P is long enough without re-proving things you already know.

Where it breaks

The tutor loop fails in two predictable ways. First, answer-seeking leaks back in. You start in Socratic mode, hit friction on question three, and type "just tell me." Claude will comply, because you are the operator. The loop is only as adversarial as you keep it, which is why the prompts above hand Claude explicit rules: rules are harder to casually override than vibes. Second, the loop gets skipped for "easy" topics, and the easy topics are exactly where confident wrongness hides. You have used webhooks for years, so you skip explaining them back, and the gap you carry is the one an entire automation build later lands on. Run explain-back on the things you are surest about at least once. The results are reliably humbling.

Lablab-p-1Run the loop once, end to end

Goal: Learn one small thing you genuinely do not know, then demonstrate it cold, with the chat closed.

  1. Pick a target you do not currently know. It must be small and checkable. Good candidates: what an environment variable is and how to set one, what JSON actually is structurally, what a git commit contains. If the entrance quiz above flagged an area, pick your target from that area.
  2. Open a fresh Claude chat. Paste the Socratic mode prompt with your topic and your real context. Work through it honestly: answer every question yourself before reading on, out loud or in writing.
  3. When Claude's questions stop surprising you, switch to explain-back mode. Write your explanation without scrolling up. Submit it. Read the harsh grading and patch the gaps it exposes.
  4. Run the prove-it protocol. Get your task and its success criteria.
  5. Close the chat. Actually close it. Do the task in your terminal or editor.
  6. Reopen Claude, report exactly what you did and what happened, and ask for the review.

Verify

  • You completed the task without reopening the original conversation.
  • Your result meets the success criteria Claude set before you closed the chat.
  • You can name the one gap explain-back mode caught that you did not know you had. If it caught nothing, your topic was too easy: run the lab again with a harder one.
>Troubleshooting
  • Claude keeps drifting into explanations during Socratic mode. Reply with: "You are explaining. Return to asking me one question at a time." It will hold the frame once reminded; you are allowed to steer the tutor.
  • The prove-it task feels too big or needs tools you do not have. Say so and ask for a task using only what you have installed. A tutor task should never require setup; setup is what Part 0 is for.
  • You failed the cold task. Good, that is the system working: it caught rented understanding before you built on it. Reopen the chat, show your failed attempt, and run the loop again from where it broke. A failed prove-it costs 15 minutes. The same gap discovered inside a real project costs an afternoon.

Knowledge check

Knowledge check

Q1You ask Claude to explain closures, read the answer, and think 'that makes sense.' By this lesson's model, what state are you in?
Q2Mid-Socratic-session, you hit a hard question and type 'just tell me the answer.' Claude complies. What actually went wrong here?
Q3Why does the prove-it protocol require actually closing the chat before doing the task?
Q4You explain webhooks back to Claude with 'so it's basically a phone number the server calls,' and Claude replies 'Exactly right!' What should you suspect?

Sources

Everything else in this lesson is method, not fact claims about tooling. The protocol's authority is that it forces production over recognition, which you will verify on yourself in the lab.