System One and System Two

The name comes from Daniel Kahneman: fast, automatic judgment versus slow, effortful reasoning. Here is what the metaphor gets right about decision models, where it breaks, and the rule of thumb it gives you: if an expert could answer in a few seconds, it is a System One question.

Key takeaways

Kahneman's System 1 is fast, automatic and effortless; System 2 is slow, serial and effortful. Decision models aim at the first kind of judgment.
Rule of thumb: if a knowledgeable person could answer in a few seconds with the right context, it is a System One question.
Tasks that need several steps of reasoning, new text or planning are System Two work: send them to a reasoning model, a person, or decompose them.
The useful architecture is a layer cake: code is exact, the decision model judges, the language model thinks.
The two systems are a metaphor, and fast does not have to mean sloppy: what makes fast judgments usable is honest uncertainty.

Try it with your agent

Paste this into your coding agent, with last lesson's list:

For each LLM decision we found in this codebase, classify it:
- System One: an expert could answer it in a few seconds from the given data
- System Two: it needs multi-step reasoning, new text, or planning
- Code: it is exact (math, dates, counting, lookups)
For every System Two item, propose how to split it into narrow questions plus code, or say why it should stay with an LLM.

Transcript

Intro

Why call a model System One? The name comes from psychology, and it hands you the most useful rule in this course: which questions belong to a fast model, and which don't.

Two ways to think

Try this. What's two plus two? The answer just appears. Now, what's seventeen times twenty four? You can feel yourself start to work. Daniel Kahneman, who won a Nobel prize for his work on judgment and decision making, called these System 1 and System 2.

In his Nobel lecture he described them like this. System 1 is fast, automatic, effortless and associative. System 2 is slower, serial, effortful and deliberately controlled.

Fast is not dumb

And System 1 isn't the dumb one. Kahneman's point is that this is where skill lives. A chess master's strong moves come to mind instantly. System 2 just checks them.

Models on the spectrum

Models sit on the same spectrum. A decision model reads the state once and answers in a single pass, in a fraction of a second. Reasoning models do the opposite: they spend tokens thinking, step by step, and trade time for accuracy.

The rule of thumb

So here's the rule of thumb, straight from the TypeSafe docs. Make each question a gut check: the kind of judgment a knowledgeable person could make in a few seconds, given the right context.

Is this customer asking for a refund? Which team should handle it? How severe is this bug? An expert answers those at a glance. But should we make an exception for this customer, given three years of history? Write the apology? Plan the rollout? Those need System Two.

The layer cake

Developer Daniel Sam summed up the architecture in one line: put a decision layer between your rules and your reasoner. Let code be exact, let the model judge, let the LLM think.

Where the metaphor breaks

One caution. Kahneman himself called the two systems fictitious characters, a way to talk, not two boxes in the brain. And System 1 thinking is famous for its biases. A fast model can be confidently wrong too. What makes fast judgments usable in software is honest uncertainty, which is module three of this course.

Quick check

Quick check. Which of these is a System One question?

Try it

Try it. Take the list of hidden decisions from the last lesson and have your agent sort them into System One questions and System Two work.

Recap

So: System One is fast, automatic judgment, and that's what decision models aim for. If an expert could answer in seconds, it's a System One question. Code stays exact, and System Two takes the hard cases. Next: what's actually inside a decision model.