Jeff Dean’s 1% Rule: How to Choose What to Build in the Age of Frontier AI

In mid-2026, standing in front of roughly 6,000 founders at Y Combinator’s Startup School in San Francisco, Google’s Chief Scientist Jeff Dean distilled the hardest question in AI — what should I build? — into a single number.

Zero.

“Look for something where the model succeeds 0% or 1% of the time, not 20%.”

Eleven days later, Dean announced he was leaving Google after 27 years to co-found Discovery Loop. The talk reads, in hindsight, like a mission statement for the company he hadn’t yet announced.

Here’s the full breakdown of the 1% Rule and the theory of AI underneath it.

The 1% Rule, explained

The rule is a heuristic for picking problems:

“If they’re kind of able to do some of it, but not very well, that’s maybe not a great sign — because that’s probably a sign that the capability is starting to be present in those models. And with more training data or larger scale models, it’s likely to get better.” — Jeff Dean

A 20% success rate is worse than 0%. It means the frontier has already planted the seed of your product inside its weights — and every subsequent training run waters it.

The two durable moats (where 2–3 people can beat Google)

Tech giants optimize for general models. That leaves two structurally protected paths for small teams:

Path 1 — Personal or protected data moats. Build products that rely on private data frontier models are legally, ethically, or technically barred from accessing. Dean’s example: a tool that helps users organize their own personal information. The data is the moat — and it compounds with use.

Path 2 — Specialized niche models (the AlphaFold shape). Train a small, highly accurate model on curated proprietary data in a hard domain. AlphaFold is the canonical example: a model specialized for protein folding, not a generalist — and it achieved world-class accuracy. The same shape exists in materials science, quantum chemistry, and chip design.

Context engineering > model scale

Dean’s sharpest technical point: the model is only one piece of the system.

Training data gets “stirred together into a soup of hundreds of billions or trillions of parameters” — knowledge exists, but it’s unclear. Information placed directly into the current context is precise and immediately usable.

The concrete evidence, from inside Google:

• The 30-page Performance Hints document. Dean and Sanjay Ghemawat published it with low-level optimization tricks. Developers who fed even a summarized version into a model measurably improved its ability to reason about code performance — without changing a single weight.
• The benchmark-optimization skill. They wrote a structured “skill” teaching a model to run microbenchmarks, modify code, re-run benchmarks, observe cache changes, and iterate — turning a standard model into an autonomous systems-optimizing engineer.
• The 300,000x learned simulator. In quantum chemistry, evaluating one molecule with density functional theory takes a night of compute. Dean’s colleagues trained a neural approximation of the simulator — 300,000x faster, nearly as accurate. Screening 10 million molecular configurations now happens “while you go to lunch” instead of over six months.

The model didn’t get smarter. The context did.

Agents run for weeks — not hours

Dean’s May 2025 prediction (AI approaching junior-engineer capability) has been validated — and he admits he underestimated how fast models would progress on complex tasks.

The industry’s biggest blind spot: people assume agents are 1–2 hour tasks. In reality, with capable models in suitable domains, agents run continuously for days or even weeks. His example: a long-running agent that reliably rewrites an entire codebase into a different language with better security or performance properties.

The step-30 wall and multi-agent search

Every team that’s built agents has seen the same failure: first 10 steps smooth, by step 30–50 the agent forgets its goal, repeats actions, and drifts off course.

“As soon as you get a little bit off the distribution of things it knows how to do, its performance will suddenly start to degrade.” — Jeff Dean

The fix is not a better prompt. It’s search:

1. Parallel exploration — multiple agents try different approaches simultaneously
2. Active evaluation — a separate evaluator agent scores each path
3. Branch pruning — promising paths survive; failing ones get discarded

Inference-time compute used as search gives dramatically higher reliability in long-running agent flows. This is exactly how Google runs internal harnesses: a set of skills that teach agents to use internal tooling for coding, code review, performance measurement, and log fetching.

Inference hardware: the next battleground

Dean’s “put it in memory” moment for 2026 is high-performance, low-energy dedicated inference hardware — the analog of Google’s 2001 decision to move the search index from disk to RAM.

The physics behind it:

• A single multiplication on an accelerator costs ~1 picojoule
• Moving that data from HBM to the processor costs 1,000x more energy than the computation itself
• This forces batching (good for throughput, bad for single-user latency)
• Communication bandwidth degrades sharply beyond ~500-chip clusters

50x inference latency reduction would unlock entirely new application paradigms: robots, real-time video processing, operating systems, continuous decision-making. Today, >10-second latency means humans treat AI as an occasional consultation tool. Near real-time changes the product boundary completely.

Taste: the scarcest skill when agents write all the code

When agents handle execution, knowing what to ask them to solve becomes the rarest skill. Dean’s advice for building taste:

1. Work on many different problems — build pattern recognition
2. Keep a prediction log — write 10 things you think will matter in 12 months; check yourself a year later
3. Run crazy first-principles thought experiments — like his hardware idea: “What if we designed chips out of unreliable transistors that make 20 errors a day, handling faults via higher-level redundancy like the human brain?”

“Most of the battle is what problem are you going to spend your time on. If you pick the problem well and succeed in solving it, that’s way better than delightfully executing a research investigation into a rather boring problem.” — Jeff Dean

Discovery Loop: the 1% Rule applied

Two weeks after the talk, Dean left Google with his longest-standing collaborators — Sanjay Ghemawat (MapReduce, Bigtable, Spanner), Oriol Vinyals (DeepMind VP), and Quoc Le (Google Brain co-founder) — to build Discovery Loop, with Google as founding investor and cloud partner.

Its mission: automate and compress the scientific method. AI systems that propose, run, and evaluate experiments on their own — thousands in parallel. Initially applied recursively to ML research itself (AI building better AI), then to chip design and materials science.

It’s the 1% Rule in company form: targeting the ultimate 0–1% territory where general models fail, using automated closed-loop systems with reliable evaluators — because, as Dean says, “anything with measurable goals can make great progress today.”

What this means for you

1. Audit your idea against the frontier. If Gemini/GPT/Claude can do 20% of it today, the clock is running. If they’re at 0–1%, you’re in the green zone.
2. Own the data or own the domain. Generalists can’t chase every niche; protected data and specialized models are the durable moats.
3. Engineer the context, not the weights. Retrieval, tools, memory, and orchestration are where small teams win — you need an API, not a GPU cluster.
4. Write precise specs. Agents can’t ask follow-up questions like a senior engineer can. The clearer the specification, the better the agent performs.
5. Design for multi-agent search. Expect the step-30 wall and architect parallel exploration + evaluator pruning from day one.

Conclusion

The 1% Rule is deceptively simple, but it reshapes competitive strategy in AI: if the frontier can already do your job one-fifth of the time, you’re building on borrowed time. The infrastructure underneath — context engineering, multi-agent search, specialized inference silicon, automated experiment loops — is where the next decade of value gets created or destroyed.

And when the architect of MapReduce, TensorFlow, the TPU, and Gemini walks out of Google to fund the 0–1% zone himself, it’s worth taking the number seriously.