Explain Like I'm a Specific Expert

1. For the Experienced Software Engineer (Skeptical, Systems-Minded, Non-ML Background)

You’re right to be skeptical—"predicting the next word" sounds trivial, like autocomplete on steroids. But the magic isn’t in the prediction itself; it’s in the scale and architecture of how that prediction is trained. Think of it like a distributed system where the "nodes" aren’t servers but attention mechanisms—a way for the model to dynamically route information based on context, much like how a load balancer routes requests based on latency or capacity. The model isn’t just memorizing patterns; it’s learning a compressed representation of language, where every word or token is embedded in a high-dimensional space (like a vector in a 12,288-dimensional array for some models). When it generates text, it’s performing a kind of probabilistic search over this space, conditioned on the input prompt. The "intelligence" emerges from the sheer scale of the training data (terabytes of text) and the model’s ability to generalize from it—akin to how a well-designed API can handle edge cases it’s never seen before by relying on robust abstractions.

The training process itself is a massive distributed computation problem. Imagine a system where you’re trying to minimize a loss function (cross-entropy, in this case) across trillions of parameters, using stochastic gradient descent (SGD) with optimizations like Adam or AdaFactor. The model is trained on TPU/GPU clusters with data parallelism, where each worker processes a shard of the dataset, computes gradients, and synchronizes them via all-reduce operations (like in MPI or Horovod). The key insight is that transformers—the architecture behind models like GPT—are permutation-equivariant, meaning they can process tokens in parallel (unlike RNNs, which are sequential). This parallelism is what makes training at scale feasible. The "next-word prediction" objective is just a proxy task; the real value is that it forces the model to learn latent structure in language—syntax, semantics, even some reasoning—without explicit supervision. It’s not "intelligent" in the human sense, but it’s a remarkably effective way to approximate it.

---

2. For the PhD Physicist (Mathematically Rigorous, Skeptical of Hype, Wants First Principles)

Let’s start with what’s not novel: the core mathematical machinery—linear algebra, probability, and optimization—has been around for decades. What’s interesting is how these tools are composed at scale to create emergent behavior. At its heart, a large language model (LLM) is a conditional probability distribution over sequences of tokens, parameterized by a transformer neural network. The transformer is a function ( f_\theta: \mathbb{R}^{n \times d} \rightarrow \mathbb{R}^{n \times |V|} ), where ( n ) is the sequence length, ( d ) is the embedding dimension, and ( |V| ) is the vocabulary size. The model is trained to minimize the negative log-likelihood of the next token given the previous ones: [ \mathcal{L}(\theta) = -\sum_{i=1}^N \log p_\theta(x_i | x_{<i}), ] where ( x_i ) is the ( i )-th token in the sequence. This is just maximum likelihood estimation (MLE) with a high-capacity model.

The novelty lies in three areas:

1. Scaling laws: Empirical work (e.g., Kaplan et al., 2020) shows that model performance improves predictably with model size, dataset size, and compute budget, following power laws. This isn’t just "bigger is better"—it’s a quantitative relationship that lets you trade off resources for capability. The emergent abilities (e.g., in-context learning, chain-of-thought reasoning) appear only above certain thresholds, suggesting a phase transition in the model’s representational capacity.
2. Self-attention as a dynamic computation graph: Unlike CNNs (which have fixed receptive fields) or RNNs (which are sequential), self-attention allows the model to adaptively weigh the importance of each token in the input. Mathematically, the attention mechanism computes a weighted sum of value vectors, where the weights are derived from a softmax over dot products of query and key vectors. This is equivalent to a kernel method with a learned kernel, enabling the model to approximate arbitrary functions over sequences.
3. Implicit Bayesian inference: The model isn’t just memorizing data; it’s performing a form of amortized inference. When you prompt it with a question, it’s effectively sampling from a posterior distribution over possible completions, conditioned on the prompt and its training data. This is why it can generate coherent (if not always correct) answers to novel queries—it’s leveraging the statistical structure of language to generalize.

The hype around "AI" often obscures that this is still just function approximation, but the scale and flexibility of the approximation are unprecedented. The real open questions are whether these models can achieve systematic generalization (like humans) or if they’re fundamentally limited by their training objective.

---

3. For the Venture Capitalist (Defensibility, Moats, Credibility of Claims)

When evaluating an AI startup, the key questions are: What’s the defensibility? Where’s the moat? And are the founders’ claims credible, or is this just repackaged open-source tech? Here’s how to think about it:

Defensibility comes from three layers:

1. Data moats: The most durable advantage isn’t the model architecture (which is often open-source, e.g., Llama, Mistral) but the data used to train it. High-quality, proprietary datasets—especially those with human feedback (e.g., RLHF data, domain-specific annotations)—are hard to replicate. For example, Scale AI’s data engine or companies with exclusive partnerships (e.g., legal, medical, or financial data) can create a flywheel: better data → better models → more customers → more data.
2. Infrastructure and tooling: Training and serving LLMs at scale requires specialized infrastructure (e.g., TPU/GPU clusters, distributed training frameworks like Megatron or DeepSpeed). Startups that build proprietary optimizations (e.g., quantization, speculative decoding, or custom serving stacks) can achieve 2-5x cost or latency improvements, which are hard for competitors to match. This is why companies like Together AI or Anyscale are raising at high valuations—they’re selling picks and shovels in a gold rush.
3. Product and UX moats: The "wrapper" around the model matters more than the model itself. For example, Notion’s AI features aren’t just a fine-tuned LLM—they’re integrated into a workflow that users already rely on. Similarly, companies that build compound AI systems (e.g., agents that can take actions, not just generate text) or vertical-specific applications (e.g., legal, healthcare) can create stickiness. The defensibility here comes from network effects, switching costs, or regulatory barriers (e.g., HIPAA compliance in healthcare).

Red flags in founder claims:

• "We have a proprietary algorithm that’s 10x better." → Probably not. Most "secret sauce" is either open-source or incremental (e.g., a new attention variant). The real differentiator is data or product integration.
• "We’re training a model from scratch." → Unless they’re Google or Meta, this is usually a bad idea. Fine-tuning or distillation (e.g., taking a 70B model and making it 7B) is more capital-efficient.
• "Our model is AGI." → No. These models are stochastic parrots—they’re good at pattern matching but lack true understanding or reasoning. The real value is in applied use cases where their limitations are manageable.

Where to look for upside:

• Vertical AI: Startups applying LLMs to specific industries (e.g., Harvey for legal, Hippocratic for healthcare) can build defensibility through domain expertise and data moats.
• Infrastructure plays: Companies that reduce the cost of training or serving models (e.g., Lamini, Modal) or enable new modalities (e.g., video, robotics) have long-term value.
• Agentic workflows: The next wave isn’t just chatbots but agents that can take actions (e.g., booking flights, debugging code). Startups like Adept or Imbue are betting on this.

The key is to separate commoditized components (e.g., base models) from differentiated ones (data, product, infrastructure). The best AI startups aren’t selling models—they’re selling outcomes.