The goal

Stage 0 sets the baseline every later stage is measured against: the raw model, and nothing else. The whole tutorial builds a mini Claude Code by wrapping this one call in more and more harness — a loop, tools, a permission gate, compaction, sub-agents. Before any of that, you need to feel exactly what the model can and cannot do on its own.

The answer is stark. A single messages.create call turns a prompt into text. The model is fluent, knowledgeable, often persuasive — and completely sealed off from your machine. It never reads a file, never runs a command, never sees the actual error. Everything it says about your repo is generated from imagination. The goal of Stage 0 is to make that sealed-off quality concrete, so the loop we build in Stage 1 lands as the thing that breaks the glass.

Build it

The entire stage is about twenty lines in tutorial/00-bare-model/agent.ts. It constructs one client, makes one request, prints the text, and stops.

First, a task comes in from the command line (with a default so the script always has something to do):

const task = process.argv[2] ?? 'Fix the failing test in this repo.';

Then the single, load-bearing line — one round-trip to the model:

const res = await client.messages.create({
  model: MODEL,
  max_tokens: 1024,
  messages: [{ role: 'user', content: task }],
});

Look at what is not there. No tools array is passed, so the model has nothing to call even if it wanted to. There is no while around this call — it happens exactly once. And nothing ever inspects res.stop_reason to decide what to do next; the value is only printed, not acted on.

Finally, we drain the response — assistant messages come back as a list of content blocks, and we print the text ones:

for (const block of res.content) {
  if (block.type === 'text') console.log(block.text);
}
console.log(`\n[stop_reason=${res.stop_reason}] It answered from imagination — it never saw your repo, never ran anything.`);

That is the whole agent. One call in, one block of prose out. The顾问 speaks; the glass never opens.

Run it

ANTHROPIC_API_KEY=… MODEL=claude-sonnet-5 \
  bun run tutorial/00-bare-model/agent.ts "fix the failing test"

A representative transcript:

This kind of failure usually comes from an assertion written backwards.
Open src/utils/format.test.ts around line 42 and swap expect(a).toBe(b)
to expect(b).toBe(a); you probably also need a null-guard in
formatDate() inside src/utils/format.ts. That should make it pass.

[stop_reason=end_turn] It answered from imagination — it never saw your repo, never ran anything.

Confident, specific, well-formatted — and every file path in it is a guess. There is no src/utils/format.test.ts unless the model happened to name a real file by luck. stop_reason is end_turn, never tool_use, because the model was given no tools to ask for. The run is over after one exchange.

对照 the real one

That single messages.create maps to exactly one line inside the real harness: deps.callModel(...), the streamed model call at claude-code/src/query.ts:659. Everything that makes Claude Code an agent rather than a chatbot is the machinery wrapped around that call — machinery this stage does not have:

• The real call lives inside a while (true) loop (claude-code/src/query.ts:307). Our call runs once and exits.
• As the response streams, the real loop pulls out tool_use blocks and flips needsFollowUp = true the moment the model asks to act (claude-code/src/query.ts:826-844). Our loop-less script has no tools to ask for, so this never fires.
• The real loop then branches on that flag — if (!needsFollowUp) return the answer, otherwise run the tools and go again (claude-code/src/query.ts:1062). We only ever hit the "no follow-up" case, which is why one call always ends the turn.
• When tools do run, their results are spliced back into the next round's messages: [...messagesForQuery, ...assistantMessages, ...toolResults] (claude-code/src/query.ts:1716). This is the递物窗 — the return channel. Our bare model has no way to put a fact back on the desk.

The bare model is not a broken agent; it is the ingredient an agent is built from. Stage 1 adds the loop, and suddenly the same model call can read stop_reason, run what it asked for, and try again. Deep-dive on that loop: /stories/loop/1/.

What breaks without it

There is no previous stage — Stage 0 is the floor. So the failure to show is what the bare call itself cannot do, no matter how smart the model:

• It never sees the repo. No file is read, no command is run. Every file name, line number, and error string in its answer is invented — plausible, sometimes even right by coincidence, but never checked.
• It cannot verify anything it says. With no way to run bun test, it can't know whether the test is red, why it's red, or whether its patch would turn it green. "Facts it actually verified: 0."
• It cannot change anything. stop_reason is end_turn; there is no tool_use, no tool_result, nothing downstream that could touch a file. The advice ends as text on a screen.

That gap — eloquence with zero grounding and zero agency — is precisely the hole the harness exists to fill. Every stage after this one is a door, a window, or a tool bolted onto the glass room.