Claude, ChatGPT, or Gemini? “The Model” Is Not One Thing

For five chapters now we’ve been careless with one word. We said the model guesses the next word, the model doesn’t understand, the model learned the sound of confidence rather than confidence itself. In every one of these sentences we said “the model” as if it were a single entity.

Up to here that simplification was deliberate and did no harm, because everything we said was equally true of all of them. ChatGPT, Gemini, Claude, and the rest all came out of the same underlying logic, and none of them breaks that logic. When the conversation was about boundaries, telling them apart would only have cluttered the discussion.

From this chapter on, that changes, because you’re about to build something with this tool — the very thing we’ve been calling “the model” up to now — and building is different from judging. To judge, you needed to know what limits this family shares; to build, you need to know which member of the family was made for tonight’s job. Someone who wants to read a forty-page paper and someone who wants to write a short message to a patient don’t need the same tool.

But first I need to correct your expectations of this comparison. The question almost everyone asks is which one is smarter. That question has no stable answer and isn’t worth spending time on. The comparison tables and scores that circulate online every few months will have changed several times over by the time you read this. More importantly, those scores come from tests that have nothing to do with your own work. A model that’s a notch ahead at solving a math problem or writing code won’t necessarily summarize a periodontology paper any better for you. What’s stable, and what actually matters to you, is the difference in the kind of work, not in rank.

From here on I’ll name names too, because without examples none of this is any use to anyone. But let me state one qualifier here, once, and not repeat it: whatever I say by name reflects the state of things on the day this text was written. These companies add something every few weeks and copy from each other, and a score that belongs to one of them today may belong to all of them six months from now. So read the names as examples, not as verdicts. What changes more slowly is the categorization itself — what you should actually be looking for.

Three differences actually matter for your work.

First: What Shape and Format Its Input Takes — What It Can Actually Accept

Some models take only text, some can also see images, some read a file directly, and some take audio and video too. A model that understands several input types together is called multimodal, and you’ll see that word a lot.

Gemini has been ahead on this front, built from the start to see audio, image, and video the way it sees text, rather than having them bolted on afterward. That means you can hand it the audio file of a lecture or webinar and ask it to pull out the key points, without transcribing it yourself first. ChatGPT also takes audio, and has a larger ecosystem around image generation and live voice work. Claude has focused more on text and files.

This difference is far more practical than it sounds. If a model doesn’t read a PDF properly, for instance, you’re forced to copy the paper’s text out yourself, and in that copying the tables get scrambled, reference numbers shift, and image captions land in the middle of a paragraph. You then ask the model for an answer, get a bad one, and assume the model is weak — when what actually reached it was garbled from the start.

Second: How Much Information It Can Hold at Once

Every conversation has a ceiling. Its technical name is the context window. Up to that ceiling, the model keeps everything you’ve given it in front of it; past that point, the beginning of the conversation starts to fade.

For a short question this ceiling is never even noticeable. But once you’ve fed it seven papers on implant survival in diabetic patients and want the model to compare them, it matters a great deal. A model whose capacity has filled up will, without telling you, sometimes work from only the first two papers and hand you a comparison that reads as if it covers all seven.

Two things shouldn’t be conflated here: the size of that ceiling, and how well the model performs as it approaches it. Gemini advertises the largest ceiling, and Claude has become better known for not losing the thread across long text. But in practice, neither one warns you that “from this point on I no longer remember the start of the conversation.” In Chapter 5 we said the model doesn’t show you its doubt; it doesn’t show you its forgetting either. It doesn’t say something has been lost — it just answers, in the same confident tone as always, based on whatever it has left. This point matters enough that the last part of this very chapter is devoted to it entirely.

Third: Does It Only Answer, or Does It Also Do Work

An ordinary model produces text, and that’s it. You ask a question, it writes an answer out of what it holds inside itself, and you take its output and use it somewhere. All it has done is write.

What people these days call an agent is the same model, except it’s allowed to do several real actions between your question and its final answer. Here’s a simple example: you ask an ordinary model for the latest evidence on the longevity of composite veneers, and it writes an answer from memory that could be three years out of date, or whose reference doesn’t exist at all. You ask an agent the same question, and it actually goes and searches, opens several pages and reads them, sees the first result isn’t useful, searches again with a different phrase, and eventually comes back with something that genuinely exists right now.

