We’ve reached the end of the series. We started with the simple idea of a machine learning from examples, and step by step we built our way up to large language models: how they’re constructed, trained, aligned, how they generate text, and where they go wrong. For this final article, I want to zoom out and give you a practical picture of what these systems actually are: what they’re good at, where they stumble, and, lightly, because nobody truly knows, where things might be heading.
If you’ve read the whole series, you now have a working understanding of these tools. This is where we put that understanding to work as judgement.
What LLMs are good at
Let me start with the good news. These models are useful, and there’s a clear shape to what they do well. Figure 1 lays out the balance.
Figure 1: A balanced view. On one side, the things language models excel at; on the other, the areas where they remain unreliable and need a human’s judgement.
Their strengths cluster around language and text:
- Writing and rephrasing: drafting, editing, changing tone, summarising long text into short. This is their home turf; it’s what they were trained on.
- Working with text you give them: pulling structured information out of a messy document, answering questions about a passage you provide, translating between languages. When the material is right in front of them, they shine.
- Explaining and teaching: turning something complex into something simpler, offering analogies, walking through an idea patiently.
- Coding help: drafting code, explaining what code does, spotting bugs.
- Brainstorming and getting unstuck: generating options, first drafts, and starting points when a blank page is the enemy.
Notice a pattern: they’re at their best when the task is about language and, especially, when they’re working from material you’ve provided. That’s the sweet spot.
Where they still fall short
Now the other half: the limits, most of which follow directly from things we’ve covered in this series:
- Facts and truth. As we saw last article, they can hallucinate, confidently stating things that are false. They optimise for plausible, not true. Anything factual needs verifying.
- They have a knowledge cutoff. A model’s training happened at some point in time, so it doesn’t inherently know about events after that, or anything private, unless you give it that information or connect it to a live source. Out of the box, it isn’t a real-time news feed.
- Careful reasoning and exact maths. They can follow sophisticated chains of thought, but they also stumble on complex logic and precise multi-step calculation. They’re pattern-completers, not calculators. Don’t trust arithmetic you didn’t check.
- Anything to do with counting letters or characters. Remember they see tokens, not individual letters (Article 5)? That’s why they can fumble tasks like “how many times does the letter r appear in this word.” The letters are, in a sense, invisible to them.
- Consistency. Ask the same thing twice and you may get two different answers (that’s sampling, Article 16). They can also contradict themselves within a long response.
- No true understanding. However fluent they sound, underneath it’s pattern completion, not comprehension or awareness. It’s easy to over-attribute understanding to something that writes so well, a trap worth staying alert to.
The thread running through these limits is worth naming: they’re weakest where the task requires guaranteed truth, precision, or genuine understanding, and strongest where it requires fluent handling of language.
The mindset that gets the most out of them
So how should you actually hold all this? The most useful framing I know is simple: treat a language model as a fast, occasionally unreliable assistant, not an oracle.
That one reframe resolves most confusion. You’d never blindly publish a talented intern’s first draft without a glance, but you’d absolutely value the time they save you. Same here. Lean on these tools for what they’re good at: drafting, explaining, transforming, brainstorming, working through text you provide. Bring your own judgement for what they’re weak at: verifying facts, checking figures, making final decisions. Keep a human in the loop wherever it matters. Do that, and you get much of the upside with less risk.
Where this might be heading
I’ll tread carefully here, because this field moves fast and anyone claiming certainty about the future is guessing. But a few directions are clearly underway and worth being aware of:
- From answering to doing. Perhaps the biggest shift: models are being connected to tools and given the ability to take actions, such as searching, running code, and using software on your behalf, rather than only producing text. This is the world of “AI agents,” and it’s a large enough topic to have its own track in this library.
- Grounding by default. Because of hallucination, connecting models to real, current information (like the retrieval we keep mentioning) is becoming standard rather than optional, making answers more trustworthy and up to date.
- More than text. Models increasingly handle images, audio, and more alongside words, so the “language” model becomes something broader.
- Steadily better reasoning. A lot of effort is going into making models more reliable at careful, multi-step thinking, chipping away at one of today’s real weaknesses.
Where exactly all this lands, I won’t pretend to know. The foundations you’ve learned in this series, learning from data, tokens, embeddings, attention, transformers, prediction, alignment, hallucination, will keep helping you make sense of whatever comes next, because the new things are built on these same ideas.
The end of the beginning
That’s the series. Look back at how far you’ve come: you started, perhaps, thinking of AI as a mysterious black box, and you can now explain how a machine learns from examples, how words become numbers, how attention lets a model connect ideas across a sentence, how a transformer is assembled, how it’s trained into a knowledgeable predictor and aligned into a helpful assistant, how it writes one token at a time, and why it sometimes confidently makes things up. That’s a working understanding you can build on.
This “AI Primer” was the foundation. From here, the other tracks build on it: how to talk to these models effectively (Prompt Engineering), how to ground them in your own data (RAG), how to adapt them (Fine-Tuning), and how to give them the ability to act (Agentic AI). You’ve got the foundation now; everything else builds on it.
Thank you for reading the whole way through. Go and use these tools well: with curiosity, with judgement, and with understanding.
This completes the AI Primer series. Ready to go further? Continue with the Prompt Engineering track to learn how to get the best out of these models.