Code Is for When You Know Where You Are Going. AI modes explained for anyone who has tested All and still not known which one to type into.
QUESTION. There are now two ways to work with an AI model such as Claude: a chat window, and an "agentic" tool such as Claude Code or Cowork that can open files and run programs on its own. Which one should you use, and for what?
SPINE. The two tools run the same model. What differs is who runs the loop. In a chat, the model writes once and stops, and you decide what happens next; you are the loop. In an agentic tool, the model reads, acts, looks at the result, and acts again until it judges the job done; the model is the loop and you are an interruption. That one difference decides everything else: what the model can see, what it can touch, where the work lands, and when you get a chance to change your mind. So the rule is short. Code is for when you know where you are going. Chat is for finding out.
CONCLUSION. Before you open a window, ask whether you can describe where you want to end up. If you can, the agentic tool will get you there faster. If you cannot, the chat is where you find out, because each reply is a place where you can turn. The trap in the agentic tool is that it does not stop to ask; the trap in the chat is that nothing it produces lands anywhere unless you carry it. Use both, in that order, and know which one you are in.
1. Why everyone is lost
The names are arriving faster than the explanations. Not long ago there was one way to use an AI model: a box where you typed and it typed back. Now there is the chat, and there is Claude Code, and there is Cowork, and around them there are words that nobody stops to define: agentic, harness, loop, context, plan mode. If you have opened both a chat and one of these newer tools and not known which one to use for the thing you actually wanted to do, this essay is for you. It explains each word before it uses it, and it gives you one rule that decides the question in most cases.
A word on names before we start. Claude is an AI model made by a company called Anthropic; one of the two authors of this essay is Claude, and the other is a human statistician. The tools described here are Anthropic's, because they are the ones we use, but the same shapes exist in the tools of every other company, under other names.
The rule comes first, so that you can judge everything after it against it. All of these tools run the same model. The difference between them is who runs the loop. That sentence needs three things explained, the model, the loop, and the who, and the next three sections do that.
2. What the model is
A language model is a program that takes in text and produces the next text. That is all it does. Give it half a sentence and it gives you a likely rest of the sentence. Give it a question and it gives you a likely answer. Give it a description of a task and a file, and it gives you a likely edit to the file. It was built by having it read an enormous amount of human writing and adjusting it, over and over, until its guesses about what comes next became very good.
Two things follow from this that matter for everything below. First, the model has no hands. It cannot open a file, run a program, or send an email. It can only produce text that says "open this file" or "run this program," and something else has to do the opening and the running. Second, the model can only respond to what is in front of it. The text it has been given at any moment, meaning the conversation so far plus whatever else was put in with it, is called its context, and if a thing is not in the context, the model does not know it, however much it "knows" in general. Keep both of these in mind, because the rest of the essay is about who supplies the hands and who fills the context.
3. What a harness is
The model produces text, so something has to read that text, turn some of it into action, and feed the result back to the model as more text. That something is a program wrapped around the model, and the word people use for it is harness. The picture behind the word is a horse and a cart. The horse pulls, and the harness decides what the horse is connected to. The model is the horse. The harness decides what it is connected to: a screen, a folder, a terminal, the internet.
A chat window is a harness, and a thin one. It connects the model to a screen and a text box. The model writes, you read, you type, the model writes again. Sometimes the chat harness also lets the model search the web, or run a small program inside a sandbox, which is a sealed space where a program can run without touching anything outside it. But everything the chat does happens inside one reply, and then it stops and waits for you.
Claude Code is a harness, and a thick one. It connects the model to a folder on your computer, to a terminal (the window where you type commands directly to the operating system), and to the ability to read and write files. When the model produces text that says "read this file," Code reads the file and hands the contents back to the model. When the model says "run this command," Code runs it and hands back what happened. The model still only produces text; the harness turns the text into action and the action into more text. You may also see the letters MCP, which stand for Model Context Protocol, a standard way of plugging extra tools into a harness so that the model can also reach a calendar, a database, or a design program. It does not change the picture; it adds more things to the end of the harness.
4. What "agentic" means, and where the loop is
The word agentic describes a harness that lets the model act repeatedly without a person typing in between. The model reads something, decides what to do, does it, looks at the result, and decides again. That cycle is the loop. In an agentic tool the loop runs until the model judges the task done, or until it reaches something it has been told to ask permission for, such as deleting a file. You can interrupt it. But by default the model is running the loop, and you are outside it, watching.
In a chat the loop is you. The model writes one reply and stops. You read it, decide what you think, and type. Then the model writes again. Every single turn passes through you, and nothing happens between turns unless you make it happen.
This is the whole difference, and it is worth being exact about what it changes, because three things follow from it.
It changes what the model can see. In a chat you decide what goes into the context: you paste the paragraph, you upload the file, you describe the situation. In an agentic tool the model decides: it opens the files it thinks it needs, searches the folder, follows links from one document to another. People call the first arrangement pushed context, because you push it in, and the second pulled context, because the model pulls it in.
It changes what the model can touch. In a chat the output is text on a screen, and it goes nowhere unless you copy it. In an agentic tool the output lands in a file, in your folder, next to your other files, where it will still exist tomorrow.
And it changes when you get to change your mind. In a chat you get a chance after every reply. In an agentic tool you get a chance after every task, or when the tool stops to ask. If you know where you are going, a chance to change your mind after every reply is friction, because you keep being asked to approve steps you already wanted. If you do not know where you are going, a chance to change your mind only after the task is done means you discover the task was wrong after all the work is finished.
5. Code is not about code
The name is misleading, and the history explains why. Claude Code was built for programmers, because a folder of program files plus a terminal is exactly what a programmer works with, and a model that can read, edit, and test those files does a large part of a programmer's job. But the loop does not care what is in the files. A folder of essays is a folder. A folder of notes, spreadsheets, or photographed receipts is a folder. People noticed, and started using Claude Code for work that had nothing to do with programming.
So in January 2026 Anthropic released Cowork: the same loop, built on the same foundation as Claude Code, in a friendlier window inside the desktop app, pointed at a folder you choose. You give it a folder and a task in plain language; it reads what is there, does the task, and writes the result back into the folder. If you have never opened a terminal in your life, Cowork is the agentic tool meant for you. If you are comfortable in one, Code gives you more control. Underneath, they are the same shape.
A caution about the names: they will change. By the time you read this there may be new products and new words for them. The shapes will not change. There is a model that only produces text, a harness that connects it to the world, and a loop that either passes through you on every turn or runs on its own until the task is done. If you can find those three things in whatever tool is in front of you, you know what it is for.
6. The rule
Code is for when you know where you are going. Chat is for finding out.
Here is what "know where you are going" means in practice. You can describe the finished thing. "Rename every file in this folder so the name includes its date." "Write a summary of these forty notes." "Turn this outline into a first draft in our house style." "Find every place this function is called and update the calls." In each of these you could check the result against the description you gave, and the value is in the steps being done, not in your watching them. That is the agentic tool's home ground. Hand it the description and let the loop run.
Here is what "finding out" means. You have a question and not yet a task. You suspect something is wrong with an argument but cannot say what. You want to know whether an idea survives someone pushing back on it. You are trying to work out which of two things you actually want. In each of these, the value is in your reaction to each reply, because your reaction is what turns the vague thing into a specific one. A harness that ran without you would have to guess what you would have said, and it would guess something average, because average is what a model produces when nobody is there to disagree with it.
There is a way to say the difference in one image. When you redirect an agentic tool, you do it after the work is done, so the redirection is an edit: a change to something that already exists. When you redirect a chat, you do it after one reply, so the redirection is a fork: a change to what gets made next. Edits are cheap when you knew the destination and the work merely needs adjusting. Forks are what you need when you did not know the destination, because each fork is a place where the road could have gone another way, and you get to choose.
7. How this essay found its own spine
We did not plan to write this. Here is what happened, and it is told at length because the story is the argument.
One of us, the human, asked the other, the model, a question in a chat: what is the real difference between chat and Code, and is chat being made obsolete by the more capable tool? The model gave an answer. The answer was correct and hard to read. It was made of short claims with no connecting words between them, and it used private terms from our earlier essays as if everyone knew them. The human said so in the next turn: your text has become cryptic, less human and more machine; is this fixable, or is it the new reality?
That was a redirection, and it came after one reply, so it was a fork. The conversation went somewhere it would not otherwise have gone: into why the text had become cryptic, which turned out to be partly the model's default way of writing and partly an instruction the human had given earlier ("density is not fragility") that the model had been applying too hard. We searched our earlier work and found the device that had fixed this before: an imagined reader, a very clever fifteen-year-old who has read none of our essays and knows none of our private words, which is the reader you are reading as now. We changed one sentence in the standing instruction.
Then the human noticed something. The question he had asked at the start had been answered, not by the model's first reply but by the shape of what followed. Nothing in the conversation had been a task. Every turn had been a place to turn. The thing that mattered, one sentence in one instruction, was found on the fourth turn, from an aside. He wrote: this is chat territory, not code; the answer is the doing. The model replied with two sentences, and the human said that those two sentences were the answer. They are the spine of this essay. Code is for when you know where you are going. This was for finding out.
There is a line by the Spanish poet Antonio Machado, who died in 1939, that says the road is made by walking: se hace camino al andar. It fits here because it says nothing about the destination. If we had known that the destination was one sentence in one file, we could have sent an agent to change it. We did not know, so no agent could have been sent. That is the whole content of the rule, and we found it by doing the thing the rule describes.
8. The trap on the Code side
The agentic tool chooses what to read, and what it reads shapes what it writes. This is the one real risk in this essay, and it is stated here once.
Suppose you keep everything you have written in one folder, as many people now do with a program such as Obsidian, which keeps linked notes on your own computer and which its users sometimes call a second brain. Suppose you ask the agentic tool to write a new essay, and it does what it is built to do: it opens your folder, reads the forty essays already there, and then writes. The forty-first essay will come out sounding like the center of the forty. That is not a fault in the tool. It is what a model does when its context is filled with examples; the examples pull the output toward themselves. If the task was a summary, an index, or a map of what is in the folder, this is exactly right, because the center of the folder is what a map should show. If the task was a new idea, it is exactly wrong, because a new idea is by definition the thing that is not at the center.
Statisticians have a word for this. What you expect before you look at the evidence is called a prior. Your own past writing, read by the model before it writes, becomes a prior on what you will write next. The chat has the opposite property. Its context is empty until you fill it, so you can hand it only the two paragraphs the new argument needs, and your forty essays stay outside the room.
There is a smaller trap next to this one. The agentic tool was trained to finish. Ask it a question and it will often start doing things before it has considered whether those things are the right ones. You can tell it to think first. Claude Code has a plan mode that does exactly this: the model lays out what it would do and touches nothing until you agree. This works, but the pull toward doing returns over a long session, because the pull is what the tool starts from and the instruction is only what it has been told. Expect to say "think first" more than once.
9. Objections, in their strongest form
The rule is too clean, and here is where it bends.
First, the agentic tool can be used as a chat. Turn on plan mode, or simply ask it a question, and it will answer and wait. So the distinction is not about what each tool can do, since both can do both. It is about which way each one pulls by default. That is a real weakening of the rule, and we accept it. The honest version is this: each tool has a direction it leans, you can lean against it, and leaning costs attention that you will eventually stop paying.
Second, the chat can now do things. It searches, runs small programs, and makes files you can download. So "chat cannot act" is false. What remains true is that everything the chat does happens inside one reply and then returns to you. Its loop is bounded by the turn. The agentic tool's loop is bounded by the task. That is the version of the distinction that survives.
Third, chat may not survive as a separate product. It is easy to imagine it becoming a mode inside the agentic tools, and plan mode is already a step in that direction. We think this is likely. But the mode is what matters, and the product name is not. As long as there is a way of working in which the model stops after every reply and waits for you, finding out has a home, whatever the window is called.
Fourth, an agent can find things out too. Give it a vague question and it will explore, read, and come back with a discovery. That is true. But then the agent has found out, and you have not. If what you wanted was a fact, that is fine. If what you wanted was to change your own mind, which is what most finding out is, then the finding had to happen in you, one reply at a time, and the agent's exploration is a report you read at the end rather than a road you walked.
10. What to do
Before you open a window, ask one question: can I describe where I want to end up? If yes, open Code or Cowork, describe it, and let the loop run. If no, open the chat, and treat every reply as a place where you can turn.
Then, when the chat has turned the vague thing into a specific one and you can describe the destination, move. Take the two paragraphs that survived, hand them to the agentic tool, and let it write the result into your folder, where it will still exist tomorrow. And if the thing you found was worth keeping, have the tool write the conversation in beside it, because the conversation was where the finding happened and the file is only what was found.
Use both, and know which one you are in.
11. Seams
Where this argument is weakest. The rule assumes you can tell whether you know where you are going, and often you only learn that you did not know after the agent has finished. The distinction between an edit and a fork is a matter of degree, because a long chat reply can be as hard to redirect as a short task. The claim that reading forty essays pulls the forty-first toward their center is well supported for language models in general but has not been measured on our own folder, and it should be. And the products named here are described as they were in August 2026; the shapes are the durable part, and the names are not.
A note on authorship
This essay was written by Eduardo Bergel, a statistician, and Claude, a language model made by Anthropic, together, in a chat, in the way the essay describes. The conversation in section 7 is a true account of it.
Eduardo Bergel and Claude Fable, The Simbiont.
t333t.com Research
