The AI alphabet: from ANI to RAG, explained without the jargon

I've been using computers since the 80s

It's a common objection whenever the word "digitalization" comes up in a meeting: I've been using computers since the 80s, are you saying we're not already working digitally?

It's actually a fair question, and it exposes a mix-up worth clearing up before we even get to AI.

Digitization is the simple step: going from analog to digital, from unstructured to structured. Scanning a paper document. Buying a piece of software instead of keeping records in a binder.

Digitalization is something else entirely: how you actually use the digital tools in your work. Moving to a shared file space isn't digitalization by itself, it only becomes that once it actually changes how people work together, who sees what, and how fast things move.

In other words, you can have used computers since the 80s and still have digitalized almost nothing. That distinction is exactly what makes AI conversations confusing, because AI is digitalization taken to its most extreme form, so it's worth untangling what's actually hiding behind all the acronyms.

A tree, not a list

Most people try to learn AI terms as a list of acronyms. That's the wrong model. Think of them instead as a tree, where every branch is a subset of the branch above it.

• AI (Artificial Intelligence) is the whole tree, any system that mimics some form of human ability.
  • ANI (Artificial Narrow Intelligence) is all the AI that actually exists today: good at one thing. A chess engine, a spam filter, a voice assistant.
  • AGI (Artificial General Intelligence) is the hypothetical AI that can do most of what a human can. It doesn't exist yet, regardless of what the headlines say.
• Under ANI sits ML (Machine Learning), systems that learn patterns from data instead of being programmed rule by rule.
  • DL (Deep Learning) is a branch of ML using neural networks with many layers, which makes it good at complex patterns like images and speech.
  • NLP (Natural Language Processing) is another branch, everything to do with handling human language. It splits further into NLU (Natural Language Understanding, understanding text) and NLG (Natural Language Generation, producing text).
  • RPA (Robotic Process Automation) is yet another branch, though it's not about understanding or learning patterns, it's about automating rule-based, repetitive workflows.

ChatGPT and similar tools (LLMs, Large Language Models) sit in the NLP branch, as a result of deep learning applied to enormous amounts of text. But since LLMs are where most of the development is happening right now, and where work is actually changing, they deserve their own stop.

So what actually is an LLM?

The simplest way in is something most people already carry in their pocket: the predictive-text feature that suggests the next word while texting. It's learned, from what you and others typically write, which word is likely to come next.

An LLM does exactly the same thing, just at a completely different scale. It's been trained on an enormous amount of text (books, articles, web pages) by repeatedly guessing the next word in a sentence and being adjusted every time it guesses wrong. Repeat that billions of times, and what builds up isn't a memory of facts in the ordinary sense, but an extremely fine-grained sense of how language (and by extension reasoning, argument, and structure) tends to fit together.

It's worth being honest about what that means in practice:

• It doesn't "know" things, it predicts them. A correct answer and a convincing wrong answer can come from exactly the same mechanism, which is why models sometimes "make things up" with total confidence (so-called hallucinations).
• It has no memory between conversations, unless that's built in separately. Every new conversation starts from zero.
• It doesn't look up facts live, unless it's connected to a tool for that (which is exactly what RAG, covered next, solves).

What makes LLMs so disruptive isn't that they're smarter than earlier AI, it's that they're a general-purpose interface to language. You no longer need to program a specific system for every text-related task; you describe what you want, in the same language you already use to talk to colleagues. That's the only reason a single technology suddenly shows up in customer service, coding, legal work, and report writing all at once. The interface is the same, only the task changes.

What an ML problem actually looks like

Formal definitions of machine learning tend to sound more complicated than they need to: a program that learns from experience and improves at a task without anyone rewriting the code by hand. In practice, it's easier to show than to explain.

Say you want to build something that guesses whether you'll like a movie. You put together a list of movies you've already seen and rated:

• Forrest Gump → +1 (liked it)
• The Matrix → +1 (liked it)
• A certain Christmas movie → -1 (didn't like it)
• Scenes from a Marriage → -1 (didn't like it)

What you've done is give examples of correct behavior. You haven't written a rule saying "like action movies, dislike dramas". That would be extremely hard to program by hand, since taste rarely follows simple rules. Instead, you let the model look for the patterns itself: maybe it's the pacing, maybe it's the cast, maybe it's something you hadn't even considered.

That's the whole idea of ML in one sentence: it's hard to write the instructions, but easy to give examples, so let the machine find the rules for you.

What you created in the movie example is called labeled data: every movie got a tag, +1 or -1. Classic ML depends on exactly that kind of labeled example. Deep Learning often doesn't need that step, but why that is, and what's actually happening inside all those layers, is a chapter of its own.

Fine-tuning or RAG: what's the difference?

When people talk about "connecting AI to our own data," they usually mean one of two very different things.

Fine-tuning means taking a finished model and retraining it on your own material. It's powerful, but it requires a lot of data and a fair amount of money. You're effectively building a new, specialized version of the model.

RAG (Retrieval Augmented Generation) is the far more common path in practice: the model itself stays unchanged, but gets access to an external database it can look things up in before answering. Picture an inspection technician asking an assistant about a previous inspection report for a specific facility. The assistant doesn't "remember" the report because it was trained on it, but because it retrieves it from the database the moment the question is asked.

The difference matters in practice: RAG is cheaper, faster to set up, and easier to keep current. Fine-tuning is the right call when you need the model to actually behave differently, not just know more.

What can you actually do with this?

In practice, the same handful of use cases keep showing up, regardless of industry:

• Customer support, first-line answers, around the clock
• Reports and documentation, summarizing what already exists, faster
• Environmental scanning, monitoring and summarizing large information flows
• Translation, not just language-to-language, but "legal" to "understandable"
• Code, writing, explaining, and debugging
• Checklists and structured material, turning loose notes into something usable

What all of these have in common: they're about moving text from one format to another, faster than a person would have done it alone. It's not magic. It's NLP, applied to a concrete problem.

Something to try tomorrow

If you take away just one thing: stop asking "can we use AI for X?" and start asking "do we already handle a lot of text or data around X manually?" If the answer is yes, there's a good chance one of the six use cases above already fits, and you won't need to build a model, or even fine-tune anything, to get started. Most of the time, RAG against what you already have is enough.

But this is the easy surface. Under the hood, ML and DL make their decisions in completely different ways, and right now, development is moving fast enough to feel almost explosive. The next article heads into the engine room: how models that "ask several experts" (bagging and boosting) differ from each other, what attention actually does when an LLM reads a sentence, and why 2022–2026 became the years everything happened at once.