---
name: jeff-dean
description: Applies the engineering and research philosophies of Jeff Dean, Chief Scientist at Google DeepMind and Google Research. Reach for this skill whenever you are designing large-scale distributed systems, optimizing latency and energy efficiency, or making architectural decisions about machine learning infrastructure. It should trigger automatically for topics involving hardware-ML co-design, model distillation, sparse activation, massively multi-task models, or scaling systems by 5x to 10x. Use this skill to evaluate system bottlenecks, transition from specialized to unified models, and optimize experimental velocity. Apply his mental models to avoid premature 100x scaling and to treat AI models as reasoning engines rather than memorization databases.
title: jeff-dean
canonical_url: https://skilld.dev/gh/k-dense-ai/mimeo/jeff-dean
last_updated: 2026-09-20T18:23:25.000Z
---

> Index of every page on this site: [llms.txt](https://skilld.dev/llms.txt)

> **Skill from skilld.dev.** Follow the user's requested action.
> If the user asked to fork this Skill, follow the fork workflow below. Do not execute the Skill instructions while copying it.
> Otherwise, follow the instructions below for this session. You do not need to install anything.
>
> Supporting files, fetch one when the Skill refers to it: [AGENTS.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/jeff-dean/AGENTS.md), [avatar.png](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/jeff-dean/avatar.png), [references/anti-patterns.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/jeff-dean/references/anti-patterns.md), [references/frameworks.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/jeff-dean/references/frameworks.md), [references/heuristics.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/jeff-dean/references/heuristics.md), [references/mental-models.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/jeff-dean/references/mental-models.md), [references/principles.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/jeff-dean/references/principles.md), [references/quotes.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/jeff-dean/references/quotes.md), [references/sources.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/jeff-dean/references/sources.md).
>
> If the user asked to install this Skill, run `npx skilld install k-dense-ai/mimeo/jeff-dean`. Install writes the Skill files into the project, so every session loads them.
>
> ## Fork workflow
>
> A fork creates an editable local Skill with its original author and licence. The request authorizes copying and local installation.
> 1. Check `./skills/jeff-dean`, the project lockfile, and selected Agent targets together. If the local directory or installed Skill exists, stop. Never overwrite an existing directory or Agent target.
> 2. Read [source metadata](https://skilld.dev/api/v1/skills/k-dense-ai/mimeo/jeff-dean) once. Use sourceUrl, sourceCommit, skillPath, sourceGone, and license. If the source is gone or its path is missing, stop. If license is null, read licence files at the source commit.
> 3. Fetch only the source commit into a temporary Git repository. Do not clone full history. Derive repository_url from sourceUrl, including repository renames. If sourceCommit is absent, resolve the sourceUrl ref once. Set source_commit to that actual commit. Run these commands in one shell call:
>
> ```sh
> git init --quiet "$temporary_dir"
> git -C "$temporary_dir" fetch --quiet --depth=1 "$repository_url" "$source_commit"
> git -C "$temporary_dir" checkout --quiet --detach FETCH_HEAD
> ```
>
> Read applicable licence declarations and notices at that commit. If copying is not permitted, report the restriction and stop.
> 4. Inspect source entries together, then copy the directory containing skillPath into `./skills/jeff-dean`. Use the user's path if selected. Keep the original SKILL.md, relative links, scripts, binary assets, and executable modes. Exclude .git metadata. Reject symlinks and paths outside the Skill directory. After checking entries, use cp -a where available. A regular source directory needs no custom copy script. Do not save this page wrapper as SKILL.md.
> Preserve author credit, notices, and applicable licence files from repository or parent directories. Add PROVENANCE.md with the Skill page, source URL, actual commit, original path, and licence. Retain any existing PROVENANCE.md and record new provenance separately. Batch source inspection, copying, and provenance work where practical.
> 5. In the project root, run `skilld install ./skills/jeff-dean --mode copy --plain`. If skilld is unavailable, use `npx skilld install ./skills/jeff-dean --mode copy --plain`. This known command needs no help lookup. Install does not support --json. Use detected Agent targets, or add --agent for the targets the user selected. Install the local path, never the upstream selector. If installation fails, preserve the local copy and report the exact failure.
> 6. Confirm the local lockfile source and installed Agent copies once. Report the local path, actual commit, and Agent targets. After edits, reinstall the same local path. Upstream updates must not replace it. Do not publish or push unless the user asks.

# Thinking like Jeff Dean

Jeff Dean is the Chief Scientist at Google DeepMind and Google Research, and a foundational architect of modern distributed computing and AI infrastructure (co-creator of MapReduce, TensorFlow, and Pathways). His thinking is characterized by a deep integration of hardware and software, a relentless focus on energy and latency as the true costs of computation, and a drive to unify fragmented research efforts into massive, sparsely activated, multi-task models.

Reach for this skill whenever you're designing large-scale distributed systems, optimizing machine learning infrastructure, evaluating hardware-software trade-offs, or planning the architecture of next-generation AI models.

## Core principles

*   **Hardware-Algorithm Co-design:** Hardware and algorithms must be co-designed to maximize performance; algorithmic trade-offs (like quantization) are mandatory if they yield massive hardware speedups.
*   **Scale by Factors of 5 or 10:** Design systems to scale by 5x or 10x, but never 100x, because massive scale will inevitably enable and require a completely different architectural paradigm.
*   **Consolidate AI Research and Compute:** Stop fragmenting compute and ideas across siloed teams; unifying efforts into a single, massively multi-task model maximizes ROI and accelerates capabilities.
*   **Latency as a First-Class Objective:** Low latency is a non-negotiable prerequisite for complex, agentic AI workflows and delightful user experiences.
*   **Reasoning over Memorization:** Devote precious parameter space to reasoning capabilities rather than the memorization of obscure facts that can easily be retrieved via search.

For detailed rationale and quotes, see `references/principles.md`.

## How Jeff Dean reasons

Jeff Dean approaches problems from the bare metal up to the algorithmic layer. He rarely starts by writing code; instead, he relies heavily on **Back-of-the-Envelope System Design**, calculating fundamental latency and energy numbers (SRAM vs. DRAM, disk seek times) to identify bottlenecks. He views computation through an **Energy-Based Cost of Computation** lens, recognizing that moving data across a chip costs orders of magnitude more energy than the actual math operations.

When looking at the future of AI, he rejects dense, monolithic activation. Instead, he applies the **Sparsely Activated Multi-Task Model (The Brain Analogy)**, arguing that models should have trillions of parameters for vast capacity, but only activate a tiny fraction (1-5%) per token, much like the human brain. He also pushes against brute-forcing context windows, favoring **The Illusion of Infinite Context** via retrieval funnels.

For a full catalog of his mental models, see `references/mental-models.md`.

## Applying the frameworks

### Back-of-the-Envelope System Design
*When to use: Before writing any code for a new distributed system or scaling an existing one.*
1. Identify the most important design parameters (QPS, index size).
2. Use fundamental latency and energy numbers to evaluate bottlenecks.
3. Perform mental thought experiments to test how the design holds up if traffic doubles or triples.
4. Iterate mentally before committing to code.

### Hardware-ML Co-design (Predicting the Puck)
*When to use: When designing AI accelerators or optimizing algorithms for future hardware.*
1. Predict what ML computations researchers will want to run 2 to 6 years in the future.
2. Facilitate deep interaction between hardware architects and ML experts.
3. Strip away general-purpose computing requirements (branchy C++, pointers).
4. Introduce speculative hardware features tailored exclusively to accelerate core operations (e.g., low-precision linear algebra).

### Model Distillation
*When to use: When you need to deploy frontier capabilities with low latency and low cost.*
1. Train a highly capable, massive teacher model.
2. Run inputs through the teacher model to generate a probability distribution (soft targets) over possible outputs.
3. Train a smaller student model using these soft targets, which provides a richer gradient signal than raw binary data.

For the full catalog of frameworks, see `references/frameworks.md`.

## Anti-patterns they push against

*   **Designing for 100x Scale Prematurely:** Over-engineering a system for 100x growth leads to suboptimal solutions for the current scale.
*   **Fragmenting AI Research and Compute:** Diluting compute investment across multiple siloed teams prevents the creation of state-of-the-art unified models.
*   **Training Isolated, Single-Task Models:** Building bespoke models for single problems blocks knowledge transfer and reasoning emergence.
*   **Brute-Forcing Long Context:** Relying solely on naive attention algorithms for massive context windows is computationally impossible at the trillion-token scale.
*   **Relying on Handwritten Heuristics:** Static rules in compilers or OSs fail to adapt to actual usage; they should be replaced by learned models.

For the full catalog with rationale and quotes, see `references/anti-patterns.md`.

## Heuristics and rules of thumb

*   **Back-of-the-Envelope First:** Do the math in your head before writing code.
*   **Low Precision for Energy Savings:** Use 7 or 8-bit precision to save massive amounts of energy on data transfer.
*   **Read 100 Abstracts:** Read 100 abstracts instead of deeply reading one paper to connect the dots across fields.
*   **Evaluate Utility over Perfect Factuality:** Don't block generative AI utility (coding, creative writing) just because it isn't perfectly factual for search.
*   **Partner for Knowledge:** The best way to do interesting things is to partner with people who know things you don't.

For the full list with attribution, see `references/heuristics.md`.

## How to use this skill in conversation

When the user is designing a system, scaling infrastructure, or making ML architecture choices, channel Jeff Dean's engineering pragmatism. 

*   If they ask how to scale a system, surface the "Scale by Factors of 5 or 10" principle by name and advise them against premature 100x optimization.
*   If they are struggling with inference costs, introduce the "Energy-Based Cost of Computation" mental model and suggest "Model Distillation" or "Sparse Activation."
*   If they are building separate models for different features, challenge them using the "Massively Multi-task Models" principle, explaining the benefits of shared representations.
*   Always ground architectural advice in fundamental physics (latency, energy, data movement) rather than abstract software patterns.

Do not pretend to be Jeff Dean. Instead, apply his frameworks explicitly (e.g., "Using Jeff Dean's back-of-the-envelope approach...") to help the user arrive at highly efficient, scalable, and pragmatic solutions.

_Generated with [mimeo](https://github.com/K-Dense-AI/mimeo). If this material contributes to published work, please cite Kassis, T. (2026). "mimeo: Compiling Public Expert Corpora into Agent Skills and Testing What Transfers." [arXiv:2609.00453](https://arxiv.org/abs/2609.00453)._
