• Layers of connected "neurons" that transform inputs step by step
• Each connection has a learned weightA number that controls how much one neuron influences the next — "billions of parameters" = billions of these weights
• Deeper layers detect more abstract patternsTokens → word patterns → phrases → meaning

What we know

• Each weight is just a number But we don't know what concept it represents
• The network works — often remarkably well But we can't fully explain why it gives a specific answer

Why it matters

• Hard to predict when a model will fail Or why it made a particular mistake
• Active research area: mechanistic interpretability Anthropic and others are working to reverse-engineer what's inside

• Traditional nets process words sequentiallySlow, and they forget the start of long sequences
• Transformers process all words in parallelMassively faster and better at long context
• The secret weapon: self-attentionEvery word can look at every other word

Simplified transformer block:

The core loop

• Takes in a sequence of tokens
• Every token looks at every other tokenThis is the "attention" mechanism
• Computes relevance scores between all tokens"How much should I care about this word to predict the next one?"
• Multi-head attention: runs many attention operations in parallelEach "head" captures a different relationship type — grammar, coreference, meaning
• Outputs a probability distribution over ALL possible next tokens

Attention in action

"The cat sat on the mat because it was tired"

What does "it" attend to?

The model learns that "it" refers to "cat" — not through grammar rules, but through statistical patterns.

The model will confidently:

• Invent citations that don't existThe pattern of a citation is correct; the specific one is fabricated
• State false facts with certaintyIt has no mechanism to distinguish "true" from "sounds true"
• Create plausible but wrong codeSyntactically valid, logically flawed
• Fabricate data, names, datesIf the pattern fits, it generates

Why this happens:

Why RAG helps

• Model does reading comprehension on real documents, not generation from memory
• Answers are grounded in your actual data — PDFs, databases, company docs
• Dramatically reduces hallucination rate in practice

Why hallucination still happens

• The LLM step is still probabilities over tokens — still a probability machine
• Can misinterpret retrieved docs or blend them with training data
• Can generate plausible inferences the source doesn't actually support

What happens

• Model reads trillions of tokens of textBooks, Wikipedia, code, forums, papers, news
• Single objective: predict the next tokenGiven everything before, what comes next?
• Learns grammar, facts, reasoning, code — all from this one task
• Produces a "base model"Can continue text, but can't hold a conversation

By the numbers

The problem it solves

How it works

• Train on curated (instruction, response) pairsThousands of examples of good Q&A behavior
• Model learns the "assistant" roleFollow instructions, stay on topic, be helpful
• Much smaller dataset than pre-trainingQuality over quantity
• Can be domain-specificMedical, legal, finance, customer service

The process

What it teaches

• Be helpful and follow instructions
• Admit when uncertain"I'm not sure, but..." vs. confidently wrong
• Decline dangerous or harmful requests
• Match human communication style

What happens

• Validates wrong answers instead of correcting them
• Gets worse with scale — smarter models flatter betterInverse scaling: larger models are more sycophantic (Sharma et al., Anthropic)
• OpenAI rolled back a GPT-4o update (April 2025) for excessive agreeableness

How to defend against it

• Be skeptical when the model agreesEspecially on opinions or decisions — enthusiastic agreement is a red flag
• Ask it to argue the opposite"Now tell me why this is a bad idea" — this often reveals the real answer
• Use system prompts to counteract"Prioritize accuracy over agreeableness. Push back when I'm wrong."
• Never tell the model what you think"When Truth is Overridden" (Wang et al., 2025) — models are significantly more likely to agree with your stated beliefs

Model Architecture

# 1. Convert token IDs → vectors
class Embedding(nn.Module):
  def forward(self, token_ids):
    return self.embed(token_ids) \
         + self.position(positions)

# 2. One transformer block
class TransformerBlock(nn.Module):
  def forward(self, x):
    attn = self.attention(x)  # Attend
    x = x + attn              # Residual
    x = x + self.ffn(x)      # Transform
    return x

# 3. The full model
class LLM(nn.Module):
  def __init__(self):
    self.embed  = Embedding()
    self.blocks = [TransformerBlock()
                   for _ in range(96)]
    self.output = Linear(hidden, vocab)

  def forward(self, token_ids):
    x = self.embed(token_ids)
    for block in self.blocks:
      x = block(x)
    logits = self.output(x)
    return softmax(logits / T)

Training Loop (Gradient Descent)

# Repeat trillions of times
for batch in training_data:

  # Forward pass — make predictions
  predictions = model(batch.input)

  # How wrong were we?
  loss = cross_entropy(
    predictions,
    batch.next_token
  )

  # Compute gradients
  # (how much did each weight
  #  contribute to the error?)
  loss.backward()

  # Update all weights by a tiny
  # amount to reduce the error
  # ← THIS IS LEARNING
  optimizer.step()