By playing, you agree to uListen's Terms and Privacy Policy and YouTube's Terms of Service.
Sequoia CapitalAndrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Summaries, chapters, transcripts, and FAQs on this page are made by uListen, not YouTube.
CHAPTERS
Jump to publisher timestampsChapter summaries
Why he’s never felt more behind as a programmer: the December inflection
Andrej Karpathy explains why recent agentic coding tools abruptly changed his relationship to programming. He describes a shift from “helpful but error-prone” code generation to repeatedly getting correct results without needing to fix them, which increased his trust and led to constant “vibe coding.”
- •He had used agentic coding tools for about a year, but earlier outputs often required correction
- •In December, he noticed a stark improvement: code “just came out fine” repeatedly
- •Growing trust in the tools led him into a “vibe coding” workflow
- •He emphasizes that many people’s impressions are outdated if they last evaluated AI earlier in the year
Software 1.0 → 2.0 → 3.0: prompting as a programming interface
Prompting and context become the control surface for a new kind of “programmable” system, distinct from writing rules (Software 1.0) or training weights with datasets (Software 2.0). Andrej frames LLMs as interpreters that operate over the information in the context window, changing what it means to build products and workflows.
- •Software 1.0: explicit code; Software 2.0: datasets/objectives/architectures as the programming
- •LLMs trained on broad internet tasks become broadly “programmable” via context
- •Software 3.0: the lever is prompting and what you place in context
- •This shift is broader than coding—more general information processing becomes automatable
Agents as installers: replacing brittle scripts with copy-paste instructions
Andrej uses the example of installing a tool to illustrate Software 3.0 thinking. Instead of writing increasingly complex cross-platform shell scripts, a workflow can be reduced to text instructions given to an agent that adapts to the environment and debugs in the loop.
- •Traditional installers balloon in complexity when supporting many platforms
- •A “copy-paste this to your agent” approach can replace detailed scripts
- •Agents can inspect the local environment, take actions, and debug interactively
- •The core artifact becomes the instruction text rather than the installer code
Menu Gen vs. the raw-prompt alternative: when the app “shouldn’t exist”
Andrej recounts building a menu-photo app that OCRs items and generates illustrative images, then seeing a more direct approach that skips the app. He argues that in a more “raw” Software 3.0 paradigm, the prompt and model can collapse much of the intermediate application logic.
- •Menu Gen: upload a menu photo, extract items, generate images, re-render a menu-like UI
- •He built and deployed it (including running it on Vercel) through vibe coding
- •He then saw a workflow that takes a photo and prompts a model to overlay generated content directly
- •He concludes much app code may be “spurious” when models can do end-to-end transformations
Beyond speeding up what exists: new products from “recompiling” information
Andrej argues the real excitement isn’t just doing old workflows faster, but enabling things that couldn’t exist before. He cites LLM-based knowledge bases that reorganize and recompile collections of documents into new, queryable structures.
- •He warns against only reframing AI as acceleration of existing software patterns
- •Some outputs are new categories of artifacts, not just faster programs
- •Example: generating wikis/knowledge bases by reorganizing a set of documents
- •The system can create new “projections” or reframings of existing information
What might feel obvious later: neural nets as the host process
When asked what will look obvious in hindsight, Andrej sketches an extrapolation where neural networks do most of the heavy lifting and classical compute becomes a coprocessor. He notes this could produce unfamiliar interfaces and workflows, arriving gradually in pieces.
- •He imagines more “completely neural” computing workflows as an extrapolation
- •Inputs like raw video/audio could drive dynamically rendered UIs
- •Neural nets could become the “host process,” with CPUs as a “coprocessor” for deterministic tasks
- •He expects the transition to happen piece by piece, with the path still unclear
Verifiability as the accelerator—and the source of jagged capability
Andrej introduces verifiability as a key reason some domains are rapidly automated. He connects frontier training to reinforcement learning with verification rewards, producing models that excel in verifiable areas like math and code while remaining uneven elsewhere.
- •Traditional computers automate what you can specify; LLMs automate what you can verify
- •Frontier training uses reinforcement learning environments with verification rewards
- •This training produces “jagged” capabilities: sharp peaks in verifiable domains, rough edges elsewhere
- •He frames verifiability as a lens to understand why models feel uneven
Why models are uneven: “labs care” and what enters the training mix
Andrej argues jaggedness reflects not only verifiability, but also what labs prioritize and include in data and training. He illustrates how capability can spike when a domain is emphasized, and warns users must explore models because there’s “no manual.”
- •Model strengths depend on both verifiability and what labs focus on
- •Some verifiable domains may be ignored if they’re not seen as economically valuable
- •He gives examples of surprising weaknesses alongside very strong coding performance
- •He stresses users must probe where a model performs well vs. out-of-distribution and consider fine-tuning when needed
Founder lens: building in verifiable domains and fine-tuning your own leverage
Stephanie asks how founders should respond if labs dominate the most obvious verifiable domains. Andrej suggests verifiable settings remain tractable for smaller players too, because they can create reinforcement learning environments and fine-tune models to pull a reliable “lever.”
- •Verifiability can let teams apply reinforcement learning or fine-tuning even without lab focus
- •If you can construct diverse RL environments/data, you can improve performance with fine-tuning
- •He suggests there are valuable verifiable environments not currently emphasized
- •He argues many areas may become verifiable to some extent, making broad automation plausible
From vibe coding to agentic engineering: raising the floor vs preserving the bar
Andrej distinguishes vibe coding from agentic engineering. Vibe coding expands who can build software; agentic engineering is about coordinating powerful but fallible agents to move faster without lowering professional standards like security and quality.
- •Vibe coding: raises the floor—more people can build more software
- •Agentic engineering: keeps the quality bar; accountability remains with builders
- •Agents are “spiky,” stochastic, and powerful—coordination becomes an engineering discipline
- •He claims the productivity ceiling can exceed the old notion of a “10X engineer”
What “AI-native” coding looks like: tool mastery and new hiring tests
Andrej describes AI-native coding as fully utilizing available agentic tooling and investing in one’s setup. He also argues hiring practices should change away from puzzle-style interviews toward evaluating large, real deployments and adversarial testing.
- •AI-native performance is about extracting maximum value from agent tools and workflows
- •He compares it to mastering prior developer tools like editors and environments
- •He says many hiring processes haven’t been refactored for agentic engineering
- •He proposes evaluating candidates via large projects, security quality, deployment, and attempts to break the system
Human value with agents: taste, oversight, fundamentals—and avoiding “intern mistakes”
Asked what human skills become more valuable, Andrej says agents resemble interns: strong recall but prone to odd design errors. Humans remain responsible for judgment, taste, specifications, and fundamental understanding, while agents handle many API-level details.
- •Humans provide aesthetics, judgment, taste, and oversight while agents fill in details
- •He shares a Menu Gen bug where an agent incorrectly matched users by email across systems
- •He notes he no longer memorizes many API quirks because agents can handle them
- •He emphasizes humans must still understand fundamentals (e.g., efficiency implications) and define correct system specs
Will taste be automated? Limits from current reward structures and “outside the RL circuits”
Andrej suggests today’s weaknesses in code elegance and simplification may reflect what isn’t rewarded during training. He describes experiences where models struggle to simplify code further, which feels like operating outside the model’s reinforcement-learned “circuits.”
- •He observes model-generated code can be bloated with awkward abstractions even if it works
- •He hypothesizes aesthetics and simplification may not be sufficiently rewarded in training
- •He cites difficulty simplifying a project further despite repeated prompting
- •He believes nothing is fundamentally preventing improvement; labs just may not have optimized for it yet
Animals vs ghosts: a framing for trust and expectations
Stephanie brings up Andrej’s “animals versus ghosts” analogy, and he explains it as an attempt to form an accurate mental model of what these systems are. He cautions against anthropomorphizing and frames the systems as statistical simulators shaped by pretraining and reinforced behaviors.
- •The framing is meant to improve user competence by clarifying what the systems are/not
- •He argues they aren’t animal-like intelligences with motivations you can influence emotionally
- •He describes the substrate as statistical pretraining with reinforcement learning bolted on
- •He presents it as a mindset tool that encourages caution and ongoing exploration rather than a checklist of rules
Agents with permissions: rewriting infrastructure for “agent-first” workflows
Andrej predicts a shift toward environments built for agents rather than humans. He criticizes human-oriented documentation and manual setup steps, and hopes for infrastructure where the primary interface is what you can hand to an agent to execute end-to-end, including deployment.
- •He expects much software and infrastructure to be rewritten to be “agent native”
- •He dislikes docs that tell humans what to do instead of giving agent-ready instructions
- •He frames agentic systems in terms of sensors and actuators over the world
- •He recounts deployment/configuration hassles and hopes future workflows let an agent build and deploy without manual clicking
Education in an agentic world: you can outsource thinking, not understanding
To close, Andrej argues understanding remains the bottleneck even as intelligence gets cheaper. He describes using LLM-based knowledge bases to reproject information in ways that build insight, enabling better direction of agents and better decisions about what to build.
- •He quotes an idea that you can outsource thinking but not understanding
- •He sees humans as still responsible for directing goals and evaluating what’s worth building
- •He’s excited about LLM knowledge bases as tools for processing and reorganizing information
- •He describes generating synthetic views over fixed data to ask better questions and deepen understanding
