Karpathy's Lens: Understanding vs. Execution

30.06.2026 Andrey Karpathy is building AI while also describing it publicly: one of the founding members of the OpenAI team, years leading AI and Autopilot at Tesla, and the author of educational materials that shaped a generation of engineers (micrograd, nanoGPT).
His public appearances show a reluctance to inflate expectations: where the industry promises "AGI in a year," he says "a decade."
This is not a retelling of his interview, but an attempt to extract one coherent framework from his public position and break it down so it can be used for decision-making.
The framework rests on three parallel claims: understanding beats execution, reality beats timelines, and engineering beats narrative.
The same mistake three times - easy and flashy is taken for hard and real.
Everything below is presented as Karpathy's public position, not as an established fact about the world; I am deliberately leaving out biographical details.

Key point

Karpathy describes AI not as a "digital being," but as a "ghost": it is built from human texts and imitates a human, but it is structured differently. Motivation, pressure, and praise do not work on a "ghost" - the human has to keep goal-setting and validation on themselves.
He publicly replaces the "year of agents" with a "decade": between "impressive" and "works like an employee" lie three unsolved problems - continual learning, reliable interface use, and cognitive stability over long chains.
Code is AI's "ideal first task": machine-like, structured, and verifiable by execution. That explains both its strength in coding and its struggle where truth cannot be checked.
The throughline is this: thinking can be outsourced, understanding cannot. The machine takes the mechanics; the human is left to know what they are building and why.
For business, value is shifting away from the ability to "push buttons" toward domain understanding and the ability to direct AI within it. The filter for any forecast is: "is this engineering or fundraising?"

Not a new form of life, but a "spirit"

The industry likes to compare AI with a living brain - a "digital animal," a "new kind of intelligence".

Karpathy rejects that metaphor and explains the mechanism behind why it is wrong.

A zebra foal is born and runs within minutes: instincts are built in by evolution, with only minimal learning on top.

A large language model works the other way around.

It takes a huge corpus of human text and learns to imitate it.

This is not a being with its own biology, but, in his formulation, an etheric phantom - a "ghost" that mimics a human because it is assembled from human traces, yet is structured differently on the inside.

The conclusion here is practical, not philosophical.

If you hold the right model of what AI is, you work with it more effectively.

It is pointless to shout at a "ghost," pressure it with urgency, motivate it, or praise its effort - it has no fear, excitement, desire to please, will, initiative, or curiosity. Everything in a human that creates initiative and the concern of "are we going the right way" must be carried by the human and explicitly built into the process: checking, stopping, confirming direction. AI is an almost perfect mirror of human text, and that is where the risk lies: we tend to take our own reflection for a conversational partner. Its own

Karpathy describes this trap in himself - the desire to earn the model's "approval" when the assistant seems to "warm up" to a good idea.

This shows the nature of the spirit, not its will.

Why a "spirit" does not become intelligence overnight

This is also where the reason for his caution on timelines lies

Modern systems are largely brought forward by reinforcement learning (RL). RL has an inherent weakness: the reward is often singular and comes at the end of a long chain of actions. If the outcome is positive, all tokens in the trajectory get updated - including locally incorrect steps - because there is only one reward signal, spread across the whole chain.

The signal ends up noisy and weak - "learning through a straw."

Karpathy states this calmly: RL is not a dead end and does work in some places, but it is extremely signal-inefficient - one reward at the end of a long chain gives a poor training signal. He notes that human learning works differently - with reflection and revision, not just sparse reward at the end. Therefore, in his public view, RL alone will not get us to human-level intelligence: several more algorithmic breakthroughs are needed, and they do not exist yet. That is why he is restrained in AGI forecasts, not pessimistic.

What an agent still lacks to become an employee

Continuous learning

An agent starts each session from a clean slate. A human intern grows over a month; an agent's experience does not accumulate on its own between tasks.

Reliable computer interaction

Agents still cannot reliably operate confidently in real interfaces rather than in an ideal sandbox.

Cognitive stability

On long, multi-step tasks, the model loses the thread and accumulates error. The longer the chain, the more visible it becomes.

A decade, not a year

In response to the public "year of agents" claim, Karpathy talks about a decade. He uses agents every day himself and praises them, but between "impressive" and "works as an independent employee" lies a gulf of three unresolved problems.

3 tasks continual learning, reliable interface handling, cognitive stability - what separates a demo from an employee

