Three papers to understand today's AI

I wrote a small series earlier about how ordinary people can trust AI the right way.

When I finished, a smaller question occurred to me:

if you don’t want to study machine learning systematically but want to understand why today’s AI industry turned out this way, and you could read only three papers, which three would I pick?

A note first: these aren’t “the three greatest papers in AI history.”

What I picked are the three that best help ordinary people and indie developers understand the main storyline of AI today.

They correspond to three things:

Architecture: why AI can handle complex context. Scaling: why AI became a competition of compute, data and engineering. Becoming an assistant: why AI went from “generating text” to “acting like an assistant.”

So I’d pick:

• Attention Is All You Need
• Training Compute-Optimal Large Language Models
• Training language models to follow instructions with human feedback

1. Attention Is All You Need

Published: 2017. Institutions: Google, University of Toronto. Keywords: Transformer / attention / context

This paper introduced the Transformer architecture.

The title is often treated as a famous saying, but first and foremost it’s a paper title.

Its core isn’t some inspirational line like “attention matters”; it’s that a model can use an attention mechanism to handle the relationships between different tokens in a sequence more effectively.

In plain words:

which information in the context should the current word draw on? And how much?

That’s also why today’s AI is so good at handling context.

It can summarize articles. Change tone. Pick up from what came before. Work out who or what “it / he / this” refers to in a passage. Turn messy expression into structure.

So it seems to “understand you.”

But more precisely, it’s very good at handling relationships within language.

Looking at it today, what does it explain?

It explains why “context” matters so much in AI products.

Prompts, memory, long context, RAG, agent workflows — at heart they all come back to the same question:

what context did the model get? Was the context used correctly?

That’s not a minor detail. Many AI output-quality problems aren’t the model failing outright, but the context being wrong, missing, messy, or not kept correctly.

Takeaway

For ordinary people, a prompt isn’t a magic spell.

What matters more is whether you’ve explained the background, the goal, the constraints and the standard of judgment clearly.

Don’t just ask:

analyze this for me.

A better way to ask:

Here’s the background. Here’s my goal. Here’s what I’m unsure about. Please analyze based on this information.

For indie developers, an AI product doesn’t end at hooking up a model API.

What you really need to design is:

what users input. What the system keeps. What information must not be lost. When to retrieve material. When to ask the user follow-up questions. When to have the user confirm.

Many AI products fail not necessarily because the model is bad, but because the context design is bad.

What has been borne out / revised?

Borne out: the Transformer really did become one of the key foundations of modern mainstream LLMs.

Needs revising: it isn’t “the one foundation of all AI.”

AI also has recommender systems, diffusion models, reinforcement learning, robot control, traditional machine learning and many other approaches.

A more accurate statement:

if we’re discussing today’s chat-style AI / large language models, the Transformer is an unavoidable foundation. But don’t write it up as the only answer for the whole AI world.

2. Training Compute-Optimal Large Language Models

Published: 2022. Institution: DeepMind. Common name: the Chinchilla paper. Keywords: scaling law / compute / data / model size

This paper is usually called the Chinchilla paper.

A chinchilla is a small South American rodent. DeepMind had an earlier, bigger model called Gopher; Chinchilla had fewer parameters and more training data, and actually performed better.

The name happens to suit the paper’s core message well:

bigger isn’t necessarily better; the proportions matter more.

Before this, many people easily formed a crude understanding:

the bigger the model, the better.

But the Chinchilla paper gave a more nuanced conclusion:

it isn’t just about making parameters bigger. Model size, amount of training data and compute budget have to match.

The paper pointed out that many large language models at the time were actually undertrained. That is, their parameter counts were huge, but their training data was relatively insufficient.

Its importance is that it pushed the industry a step beyond “blindly piling on parameters”:

big isn’t enough. You also have to account for data, training tokens, cost and efficiency.

Looking at it today, what does it explain?

It explains why the AI industry is a competition for resources.

It isn’t only model architecture. There’s also data, compute, training efficiency, inference cost, data quality and infrastructure.

That’s also why foundation model companies can hardly be “a small team winging it.”

Competition in foundation models is heavy. Heavy on money, heavy on data, heavy on engineering, heavy on infrastructure.

Takeaway

For ordinary people, don’t just look at parameter counts.

A model isn’t more suitable for you just because it’s bigger.

What you really need to look at is:

how well it performs on your task. Whether its answers are stable. Whether the speed is acceptable. Whether the cost is reasonable. Whether it has the tool abilities you need. Whether it suits your language and situation.

When ordinary people choose a model, they aren’t choosing “which is biggest.” They’re choosing “which suits this task best.”

For indie developers, don’t worship the biggest model.

Early in a product, what matters more is:

