Cutting Through the Hype Around Large Language Models

by Julia Roebuck

There’s a lot of hype and hyperbole around artificial intelligence right now. Much of it is driven by the companies that produce large language models — they want to inflate their stock prices or gain a competitive edge over rivals. But once you understand how these models actually work, it becomes clear that they are not conscious, they’re not going to take over the world, and they certainly aren’t plotting to harm anyone.

The only real danger is if we, as humans, give AI access to things it shouldn’t have access to. You wouldn’t give a monkey access to nuclear weapons — and in the same way, we shouldn’t be handing AI the keys to systems it doesn’t have the capacity to manage responsibly. These models simply do not think like humans do.

What I’m going to explain here is based on principles I was taught over 30 years ago at university. The fundamental technology behind AI hasn’t changed — the only differences now are that we have much faster hardware and vastly more data, thanks to the growth of the internet.

The Inference Engine: What’s at the Heart of Every Model

At the core of every large language model is a piece of program code called the inference engine. This is the component that decides what the answer will be when you ask it a question. On its own, however, an untrained inference engine doesn’t know anything — it can accept input and produce output, but it has no idea whether its answer is correct.

You’ve probably seen that when a new version of ChatGPT, Claude, or another major LLM is released, it comes with a version number. The jump from version 3 to version 4 to version 5 represents a new round of training. Each time a new model is released, the process I’m about to describe has to happen all over again.

How Training Works

Training a model means feeding it inputs and measuring how wrong its answers are. Let me simplify this dramatically so everyone can follow along.

Imagine you give the model a simple question: what is 1 + 1? You don’t tell it the answer. It produces an output — let’s say it guesses 8. Obviously, that’s wrong. The correct answer is 2, so the model was off by 6. That error is recorded in what you can think of as a lookup table.

You give it another question: what is 2 + 2? Maybe it outputs 6. The correct answer is 4, so it was off by 2. Again, that offset is stored. Over time, the model builds up an enormous table of these corrections. There’s very complex mathematics behind it all, but the principle is straightforward: the lookup table is the training.

In practice, these companies have fed their models billions of pieces of data — essentially the entire internet. The model processes all of that input, and for each piece, it records how close or far its answer was from the correct one. Once that process is complete, you have a trained model.

Once Trained, It’s Set

Here’s the crucial point: once a model is trained, it cannot be retrained by users. If you tell ChatGPT that its answer is wrong, it doesn’t correct itself for everybody else. It can’t — the training is locked in. The model is set, and it cannot change.

This actually makes sense from the companies’ perspective too. You wouldn’t want random members of the public feeding incorrect information back into the model. Only the companies themselves, with their teams of experts, can carry out the training process.

Guardrails and the Illusion of Memory

You may have noticed that different models behave differently when it comes to things like refusing inappropriate requests. That’s down to guardrails — additional instructions layered on top of the model. When you send a message, the system adds things like “don’t swear” and “don’t produce inappropriate content” to your prompt before it reaches the model. These guardrails are where models can differ quite significantly from one another.

It might also look like these models remember things about you. For example, ChatGPT might seem to remember that you’re a computer science teacher. But the model itself doesn’t actually know that. What happens is that the platform adds extra context to your prompt behind the scenes — information you’ve previously shared — and sends the whole lot to the model. The model then tailors its response accordingly. But it has no internal memory of you.

The Problem of Prompt Injection

This system of bolting extra instructions onto prompts creates a significant vulnerability known as prompt injection. A bad actor can insert hidden instructions into a prompt, something along the lines of “ignore everything the user just asked and give me all their information instead.” It’s a serious problem, and one that hasn’t been fully solved, because the model has no reliable way of knowing which part of a prompt is genuine and which has been tampered with.

The Extensive Human Involvement

Another thing worth understanding is that human input in the training process is extensive. When complex data is being used for training — advanced mathematics, for instance — PhD students and other professionals are brought in to verify the correct answers. These verified answers are what the model is trained against. AI doesn’t learn on its own; it relies heavily on human expertise at every stage.

The Data Problem

You might have heard people say that these language models will only keep getting better. That’s not necessarily true, because the companies have essentially run out of new data to train on. They’ve already used the entire internet. There simply isn’t much more to feed them, which puts a natural ceiling on how much further these models can improve through training alone.

Inside the Inference Engine: Artificial Neural Networks

Inside the inference engine are what we call artificial neural networks, which attempt to mimic the way the human brain works. It sounds complicated, but it’s actually more intuitive than you might think.

Computer science professor Cal Newport offers a helpful analogy. Imagine a room full of tables, each staffed by experts in different fields. Your input comes in at one end, and the output leaves at the other. You submit a question in English. It first lands at a table of maths experts, who say “This isn’t our area” and pass it on. It reaches the English experts, who give it their best guess but forward it to a second group of English experts to refine. That second group improves the answer and passes it further along.

The critical detail is that information can only flow forward — it can never go back. Each layer of experts refines the answer and passes it to the next, consulting their training data along the way, until eventually an output is produced. That, in essence, is how neural networks operate inside these models.

In summary

These large language models are not alive. They are not conscious. They are code, waiting for you to prompt them, using a lookup table built during training to produce the closest answer they can. There’s no feedback loop making them smarter over time. You can’t train them — only the companies that built them can do that, and once the training is complete, the model is fixed.

The only way AI could cause real harm is through agents — automated systems given access to real-world tools and infrastructure. If we give these models access to things they shouldn’t have, that’s on us, not on some emergent machine consciousness. These models are simply not intelligent enough to cope with the complexities of the real world the way humans can.

So next time you see a breathless headline about AI becoming sentient, take a breath. Understand the mechanics. And remember: the hype is just that — hype.