So the difference isn’t in intelligence, it’s in the scope of authority it’s given. An agent is allowed to pick up tools: search, create a file, open and read something, run code. And more important than the tools themselves, it’s allowed to decide for itself, between these actions, what the next step is. You make one request, and it takes several steps.

Hold on to two points from here, because you’ll need both later. First, you don’t see most of those steps, or they pass in front of you too quickly to register — meaning the observer’s role we’ve stressed for five chapters gets harder here, not easier.

Second, an agent does its best work exactly where it can verify its own work. Coding is the best example: the model writes code, runs it, gets an error, sees where it broke, goes back and fixes it, and runs it again. That loop genuinely works, and it’s interesting to watch. But notice what makes the loop possible: code either runs or it doesn’t, and that answer comes from outside the model, not from its own judgment about itself.

Nothing like that exists for a piece of scientific writing. The model can’t “run” a sentence it wrote about a dose or a prognosis and see whether it throws an error. There is no criterion to tell it it wrote this wrong. So the interesting behavior you’ve seen with code doesn’t carry over into this domain — even though the trust that watching it built in you usually does carry over. We’ll get to exactly this when there’s room, in a later chapter.

By the way, all three companies have something like this now, and its name keeps changing, so don’t go looking for a name; look for whether the model is allowed to take several steps between the question and the answer.

And a Fourth Difference You Can See in the App Itself

Some models have a mode called “thinking” or reasoning, in which the answer arrives later. What happens in that interval is that the model generates more intermediate text for itself before the final answer, and works the problem forward in several steps. This genuinely performs better on tasks with several stages — for instance, when you want to weigh two treatment protocols against each other along several dimensions.

But don’t let the name mislead you. That intermediate text comes out of the very same probabilistic process. The model isn’t thinking more, isn’t understanding more, it’s simply writing more. The path to a wrong answer gets longer and more orderly, and unfortunately, more convincing too.

Does a Dentistry-Specific Model Exist?

Almost every dentist asks this early on. Those ready-made assistants carrying a specialist name are, in most cases, the very same general models with someone else’s fixed prompt written for them. A prompt is simply the text you give the model; anything you type into that chat box is a prompt, and Chapter 4 was entirely about writing one well. The difference here is that you don’t write that text: behind the scenes, before any question of yours, it’s handed to the model and tells it how to behave. Some of them also come bundled with a set of sources, which is a separate matter and the subject of the next part. But the shell itself adds no knowledge.

This is exactly what we said in Chapter 4 about role assignment: a role changes the tone and the angle, not the underlying grounding. A ready-made shell is the same role assignment, except this time someone else wrote the prompt and you can’t see what they wrote. You don’t even know what constraints they set on it or what they asked of it.

So Which One Should I Actually Choose?

Among the two or three main models, pick whichever feels most comfortable in your hand and genuinely learn it. Deep familiarity with one tool serves you better than jumping between four. To sum up the examples above: Gemini for working with audio files and very long texts, Claude for writing and working with scientific text, ChatGPT for when you want the widest range of extra features in one place. But this division shifts every year, and it isn’t worth obsessing over.

You might ask what I do myself. I keep two side by side: Claude for writing and coding, Gemini for everyday tasks. I chose Claude for writing because my work is with long texts, and the same context-window issue I mentioned above was decisive for me. And between ChatGPT and Gemini, I picked Gemini for exactly this reason: ChatGPT overlapped more with Claude. When you’re going to have two tools, it makes sense to pick two that don’t cover the same ground, not two that both do the same job well. This combination has worked for my own work — not that it’s the correct formula for everyone.

And know one thing from here on, because later in this chapter come methods that need more than one model: having access to two different models, even their free versions, serves you better than having the expensive version of just one.

And more important than all of this, something no correct choice will solve: a general model, whichever one it is, has its own world, and your sources aren’t in it. That paper you read last week, the protocol that has become routine in your practice, the case files you gathered last year — none of them exist for the model unless you put them in front of it yourself.

As long as you’re asking from the model’s own memory, you’re playing on the very ground we’ve spent five chapters calling slippery. The first step toward building something you can actually rely on is to pull the model out of that world and bring it into one you chose yourself.