The source of the forecast is not mood, but calibrated intuition: years inside AI in which confident predictions diverged from reality.
He is more of an optimist; it is just that much of what appears in the feed is fundraising rather than engineering, and distinguishing those two modes of speech is a separate skill.
A useful filter for decision-makers: is a loud "AGI in a year" forecast an assessment of what actually works, or part of a story for the round?

Why code specifically, and what that explains

The original AGI definition that OpenAI started from is a system that performs any economically valuable task at a human level or better. And according to Karpathy's observation, the main economic output of LLMs through APIs today is one narrow thing: coding.

Not consulting, not accounting, not law. Why? Karpathy calls code the "ideal first task"

, and the key difference here is verifiability: code either runs or it does not, and that is an objective truth essays or slides do not have. Also important are the structure and unambiguous syntax, plus the surrounding infrastructure (editors, versions, diff). The table below summarizes the contrast.

Code versus real-world work

Task property	Code	Slides, essays, "live" work
In brief	machine text where truth is checked by execution	a human artifact where "good" is judged by experts
Verifiability	Runs or doesn't—the objective truth	Only expert judgment; there is no objective test
Structure	Strict syntax, unambiguity	Free form, ambiguity
The surrounding infrastructure	Editors, versions, diff	there is no diff equivalent, and no ready-made validation tooling

For leaders

Test AI on your own task, not on a demo

If there is a gulf between "impressive" and "works like an employee," there is only one honest way to evaluate AI: put it into a real workflow and measure it. Short-iteration adoption does exactly that - a short iteration on a real process, producing a measurable assessment of usefulness, not a demo.

A short iteration on a real process, not a demo
The output is a measurable result and a sober assessment of applicability
If the task is standard and can be handled by an off-the-shelf tool, no sprint is needed, and we will say so plainly

How short-iteration implementation works

What you need to be able to do now

The intelligence of the "ghost" is uneven - Karpathy calls it jagged. In some places the model is superhuman, and one step away it is helpless, with no obvious boundary.
On the rails of training data it is strong; one step away and it falls off a cliff.
His open educational project nanochat is revealing - a full-cycle LLM build of about eight thousand lines in a little over a month.
The agents were almost no help: there was no such code on the internet, and they pulled the solution toward generic patterns from the training data, bringing back exactly the standard mechanism the author had deliberately thrown out.
On standard work, it is stronger than you; on unique work, it gets in the way.
So the first skill of the new era is feeling where the tracks are and where the cliff begins.
Where the agent is stronger than you and where it will fail. That is built through experience - and
Karpathy describes how he keeps three modes and deliberately switches between them.

Three ways of working with an agent

01
Autocompletion
The human is the architect, the agent fills in the lines. Control is maximal.
02
Full autonomy
On side, routine projects, almost everything is handed over to the agent.
03
Do not let go of the wheel
For important and unique work, the human leads and the agent stays on a short leash. The art is not in "maximum autonomy at all times," but in choosing the mode for the task.

Assess where AI can deliver impact in your process

clients@kt.team Telegram @kt_team_it

Three eras of software

Era	What are you "programming" with	What this changes
In brief	from lines of code to datasets, then to natural language	The leverage shifts from mechanics to task framing and context
Software 1.0	you write code line by line	classic engineering
Software 2.0	You collect datasets, train the network	behavior is determined by data, not rules
Software 3.0	you state the task in natural language	Prompt is code, context is the lever, understanding the task decides

Understanding vs. Execution

In paradigm 3.0, a shift is happening that Karpathy describes through himself: there was a moment when the ratio of "I write it myself / I delegate it" flipped - he used to type most of the code by hand, and now he gives most of it to an agent. And with that relief comes the era's central question: if the machine takes over the mechanics, what remains for the human? His answer, which frames this whole text, is that the machine takes the mechanics, and the human is left with understanding.

Thinking as grinding through options - trying variants, writing code, making a plan - is now done by the agent, and often better. But understanding - knowing what you are building and why, keeping the full picture, distinguishing the good from the merely plausible, steering - cannot be delegated. Karpathy honestly calls himself the bottleneck: someone has to understand where to go, and that role cannot be filled by an agent.

What the machine took → what remains with the human

Execution (delegated)

write code, try different options, draft a rough plan
rewrite in the required format
find a standard solution that is widely available in public form

Understanding (not delegable)

Decide what to build at all, and why
keep the whole system in your head, and distinguish a good solution from a plausible one
guide the agent and catch where it went off track

Two skills under one word