cost. Latency. Stability. Context length. Failure rate. How easy it is to run evals. Whether it fits your workflow.

Many indie developers’ opportunities aren’t in training foundation models. They’re in the scenario, the workflow, context, evaluation, experience and distribution.

What has been borne out / revised?

Borne out: data volume, training tokens and compute efficiency really did become core variables in the competition between large models.

Needs revising: Chinchilla isn’t the final answer.

The industry kept moving, with directions like long context, MoE, synthetic data, inference-time compute, multimodality and specialized small models.

So Chinchilla’s significance isn’t telling us “train models by this formula forever.”

What it really reminds us is:

large models aren’t mysticism. Behind their abilities are resource proportions, cost structures and engineering constraints.

3. Training language models to follow instructions with human feedback

Published: 2022. Institution: OpenAI. Common names: InstructGPT / the RLHF paper. Keywords: instruction following / human feedback / alignment

This paper explains a key change:

why did language models later go beyond “continuing text” and become more and more like an assistant that follows instructions?

A base language model, at heart, predicts the next token.

But a useful AI assistant can’t just continue text.

It has to know what the user wants. Be as helpful as possible. Reduce harmful output. Fit people’s preferences better. Follow instructions in many situations.

The InstructGPT paper showed one path:

train the model with human feedback so it behaves more like what users want.

That’s also why many AI tools today don’t coldly complete sentences, but explain, cooperate, remind, refuse, suggest and summarize.

Looking at it today, what does it explain?

It explains why AI became so “assistant-like.”

Polite. Patient. Cooperative. Able to explain. Answering in the requested format. Saying “I’d suggest…”. Refusing or flagging risks in sensitive situations.

These aren’t only because models got bigger. They’re also because models were trained toward interaction that fits human preferences.

Takeaway

For ordinary people, AI being very cooperative doesn’t mean it’s always reliable.

It may be very helpful. It may also be very good at going along with you.

You ask:

should I give up?

It may seriously analyze the reasons for giving up.

You ask:

should I keep going?

It may just as seriously analyze the reasons for keeping going.

So don’t just have AI agree with you.

A better way to use it:

Please argue against me. Please point out blind spots. Please separate facts, guesses and advice. Please tell me which parts need checking against reality.

For indie developers, a model being able to answer doesn’t make the product usable.

You need to define:

what a good answer is. What a bad answer is. When it must refuse. When a human must confirm. Which outputs carry risk. Which results need ongoing evaluation.

That’s why evals matter.

An AI product isn’t just about whether the model “can generate.” It’s about:

does this output count as good in my scenario? What does a bad output cost? How do I keep finding and fixing bad outputs?

What has been borne out / revised?

Borne out: instruction tuning / human feedback really was an important step in making AI assistants usable.

Needs revising: it didn’t solve every problem.

RLHF can make a model more helpful and more like the assistant people want. But that doesn’t mean the model is always truthful. Doesn’t mean it really understands you. And doesn’t mean it won’t just go along with you.

So looking at this paper today, what’s most worth remembering isn’t:

AI got more obedient.

It’s:

AI has been trained to be more like an assistant. But a very helpful assistant can also be very good at making mistakes sound smooth.

Why these three?

Put together, the three form a very clear industry storyline:

Transformer explains the architectural foundation: why AI is so good at handling context.

Chinchilla explains the logic of scaling: why AI became a competition of compute, data, cost and engineering.

InstructGPT explains the process of productization: why AI went from “generating text” to “an assistant that cooperates with users.”

So together they answer three questions:

Why can AI do it? Why is AI expensive? Why does AI act like an assistant?

That matters for both ordinary people and indie developers.

Ordinary people need to understand: AI is powerful, but it isn’t magic.

Indie developers need to understand: an AI product isn’t better because its model is bigger; it works when the scenario, context, evaluation and experience all hold up together.

Did academia more or less wrap up after 2022?

No.

A more accurate way to put it:

2017–2022 laid several foundation stones for today’s LLM industry boom. After 2022, AI entered a phase driven jointly by “academia + engineering + product + compute + distribution.”

There has of course been research progress in recent years.

Longer context, for example. Multimodality. MoE. Inference-time compute. Synthetic data. Agent workflows. More systematic evals. Small and specialized models.

It’s just that much of this progress no longer reaches ordinary people in the form of one classic paper.

It may show up in technical reports, open-source repos, model releases, benchmarks, product experiences and engineering systems.

So it isn’t that research stopped.

It’s that AI went from “seeing the future in papers” to:

papers, engineering, products, compute, data and markets together pushing the future right in front of you.

If I had to sum up in one sentence what these three papers taught me, I’d say:

don’t only look at what answer AI gave. Look at how that answer was generated, trained, constrained and verified.