I'm learning a bit of computer science, and I want to understand the difference between an electromechanical switch, a vacuum tube, which was used to make the logic gates AND, OR and NOT, and a transistor. Am I confusing terms, or what?
You're not confusing terms. They are three real, distinct technologies, each a generation of computing, and they share one idea: each is a switch controlled by electricity. Logic gates don't need any particular technology, only something that can be on or off depending on a signal.
- The relay (1930s to 1940s) is a switch pulled by a magnet. A current in a coil pulls a metal arm across to close a circuit, and you can hear it click. The Harvard Mark I used thousands.
- The vacuum tube (1940s to 1950s) has no moving parts. In a sealed glass tube with the air taken out, a heated cathode sends electrons to a plate, and a small voltage on a grid between them throttles the stream from fully on to fully off. Faster, but big, hot and fragile: ENIAC had 18,000, and a team replacing the ones that burned out.
- The transistor (1950s to now) does the tube's job in solid silicon: a small signal controls a larger current. shrank from fingertip size to nanometres, which is why a phone chip holds billions.
- 1Controlled byA current in a coil makes a magnet
- 2What switchesThe magnet pulls a metal arm down onto a contact, and it clicks shut
- Years
- 1930s to 1940s
- One flip
- About a thousandth of a second
- About the size of
- A matchbox
All three can be wired into AND, OR and NOT gates.
Relays, tubes or transistors: the table is the same. In a chip, NOT takes two transistors, NAND or NOR four, and AND or OR six.
Explain the electromechanical relay in more detail. How does it make AND, OR and NOT gates?
I'm trying to understand the physical form of a transistor before the integrated circuit. This is my realisation: I thought the relay and the vacuum tube were early versions of the transistor. But they are different things. Then I heard the IBM 7090 replaced its vacuum tubes with transistors. You see what I mean?
Yes, and the realisation is right. They are three separate inventions that happen to solve the same problem, being a switch controlled by electricity: competitors for one job, not versions of each other. A candle, a gas lamp and an LED all make light, and nobody calls a candle a primitive LED.
Before integrated circuits, a transistor was a part you could hold: a small metal or plastic capsule with three wire legs, soldered onto a board beside resistors and capacitors. That is the 7090 story. IBM's 704 (1954) ran on vacuum tubes; the 7090 (1959) put one of those little transistors where each tube had been. The same logical design, different physics underneath, and faster, cooler, smaller and far more reliable.
- Relay: a switch made of metal and magnets.
- Vacuum tube: a switch made of glass, vacuum and electrons.
- Discrete transistor: a switch made of solid semiconductor, germanium and then silicon, in a capsule.
- Integrated circuit: the same transistors, made together on one piece of silicon instead of soldered one by one. An is a chip.
The logic stays the same throughout. Only what does the switching changes.
It's said that the Intel 4004 was an entire CPU in one chip? Chip and CPU, what's the difference?
A chip is a physical thing; a CPU is a job. A chip, or integrated circuit, is a slice of silicon with transistors made on it, in a package with metal legs. It doesn't care what it does. A CPU, the central processing unit, is the part of a computer that fetches instructions, decodes them and carries them out.
CPUs existed before the 4004, built from many chips and boards of transistors working together. Chips had existed since the early 1960s. What was new in 1971 was everything a CPU needs, the arithmetic, the control and the registers, on one chip: 2,300 transistors. The word for it was . Before it, a computer's CPU was a room or a cabinet of boards. After it, you could hold one between two fingers.
- Year
- 1945
- Switches
- Vacuum tubes
- How many
- 17,468
- The CPU is
- The whole room
Each is drawn to fit, not to one scale.
[Two photos: the Intel 4004, and a modern CPU going into a socket.] So I know silicon allowed ICs, which is how a chip looks today. Is the 4004 the same thing, just improved over time, or what?
The first photo is the 4004: a white ceramic package with gold legs, the silicon die a small square under its lid. The second is a modern CPU going into its socket, with hundreds of contacts underneath. The same idea in both: a die of silicon in a protective package, with connections to the board.
So yes, the same thing, improved beyond recognition. The 4004 had 2,300 transistors, about 10,000 nanometres across, at 740 kHz, handling 4 bits at a time. Apple's M4 (2024) has about 28 billion, on what is called a 3 nm process, at about 4 GHz, 64 bits at a time. Transistors kept shrinking, so more fit on the same silicon, roughly doubling every couple of years; that is what Moore's law describes. The packages changed because a chip doing more needs more connections: the 4004's two rows of legs became a grid of contacts.
Ahh, okay. Now I see it. So the computers I hear calculated artillery trajectories in the world war, is it one or two, were what exactly? I know they weren't ICs, because they were huge "chips" you could walk into.
The Second World War, and they couldn't have been ICs: the transistor came in 1947 and the integrated circuit in 1958. The rooms were two different things.
- Human computers. The first firing tables were worked out by people, mostly women, at desks with mechanical calculators, in shifts. "Computer" was a job title: a person who computes.
- ENIAC (1945), built to calculate those firing tables for the US Army: walls of panels holding about 18,000 vacuum tubes, each doing the switching one transistor does in your phone.
The room was the computer, because every switch was the size of a light bulb and the maths needed that many of them.
Can you list some big, popular computers I should know? I love that I can tell the difference more easily now that I understand what's behind the scenes.
- ENIAC (1945): electronics replaced mechanical calculation.
- IBM 7090 (1959): transistors replaced vacuum tubes.
- IBM System/360 (1964): one family of machines, large and small, that ran the same software. It changed how the industry worked.
- Intel 4004 (1971), then the Altair 8800 (1975): the microprocessor, and the kit computer that set off personal computing.
- Apple II (1977) and IBM PC (1981): computers for everyone, not only scientists and governments.
Knowing what's inside each, relays, tubes, discrete transistors or chips, tells you why each was the size it was and why the next was better.
Ahh, so "used early ICs, fridge-sized": you mean there were bigger ICs before the Intel 4004? Was it because of another material being used by some guy whose name I don't remember, unlike the one in California experimenting with silicon? Help me out here.
Two people invented the integrated circuit at almost the same time. Jack Kilby, at Texas Instruments in 1958, used germanium; he won the Nobel Prize for it in 2000. Robert Noyce, at Fairchild Semiconductor in California, used silicon and a better way of making it, the planar process, which is essentially what the industry runs on today. Silicon won because it copes with heat better and is far more plentiful. Noyce later co-founded Intel, the company that made the 4004.
But the size of the early machines wasn't about the material. It was about how many transistors fit on one chip. Early chips held a handful, so a CPU still needed many of them, and a cabinet to hold them. The 4004 had enough on one chip for one chip to be enough.
Switching gears for a bit. I'd like to understand how a model actually works behind the scenes when we're using a chat, or something like Claude Code. When it says it's thinking, I know that's been abstracted for us, but what is it actually doing? What's happening when it makes a tool call? I want to understand the different states an LLM or an agent goes through, from the time we ask it to do something to the point where it gives us something: what's technically behind "thinking" or "tools", explained simply.
- Tokenising. Your words become numbers: "Hello" might become two. The model never sees letters, which is why spelling can trip it up.
- The context. Everything in the conversation, your messages, its replies and the system's instructions, is packed into one list of and handed to the model every time. It has no memory between turns.
- The forward pass. The computation itself: the tokens go through layer after layer of the network, and at each layer, attention decides which tokens matter to which. This is the expensive part, and it is what the GPU does.
- The pick. The pass ends in a probability for every possible next token, and one is chosen from them.
- Tool calls. The model doesn't search or run code. It writes a , structured text naming a function and its inputs. The program round it runs the tool, adds the result to the context, and the model runs again with it.
- Streaming. Tokens are made one at a time and sent as they are made, which is why words appear one by one.
1 / 7You type a request.
Say hello instead of hi
So "thinking" is forward passes, and "running tool" is the model stopped while the server does something real, before the cycle starts again with the result added.
And then what is reasoning? Sometimes in an app using AI, the user types something in and the AI goes "reasoning", and under it the AI writes a bit of text, as if it's trying to work out what the user is asking for. What is that, exactly? How does the AI reason, if the only thing it does is predict text?
Reasoning is prediction, used as a scratchpad. The model still only predicts the next token, but every token it predicts goes back into the context. So when it writes "the user seems to be asking about X, but Y is ambiguous", that text is now part of what it reads to predict the next token.
Your question is in the context. Nothing has been written yet.
This is , and it genuinely improves accuracy, the way working on paper beats working in your head: each written step gives the next prediction more to go on. The "reasoning" block is that scratchpad made visible. Whether it is reasoning, or a learned pattern in which text that looks like reasoning comes before text that is right, is an open question. It behaves like reasoning: it catches errors, changes its mind, and gets to better answers.
Okay, now that I have a technical understanding of how reasoning works behind the scenes, I'd like to understand what makes Opus or Sonnet different. What's the difference between Opus 4.5 and 4.8? We're always told they're better at reasoning, or more intelligent, but it always sounds so abstract. Technically, give it to me.
Anthropic doesn't publish the architectural differences, but research says what the levers are:
- Size: how many the model has.
- Data: what it was trained on, and how good that is.
- Training: how much computing went into it.
- Fine-tuning: shaping it after training, with human feedback among other things.
- Thinking time: how many tokens it may spend before answering.
Opus and Sonnet differ mostly in size, training and thinking time. Opus is larger, trained longer, allowed to think longer; Sonnet is smaller and faster, made for the many tasks that don't need all that. 4.5 and 4.8 are the same tier, iterated. The difference there is mostly data and fine-tuning: more experiments, what worked kept. A later version isn't necessarily bigger, more likely better shaped.
"More intelligent" comes down to scores on thousands of standard tasks, and even that can be gamed. What you can trust as signal: long contexts handled accurately, fewer made-up facts, instructions followed, and hard chains of reasoning staying coherent.
More reasoning tokens = more chain-of-thought steps = better answers on hard problems = this is why they say it uses more tokens. It's spending more tokens when it reasons, iterating the predictions, as you said earlier.
Exactly. And that's why cost and intelligence are linked in a way that makes physical sense. Every reasoning token is a forward pass through billions of parameters, on a GPU of billions of transistors, each switching billions of times a second, which costs real electricity and real hardware time.
- Low
- 1,500 tokens billed
- Medium
- 4,500 tokens billed
- High
- 16,500 tokens billed
- Max
- 32,500 tokens billed
A printed line is 500 tokens. The answer is the same 500 at every effort; the thinking above it is billed as output too, at $20 a million.
- Parameters
- 4.0 × 10¹¹
- Operations, one token
- 8.0 × 10¹¹
- Operations, 4,500-token reply
- 3.6 × 10¹⁵
- One token on one H100, flat out
- 0.81 ms
Every token pays the whole model again. Ten times the parameters is ten times the work, for every token, thinking included.
So a price gap between Opus and Haiku isn't arbitrary: a bigger model doing more work for every token. You're buying computation. And that is the whole stack, from a switch on silicon to why Opus costs more and thinks harder than Haiku.
In the context of npx… elaborate this for me again.
Normally you download a program, it installs, and it runs. Installing means copying files onto your disk for good, and often onto your . npx skips the middle: you type a command, npx fetches the package, runs it, and it's gone. npm install is buying a book for your shelf; npx is borrowing it from a library for one chapter.
And the JavaScript npx fetches goes the same way down as everything else: Node runs it, compiles the busy parts to machine code, and that machine code is transistors switching on your processor.
[A chart: Terminal-Bench Science, cost per run against how often each model solved the task.] Shifting gears here. I'm trying to understand what makes some models better than others in a less magical way, because I still don't understand what it means for one model to be better than another. How are these challenges broken down? When a new model is released, what should I look out for? I don't want the big marketing terms.
The chart is a benchmark: across the bottom, what a run costs; up the side, how often the model solved the task. Each model was run at several reasoning efforts, so each is a curve, not a point: let it think more and it does better, and costs more.
- Which benchmarks. Trust new, unseen tests, agentic tasks, real coding and maths; be wary of tests a model may have trained on, a company's own benchmark, and vague claims.
- The cost curve. The same score for less money is a real improvement; so is a higher score for the same money. A slightly higher score for much more money is worth questioning.
- Effort scaling. Does more thinking budget actually help, or does it flatten out?
- Context, in practice. A million tokens of context is only worth it if the model uses the middle. Models are known to remember the start and end of a long context better than the middle.
- Made-up facts. A model can be capable and confidently wrong; benchmarks such as SimpleQA measure it.
- Instructions followed. Exactly, not roughly.
A better model moves the curve up and to the left: higher scores, for less.
I didn't mean how to read the graph. Give me the philosophy of what Terminal-Bench is in the first place. How did it become a measure of intelligence? What other kinds of exams are there, and how did they come up with them? Educate me in a very simple way.
Nobody can measure intelligence directly, in people or machines, so researchers did what schools do and wrote exams. A is a fixed set of questions, a fixed way of scoring them, and the same paper for every model. No one exam captures intelligence; the value is that everyone sits the same one.
Each has the same life: it's written, models get good at it, it stops telling anyone anything, and someone writes a harder one. Recognising digits and pictures (MNIST, ImageNet) was solved and retired. Understanding a sentence (GLUE, then SuperGLUE, 2018 and 2019) went within a year or two. MMLU (2020), multiple choice across 57 subjects, sits around 90%. Writing a function and school maths (HumanEval and GSM8K, 2021) saturated. Then GPQA, science questions a clever person with a search engine still fails, and SWE-bench, real bugs from real GitHub projects to fix. In 2025, Terminal-Bench, ARC-AGI-2's puzzles that children solve and models don't, and Humanity's Last Exam. The direction is from answering a question to doing a job.
Terminal-Bench hands the model a computer and a task, as an employer would. A sandboxed Linux machine starts up; the task is in plain English ("the data pipeline is broken, fix it"); the model gets a terminal and nothing else, runs commands, reads what comes back, tries again. When it says it's done, hidden tests run, and the score is how many tasks passed. It measures planning, using tools and recovering from mistakes, which a quiz can't.
- The families: knowledge (MMLU, GPQA), maths and step-by-step reasoning (AIME, FrontierMath), code (HumanEval, SWE-bench), agentic jobs (Terminal-Bench, OSWorld), honesty (SimpleQA), new kinds of puzzle (ARC-AGI), and taste, by blind votes between answers (LMArena).
- Four ways to make one: borrow human exams; pay experts to write questions they'd fail without their PhD; mine the real world for real bugs; or build an environment with a task and a test.
A good benchmark can be marked without a person: an answer key, or a test that passes or fails. They die two ways, saturated, when everyone scores 95%, or contaminated, when the questions leak into training data and get memorised. And once a number is the target, labs tune for it, and it slowly stops meaning what it did: Goodhart's law.
"Better at reasoning" means more questions right, on exams everyone agreed to sit, and more and more those exams are jobs.