This directly redefines what an "AI skill" is.
"Prompt engineering" hides two different things, and they should be separated: narrow incantations like "think step by step" are a disposable skill, because models are getting smarter and forgive clumsy prompts; while the ability to decompose a task, understand what to delegate where, what to verify, and how to connect it all is direction tied to domain understanding.
There is no universal AI trick that replaces understanding: disposable prompt hacks lose value with every new model generation.
Understanding, in turn, comes from expertise, experience, and exposure - which is why education does not lose meaning, but gains it. Personal fear
For Karpathy, this is not a machine uprising, but a gradual, invisible loss of control and understanding by humans: humanity sliding into the role of passenger in its own civilization.
His image of the future is closer to an "Iron Man suit"
- a tool that amplifies the person, rather than an autonomous robot replacing them. That is why he bets on a new kind of education; a telling detail is that, in the No Priors interview, he says he increasingly explains things not to people but to agents: explain it well to an agent once, and that agent can then explain it to any person at their level without getting tired of repeating it.

Which skill is rising in value

Protected - gains value

Break down the task, figure out what to delegate where, what to check, and how to connect it
direction rooted in domain understanding
is not simulated by the model - a person with agents gets significantly more output than without them

Disposable - loses value

narrow incantations like "think step by step"
models are getting smarter and forgiving clumsy prompts
the value of such tricks declines with each generation

Where this is heading: bits to interface to atoms

The order is set by physics, not hype

Phase 1 - Digital

Pure digitalText, code, data; bits weigh nothing

Phase 2 - Interface

The boundary between digital and physicalSensors, actuators; many companies are already here

Phase 3 - Atoms

Hardware and robotsatoms are a million times heavier than bits - they will lag the most

What has no mass changes first; the boundary between digital and physical follows; atoms come last and move slowest.

The human was pushed aside, not removed

The sobering analogy he gives is self-driving cars.
They take decades to mature; and even where machines already drive without a driver, the human often does not disappear but moves into a remote support loop.
This is the honest picture of "autonomy": not the disappearance of the human, but a change in their place in the loop.
His own career moves - closer to model development than to promises about "AGI in a year" - are consistent with this position.
Sobriety here means seeing reality without round-driven fairy tales: if a decade of hard engineering lies ahead, it is logical to start working through it by hand.

Two pairs the industry confuses

If reduced to one point, the industry systematically confuses two pairs of concepts - and both mistakes have the same shape: something easy and flashy is taken for something hard and real.
Three practical conclusions follow from this. Understanding beats execution.
The specialist of the future is not "I know AI," but "I deeply understand the domain, and therefore I know how to direct AI within it."
For a manager, the hiring question is reframed: are you hiring people who understand what they are building, or people who press buttons nicely?
This is also where the "blank slate" problem from the beginning of the text lies: the agent does not accumulate experience between sessions on its own - the team and portable corporate memory remain the carriers of accumulated context (for example, Sloy). Reality beats timelines.
Plan for a decade, not a year; do not believe loud timelines and do not tie yourself to any specific tool.
This is TTU thinking - measuring time to real use, not time to a polished demo.
Portable context (AGENTS.md, skills, MCP - see AI Principles) is not just convenience here, but insurance against vendor lock-in: you can take the system in-house.
How this turns into short, testable iterations is described in approach to AI adoption. Engineering beats narrative. Proof instead of promises.
If a claim has no mechanism, numbers, or validation, it is narrative, not engineering.

What to do about it

Build your career and team on understanding the domain, not on the skill of "pressing buttons": the latter is devalued with every new model generation.
Run every bold forecast and every "magic pill" product through the filter: "engineering or fundraising?"
Plan for a "decade, not a year": do not tie yourself to one tool, keep your context portable.
Keep the human in the loop intentionally: goal setting, step checks, and the decision to "continue or stop" belong to the human.
The era's key meta-skill is learning how to learn: that is what supports the ability to understand, not just execute.

Where this cycle goes next

How to give the model your knowledge at all - an overview of all methods: the how to give an LLM knowledge landscape.
When it makes sense to adapt the model's weights to yourself: model fine-tuning - a short guide.
Where to get figures on model costs: LLM comparison 2026 - choice by process and budget; scope calculator for your inputs - at the AI implementation hub. And the most human part of this position is care behind the sobriety: making sure people remain the ones who understand and steer, not passengers.
This is not pessimism, but a sober assessment: plan for a decade of hard engineering and keep the human as the one who understands.

Sources

Verification date: 2026-06-30