Explain Like I'm a Specific Expert

For the Software Engineer

Think of an LLM as a massive distributed system where instead of routing requests or managing state, you're computing probability distributions over a vocabulary of ~50,000 tokens. During training, you're essentially building an enormous lookup table—but instead of exact key-value pairs, you're learning compressed representations of patterns across terabytes of text. The model architecture (transformers) uses attention mechanisms that work like dynamic routing tables: for each token, the model computes which other tokens in the context window (typically 4K-128K tokens) are most relevant, then aggregates their representations weighted by relevance scores. This happens across multiple layers (often 20-100+), with each layer learning increasingly abstract patterns.

The "just predicting the next word" skepticism is understandable, but consider this: predicting the next token correctly across diverse contexts requires implicitly modeling the processes that generated that text. To predict the next line in a Python function, the model must understand syntax, semantics, and even algorithmic intent. To continue a mathematical proof, it needs to model logical reasoning. The scale is crucial here—at 100B+ parameters, these models can simultaneously encode patterns from code reviews, API documentation, Stack Overflow discussions, and academic papers. What emerges isn't unlike how your distributed systems exhibit complex behaviors from simple rules: local token prediction, when scaled massively and trained on diverse data, produces emergent capabilities like reasoning, translation, and even creative problem-solving. The model learns a lossy compression of the internet's text, and decompressing it through autoregressive generation produces surprisingly coherent and useful outputs.

For the PhD Physicist

At its core, an LLM is performing gradient descent on a high-dimensional non-convex loss landscape to minimize cross-entropy between predicted and actual token distributions. The transformer architecture's key innovation is the self-attention mechanism: computing QK^T/√d for query-key dot products, applying softmax for normalization, then multiplying by value vectors. This creates a differentiable routing mechanism where information flow is determined by learned linear projections. The model learns hierarchical representations through residual connections and layer normalization, with each transformer block computing: LayerNorm(x + MultiHeadAttention(x)) followed by LayerNorm(x + FFN(x)). The feed-forward networks are typically overparameterized (4x hidden dimension) ReLU/GELU activated MLPs that act as pattern memories.

What's genuinely novel isn't the mathematics—it's mostly matrix multiplications and nonlinearities—but rather three discoveries about scale and emergence. First, the scaling laws: model performance follows power laws (L ∝ N^-α where α ≈ 0.076) with respect to parameters N, remaining predictable across 7+ orders of magnitude. Second, in-context learning emerges without explicit training: models develop the ability to adapt to new tasks from examples in the prompt, suggesting they're learning mesa-optimization algorithms during training. Third, the "grokking" phenomenon where models suddenly transition from memorization to generalization suggests phase transitions in the loss landscape. The bitter lesson here is that simple algorithms (autoregressive likelihood maximization) plus scale outperform clever inductive biases. The models are learning approximate Bayesian inference over an implicit prior determined by the training distribution—not "intelligence" in any fundamental sense, but a surprisingly effective approximation given enough parameters and data.

For the Venture Capitalist

LLMs represent a fundamental platform shift similar to cloud computing's emergence. The core technology involves training massive neural networks on internet-scale text data, requiring $2-100M+ in compute costs and specialized expertise in distributed training. Once trained, these models can be fine-tuned for specific verticals at marginal cost, creating a powerful economic moat. The key insight: these models are general-purpose reasoning engines that can be specialized through prompting or fine-tuning, eliminating the need to build ML capabilities from scratch. Think of them as AWS for intelligence—companies will build on top of them rather than competing with them directly.

The defensibility question is nuanced. Raw model performance is increasingly commoditized—open-source models lag closed ones by only 6-12 months. The real moats are: (1) proprietary data for fine-tuning in regulated/specialized domains, (2) inference optimization and serving infrastructure that reduces costs by 10-100x, and (3) workflow integration and compound AI systems that combine models with traditional software. When evaluating founders, test their understanding of these economics: Do they know that inference costs scale linearly with usage while training is a one-time cost? Can they articulate why their domain-specific fine-tuning or RAG implementation isn't easily replicable? The winners won't be building new foundation models (except at massive scale); they'll be building the application layer that makes these models useful for specific workflows, with network effects and switching costs. Look for teams that understand the technology deeply enough to know what not to build—those riding the wave rather than trying to create a new ocean.