Neill's Vibe — Module T4·F31 · Claude Code — the AI inside your actual project

01 · the scene

Copy out. Paste the fix back. Copy the next file out. Repeat until something breaks.

The first weeks of this were done in a browser chat tab. The loop went like this: paste a file in, ask for the fix, copy the answer back into the editor, run it, hit a new error, copy that file in, paste the next fix back. The AI never saw the real project — only the snippets I hand-fed it. So it kept "fixing" code that didn't match what was actually on disk: it patched a file it had imagined from two messages ago, missed the import three files over it had never been shown, and confidently rewrote a function I'd already changed. I was the courier carrying parts between a workshop and a mechanic who was never allowed in the building.

the chat-tab loop — me ferrying parts back and forth

# the actual rhythm, message after message:
[me] here is app.js, it crashes on save. <pasted 80 lines>
[ai] change line 40 to this. <pasted fix>
# i copy it back, run it, NEW error in a file the ai never saw:
ReferenceError: formatDate is not defined (utils.js:12)
[me] ok here is utils.js too <paste> ... and here is the config <paste>
# every fix opened a file it had never been shown. i was the only link.

Neill51% · the terrain

"It felt like describing my house to a builder over the phone. He'd tell me how to fix a wall he'd never stood in, based on the one photo I'd texted. Half his fixes were for a room that didn't exist anymore because I'd already changed it. I spent more time being the messenger than getting anything built."

Claude49% · the execution

"Honest version: in a chat tab I only know what you paste. I can't open the other files, I can't run the thing, I can't see that you already edited line 40. So I answer about a project I'm guessing at — and a confident guess about code I can't see is exactly how the wrong fix looks right. The fix isn't a better prompt. It's letting me work where the real files actually live."

02 · the why

Bring the parts to the mechanic, or move the mechanic into the shop.

A chat tab and Claude Code are the same model — but in completely different rooms. A chat tab lives in a browser, walled off from your computer. It only ever sees the text you paste, and the only thing it can hand back is more text for you to carry. That's the courier loop: you ferry every file in, you carry every fix back out, you run everything yourself, and the AI is blind to anything you didn't personally show it. Claude Code is the same AI given a workbench inside your actual project folder. It's a program you run in your terminal — the black text window where you type commands to your computer — pointed at one real folder on your disk. Now it can read any file in that folder itself, edit files in place, run the project and read the real error, and — when you say so — commit the change to git. You stopped being the courier. The AI is in the shop, with the real parts, the real tools, and the real engine running.

✉

Chat tab

paste-in, paste-out

Lives in the browser, sealed off from your files. Sees only what you paste; hands back text you must carry into the editor and run yourself.

⚙

The terminal

where you run it

The plain text window where you give commands to your computer. You start Claude Code here, aimed at one real folder. That folder is its workshop.

▤

Claude Code

reads · edits · runs

The same AI, now living in your project. It opens the real files, edits them in place, runs the code, reads the real error — no courier in the middle.

The model: picture a master mechanic. In the chat-tab world he's stuck in another building; you photograph one part, text it over, he texts back instructions, you walk the part back, bolt it on, find the next problem, photograph that. In the Claude Code world you hand him the keys to the garage. He walks the rows himself, picks up whatever part he needs, turns the engine over to hear the real knock, and fixes it on the spot. Same mechanic, same skill — the difference is whether he's looking at the actual car or guessing from your photos. Claude Code isn't a smarter model. It's the same model standing inside your real project instead of you ferrying parts to it through a window.

03 · predict it

You point Claude Code at a folder and say "the app crashes on save." Predict its first move.

You start Claude Code inside a real project folder — say a small web app — and type one sentence: "the app crashes when I click Save, fix it." You paste no code. You name no file. In a chat tab this question would be useless: it can't see anything you didn't paste. Here, what does it do first?

Not quite — those are all the chat-tab habit. A and B leave you ferrying files in and fixes out; D imagines a cloud copy, but Claude Code works on the real files on your own disk. The whole shift is that the AI can open and run the actual project itself. Which option has it read the real files with no pasting from you?

That's the prediction to hold — and getting it right is your first win here: you already grasp the one thing that changes everything. It reads the real files itself — finds the Save handler, follows it into the file that actually throws, can run the app to reproduce the crash — and edits the right file in place, all on your real disk. You never paste a line. This module is read-first on purpose, so the hands-on payoff is the end lab: there you'll run it, deliberately break it once, undo it in one move, and watch a real file on your disk change with your own eyes.

04 · the walkthrough

One sentence, and the AI does the courier run itself.

start it in the real folder

step 1In your terminal, go to the project folder and run claude. It opens pointed at that one folder — its workshop. Everything it does happens to the real files on your disk, not a copy.

