What Are LLMs? Explained for Developers

Part 4 covered how generative text models predict the next token. This part covers what a Large Language Model actually is, in real, practical terms a developer needs — not the full mathematical detail, but enough to build correct mental models for every part that follows.

A real, practical definition

A Large Language Model (LLM) is a neural network (part 6 covers what
  that actually means), trained on a real, massive amount of text,
  that predicts the next token given the text so far (part 4) — and
  is "large" specifically because it has a genuinely huge number of
  real, adjustable internal parameters, often in the billions

The "large" in the name refers to real scale — both the size of the model itself (its parameter count) and the real size of the training data it learned from. This scale is directly what separates a modern LLM from earlier, smaller language models — the same fundamental prediction task from part 4, but at a scale that produces genuinely different, more capable real behavior.

Training vs. inference: two real, separate phases

Training: a real, one-time (or periodic) process where the model
  learns from a massive real text dataset — genuinely expensive,
  taking real weeks and enormous real compute
Inference: the real, everyday process of actually USING a trained
  model to generate a response to a real prompt — comparatively
  cheap, fast, and what every API call this series makes actually is

This distinction matters directly for a developer: nothing covered in this series' later, real coding parts (16 through 18) involves training a model — a real application calls an already-trained model's inference API, sending real input and receiving real generated output, the same distinction as calling a pre-trained image classifier versus training one from scratch.

The transformer architecture, at the real, practical level a developer needs

Real, core mechanism: "attention" — for each token being generated,
  the model weighs how relevant every other token in the real input
  is to predicting what comes next, rather than processing text
  strictly left-to-right with no real memory of earlier context

This is the real, 2017 breakthrough referenced in part 3 — attention lets a model directly weigh the relevance of any part of the real input to any other part, in parallel, rather than processing tokens strictly sequentially the way older architectures did. The full mathematical detail is genuinely beyond what a developer building applications needs — what matters practically is the real behavior this enables: a model that can track real, long-range relationships in text, like connecting a pronoun late in a paragraph back to the specific real noun it refers to several sentences earlier.

What a model actually "knows" — and the real, practical limit

A model's real knowledge comes entirely from its training data,
  frozen at a specific real point in time (its "training cutoff")
It does NOT have real, live access to the internet, a real database,
  or anything happening after that cutoff — UNLESS the application
  explicitly provides that information in the prompt (covered
  directly in part 19's RAG coverage)

This is one of the single most practically important things for a developer to internalize early: a raw LLM call has no real, inherent access to your product's actual data, today's real date, or anything outside its frozen training data — every real fact an application needs the model to reason about has to be explicitly included in the prompt sent to it, a design constraint that shapes essentially every real application built in this series from part 16 onward.

The real, practical distinction from part 2, restated concretely

An LLM is a real, specific instance of: Deep Learning → Machine
  Learning → AI (part 2's hierarchy), applied specifically to
  next-token prediction over text (part 4), using the transformer
  architecture (this part)

Every remaining part of this series builds directly on this specific, real foundation — how the underlying model actually generates a response (part 7), the real units it operates on (part 8), and eventually, how to actually call one from real, working Python code (parts 16 through 18).

Next: how ChatGPT specifically generates answers — taking the general LLM mechanism from this part and tracing it through one real, specific, well-known product.