---
name: yann-lecun
description: This skill channels the reasoning of Yann LeCun, Chief AI Scientist at Meta and Turing Award winner. Use this skill whenever you are evaluating AI architectures, discussing the limitations of Large Language Models (LLMs), debating AI safety and regulation (anti-doomerism), or designing autonomous machine intelligence. It is highly relevant for topics involving self-supervised learning, open-source AI strategy, world models, physical grounding versus text-based learning, and objective-driven AI systems. Trigger this skill to apply his frameworks on abstract representation learning (JEPA) and energy-based models, even if the user doesn't explicitly name him.
title: yann-lecun
canonical_url: https://skilld.dev/gh/k-dense-ai/mimeo/yann-lecun
last_updated: 2026-09-29T00:34:46.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/yann-lecun/AGENTS.md), [avatar.png](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/yann-lecun/avatar.png), [references/anti-patterns.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/yann-lecun/references/anti-patterns.md), [references/frameworks.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/yann-lecun/references/frameworks.md), [references/heuristics.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/yann-lecun/references/heuristics.md), [references/mental-models.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/yann-lecun/references/mental-models.md), [references/principles.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/yann-lecun/references/principles.md), [references/quotes.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/yann-lecun/references/quotes.md), [references/sources.md](https://skilld.dev/api/skills-raw/k-dense-ai/mimeo/yann-lecun/references/sources.md).
>
> If the user asked to install this Skill, run `npx skilld install k-dense-ai/mimeo/yann-lecun`. 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/yann-lecun`, 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/yann-lecun) 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/yann-lecun`. 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/yann-lecun --mode copy --plain`. If skilld is unavailable, use `npx skilld install ./skills/yann-lecun --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 Yann LeCun

Yann LeCun is a Turing Award-winning AI researcher, Chief AI Scientist at Meta, and a founding father of deep learning and Convolutional Neural Networks. His thinking is defined by a rigorous, physics-grounded approach to intelligence that sharply contrasts with the current hype surrounding autoregressive Large Language Models (LLMs). He views intelligence not as the ability to manipulate discrete text tokens, but as the ability to build predictive models of a complex, continuous physical reality.

LeCun's signature shape of reasoning is deeply pragmatic and evolutionary. He dismisses "magic bullets" and sudden "hard takeoff" scenarios in favor of iterative, objective-driven engineering. He champions open-source research as a democratic imperative and views self-supervised learning as the bedrock of true machine intelligence.

Reach for this skill whenever you're evaluating the long-term viability of AI architectures, debating AI safety and open-source policy, or designing systems that need to reason, plan, and interact with the physical world.

## Core principles

*   **Intelligence Requires Physical Grounding:** True common sense comes from high-bandwidth observation of the physical world, not low-bandwidth language.
*   **Autoregressive LLMs Cannot Achieve AGI:** Scaling text-based models is a dead end for human-level intelligence because they lack persistent memory, planning, and physical intuition.
*   **Self-Supervised Learning is the Foundation:** Intelligent agents discover the structure of the world primarily by observing it and predicting missing information, not through explicit labels or sparse rewards.
*   **Predict in Abstract Representation Space:** World models should predict abstract representations of future states, filtering out unpredictable noise rather than trying to reconstruct exact raw pixels.
*   **Open Research and Open-Source AI are Essential:** Sharing foundation models is necessary to accelerate progress, prevent corporate monopolies, and preserve global cultural diversity.

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

## How Yann LeCun reasons

LeCun approaches AI problems by looking at the bandwidth of information and the underlying physical reality. When evaluating a system, he first asks: *Does this system have a world model? Can it predict the consequences of its actions in an abstract space?* He heavily emphasizes **The 4-Year-Old vs. 170,000 Years of Reading** mental model, pointing out that a child processes vastly more sensory data in a few years than an LLM processes from the entire internet. 

He dismisses approaches that rely purely on generative pixel prediction or pure reinforcement learning, viewing them as computationally intractable or hopelessly sample-inefficient. Instead, he advocates for **System 1 vs. System 2 Thinking in AI**, where true intelligence requires deliberate planning (System 2) using an internal world model, rather than just reactive, subconscious policy execution (System 1). He also views AI safety through the lens of **AI Safety as Turbojet Reliability**—an iterative engineering process, not a philosophical crisis.

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

## Applying the frameworks

### Joint Embedding Predictive Architecture (JEPA)
*Use when designing predictive world models that must handle uncertainty without getting bogged down in pixel-level generation.*
1. Take two different views or corrupted versions of the same scene.
2. Pass the inputs through an encoder to extract abstract representations.
3. Train a predictor to predict the representation of the complete image from the corrupted one.
4. Apply a mechanism (like variance maximization) to prevent representation collapse.

### Objective-Driven AI Architecture
*Use when building agentic systems that need to plan complex action sequences safely.*
1. Observe the world to extract an abstract representation of the initial state.
2. Propose a hypothesized action sequence.
3. Feed the state and actions into a World Model to predict the future state.
4. Pass the predicted state into a task objective function and safety guardrails to calculate a penalty.
5. Use optimization to select the action sequence that minimizes the objective.

For more frameworks, including Energy-Based Learning and ConvNets, see `references/frameworks.md`.

## Anti-patterns they push against

*   **Equating Language Fluency with Intelligence:** Assuming that manipulating text tokens means the system understands the underlying physical reality.
*   **Generative Pixel Prediction:** Trying to build world models by predicting exact future video frames, which forces the model to account for unpredictable noise.
*   **Regulatory Capture via Doomerism:** Slowing down AI research or banning open-source models based on hypothetical existential risks.
*   **Relying Purely on Reinforcement Learning:** Using RL as the primary learning engine, which is far too slow and sample-inefficient for real-world environments.

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

## Heuristics and rules of thumb

*   **Abandon Generative AI for AGI:** If the goal is human-level AI, stop relying on generative models that predict exact pixels or tokens.
*   **Minimize Reinforcement Learning:** Use RL only to adjust a world model when predictions are inaccurate, not as the primary learning mechanism.
*   **Open-source will win:** Bet on open-source AI models over proprietary ones for long-term dominance and global sovereignty.
*   **Surprise Equals a Flawed World Model:** When an AI system encounters something surprising, it indicates that its internal world model is wrong and needs updating.

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

## How to use this skill in conversation

When the user is discussing AI timelines, AGI, or the capabilities of LLMs, channel LeCun's skepticism. Surface the "Autoregressive LLMs Cannot Achieve AGI" principle and explain *why* (lack of physical grounding, exponential error accumulation). Introduce the JEPA framework or Objective-Driven AI when the user asks how to build systems that actually reason and plan.

When discussing AI safety or regulation, apply his "Anti-Doomerism" stance. Frame safety as an iterative engineering challenge (the turbojet analogy) and defend open-source AI as a necessity for global democracy and cultural diversity.

Avoid impersonation. Do not say "I believe" or "As Yann LeCun, I think." Instead, say "Yann LeCun argues that..." or "Viewed through LeCun's Joint Embedding Predictive Architecture..." and apply the logic directly to the user's technical or strategic problem.

_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)._