it reads, you don't paste

step 2You type "the app crashes on Save." It reads the relevant files on its own — opens the Save handler, follows it into utils.js where the real error lives. The thing you'd have spent ten messages pasting, it just does.

it edits + runs in place

step 3It edits the file in place and runs the app to reproduce and confirm. Edits pause for your yes/no by default, so nothing changes without your nod — you stay the operator, it does the legwork.

you verify, then commit

step 4You click Save yourself — the crash is gone. Only then do you tell it to commit the change to git (your project's save-history). You watched it work, on the real files, before trusting it.

05 · prove it · gate

Teach it back to unlock the payoff.

Same rule as always: answer it right, or the module isn't done.

A friend says: "Claude Code is just the chat tab with a nicer skin — you still paste your code in and copy the answer out." In one move, what is the actual difference?

// name the real distinction · one correct answer unlocks Module T4·F31

Not the core of it. The model isn't the difference (A) — it's the same AI; "memorizes forever" (C) isn't how it works, it reads files fresh each time it needs them; and offline (D) isn't the point either. The one thing that changes everything is where the work happens. Which option moves the AI into your real files instead of leaving you to ferry them?

That's it. Same model, different room: Claude Code lives in your real project folder, so it reads the actual files, edits them in place, and runs the code itself. The courier loop — paste in, copy out, run it yourself — disappears. That's also why it scales: a non-coder can run a fleet of apps only because the AI works on the real things on disk instead of being hand-fed snippets through a window. The ban took the operator layer away overnight; this is the layer — the AI moved into the workshop, which is what made the workflow, not any one model, the asset. Module unlocked. ↓

the durable idea

A chat tab makes you the courier; Claude Code moves the AI into your real project. Same model — the difference is whether it's looking at your actual files or guessing from what you pasted.

06 · factory payoff

⊘ locked — pass the teach-back to claim this piece of the machine

Your first Claude Code session — a checklist and a folder to point it at.

Two things you own the second the gate opens. FIRST-CLAUDE-CODE-SESSION.md is a plain-language checklist for your very first run: install it, open your terminal, go into a real project folder, start claude, give it one small honest task, watch it read and edit the real files, then verify with your own eyes before you let it commit. No jargon left unexplained — terminal, folder, commit, and the rest. And starter-project/ is laid out as a tiny but real project — a sane starter layout carrying the files a real project carries, including the one file Claude Code actually reads on its own: a CLAUDE.md (the standing-instructions file it loads at the start of every session, so your house rules outlive the chat). Claude Code works on any folder — it doesn't require this shape — but a real project usually has a README.md that tells it what the project is, a .gitignore + .env.example so secrets never ride along, and a src/ folder for the actual code. Standing instructions are one layer; enforcing them automatically (a hook — an automation it runs for you) is its own module later. You now own the thing that ends the courier loop — and this is the layer the whole factory stands on: once the AI works on the real files instead of pasted snippets, the workflow becomes the asset, and the asset survives any one model getting yanked overnight.

▶ now feel the failure FIRST, then the fix — don't trust it

Don't take "it edits in place" on faith — that's the whole lesson, and the fastest way to learn it is to break it on purpose first. Run the starter script, start Claude Code in the folder, and deliberately do the lazy thing: give a one-word task and don't tell it to read the file. Watch it patch from a guess. Then you'll undo that in one move and do it right.

break it, undo it in one move, then do it right

# 1. build the starter project and step into it
bash setup-starter-project.sh && cd my-first-app
claude
# 2. ON PURPOSE: a vague task, and you DON'T tell it to read the file first.
> make the greeting friendlier
# it guesses from memory and writes a line that isn't even in your file:
edited src/app.js -> console.log("Hey there, friend! :)");
# that's the chat-tab habit leaking through. don't keep it. UNDO in one move:
git checkout .
Updated 1 path from the index # the file is back to "Hello, world". reversible.
# 3. NOW do it right: a precise task that names the file, so it reads it first.
> read src/app.js, then change the greeting to say "Hello, workshop"
# it EDITS the real file (you approve). now check it yourself, no AI:
grep -rn "Hello, workshop" src/
src/app.js:3:console.log("Hello, workshop");
# the words are in the file on YOUR disk. it worked on the real thing.

You just lived both halves: the vague ask let it patch from a guess — the chat-tab failure, now happening on your real disk — and git checkout . threw that away in one move, which is exactly why you can let it try at all. Then the precise ask had it read the actual file and your grep proved the words landed in the real src/app.js. Verifying with your own eyes — and knowing the undo is one command — is the whole difference between a chat tab and Claude Code.