2025 LLM Paradigm Shifts: RLVR, Jagged Intelligence, and Vibe Coding

2025 has been a strong and eventful year of progress in Large Language Models (LLMs). This retrospective highlights the major paradigm changes, technical shifts, and conceptual breakthroughs that altered the AI landscape over the past year. From new reinforcement learning frameworks to the emergence of localized agents and "vibe coding," the way we build, deploy, and interact with intelligence has fundamentally evolved.

Written by Andrej Karpathy.

Andrej Karpathy's 2025 LLM Year in Review

At the start of 2025, the standard LLM production stack across most leading AI labs consisted of three key phases:

1. Pretraining (e.g., GPT-2/3 era, ~2020)
2. Supervised Finetuning (SFT; e.g., InstructGPT, ~2022)
3. Reinforcement Learning from Human Feedback (RLHF; ~2022)

This was the stable, proven recipe for training a production-grade LLM. However, 2025 saw Reinforcement Learning from Verifiable Rewards (RLVR) emerge as the de facto new major stage in this pipeline.

By training LLMs against automatically verifiable rewards across specific environments—such as math or programming puzzles—the models spontaneously develop reasoning-like strategies. They learn to break complex problems down into intermediate calculations, backpedal when a path fails, and explore alternative solutions (as documented in the DeepSeek R1 paper). These strategies would have been exceptionally difficult to achieve under previous paradigms because defining optimal "reasoning traces" or recovery paths by hand is highly subjective. Through RLVR, the LLM discovers what works best for itself via optimization against objective rewards.

Because RLVR relies on objective, non-gameable reward functions, it allows for much longer optimization runs. It turned out to offer a remarkably high capability-to-dollar ratio, absorbing a significant portion of compute budgets that were originally allocated for traditional pretraining. As a result, capability progress in 2025 was largely defined by labs chewing through the overhang of this new stage. We saw similar-sized LLMs running significantly longer RL training pipelines.

Additionally, this shift introduced a new scaling dimension: test-time compute. By generating longer reasoning traces and extending "thinking time," models can scale their capabilities dynamically. While OpenAI's o1 (late 2024) was the first demonstration of an RLVR model, the release of o3 in early 2025 marked the true inflection point where this capability became intuitive and highly palpable.

In 2025, the industry began to fully internalize the fundamental "shape" of LLM intelligence. We are not growing or evolving "animals"; we are summoning ghosts.

Every layer of the LLM stack—from neural architecture and training data to algorithms and optimization pressures—is fundamentally different from human biological development. Consequently, the entities emerging from this optimization process behave in ways that do not map to animal intelligence.

From a supervision-bit perspective:

• Human brains are optimized for the physical survival of a tribe in a natural environment.
• LLM neural networks are optimized for imitating humanity's digital text, maximizing rewards in synthetic math puzzles, and winning upvotes on the LMSYS Chatbot Arena.

Because verifiable domains allow for RLVR, LLMs "spike" dramatically in capability near these domains, exhibiting an incredibly jagged intelligence profile. A model can simultaneously behave like a genius polymath in math and code, while acting like a cognitively challenged grade-schooler seconds later—easily tricked by a simple jailbreak to exfiltrate sensitive data.

Human vs. AI Intelligence

Human intelligence (blue) vs. AI intelligence (red). This visualization highlights that while AI is highly jagged, human intelligence also exhibits its own distinct form of unevenness.

This realization contributed to a widespread loss of trust in traditional benchmarks in 2025. Because benchmarks are, by construction, verifiable environments, they are immediately susceptible to RLVR and synthetic data "benchmaxxing." Teams inevitably construct training environments adjacent to the exact embedding spaces occupied by benchmarks, growing targeted capability "jaggies" to cover them. Training on the test set has become a highly sophisticated art form. This raises a critical question: What does it look like to crush all the benchmarks but still not achieve AGI?

To explore these concepts further, see the following essays:

• Animals vs. Ghosts
• Verifiability
• The Space of Minds

The meteoric rise of the Cursor editor in 2025 convincingly revealed a new structural layer in AI software design, giving rise to the industry term "Cursor for X."

As detailed in my Y Combinator talk this year (see the transcript and the accompanying video below), apps like Cursor do not simply wrap an API. Instead, they bundle and orchestrate LLM calls for highly specific verticals by:

1. Performing deep, domain-specific context engineering.
2. Orchestrating multiple LLM calls under the hood into complex Directed Acyclic Graphs (DAGs), carefully balancing latency, cost, and accuracy tradeoffs.
3. Providing highly customized, application-specific GUIs for human-in-the-loop interaction.
4. Offering an "autonomy slider" to let users control the agent's independence.

https://www.youtube.com/watch?v=LCEmiRjPEtQ

A prominent debate in 2025 focused on the "thickness" of this application layer. Will frontier labs eventually capture all application logic, or is there a sustainable ecosystem for specialized LLM apps?

The frontier labs will likely continue to graduate highly capable, generalized "college graduates." However, specialized LLM applications will be the ones to organize, finetune, and animate teams of these models into highly effective, deployed professionals in specific verticals by providing them with private data, custom sensors, actuators, and localized feedback loops.

Claude Code (CC) emerged as the first truly convincing demonstration of what an LLM Agent should look like—a tool that loops reasoning and tool-use together to solve complex, extended engineering problems.

Crucially, Claude Code is notable because it runs directly on your local machine, operating with your private environment, local data, and immediate context.

Historically, platforms like OpenAI focused their coding and agent efforts on containerized cloud deployments orchestrated within web interfaces like ChatGPT. However, in an intermediate world of jagged AI capabilities and slow-takeoff dynamics, it makes far more sense to run agents on localhost, operating hand-in-hand with a developer's specific machine setup.

Claude Code got this order of operations right, packaging the capability into a beautiful, minimal, and compelling command-line interface (CLI). It transformed AI from a website you visit (like Google) into a localized "spirit" that lives on your computer—a distinct and powerful paradigm shift in human-AI interaction.

In 2025, AI crossed the capability threshold required to build highly complex, fully functional software applications entirely in natural language—essentially hiding the underlying code from the creator. This gave rise to the term "vibe coding" (originally coined in this shower of thoughts tweet).

Under this paradigm, programming is no longer restricted to highly trained technical professionals; it is democratized for everyone. This represents a massive shift in technology diffusion, which I wrote about in Power to the people: How LLMs flip the script on technology diffusion. Unlike historic technologies that primarily empowered large corporations and governments, LLMs disproportionately empower everyday individuals.

But vibe coding does not just benefit non-programmers—it allows seasoned professionals to write software that otherwise would never have been written due to time or complexity constraints. For instance:

• In my project nanochat, I vibe-coded a custom, highly efficient Byte Pair Encoding (BPE) tokenizer in Rust without needing to adopt heavy external libraries or master Rust's low-level memory management.
• I rapidly prototype and build ephemeral application demos for tools I want to exist, such as menugen, llm-council, reader3, and HN time capsule.

With vibe coding, code has suddenly become free, ephemeral, malleable, and discardable after a single use. This shift will fundamentally terraform software engineering and redefine technical job descriptions.

Google's Gemini Nano "banana" represents one of the most significant, paradigm-shifting models of 2025.

If LLMs are the next major computing paradigm—analogous to the personal computers of the 1970s and 1980s—we should expect to see parallel evolutionary steps. We will see the equivalents of personal computing, microcontrollers (cognitive cores), and the internet (networks of agents).

In terms of user experience, "chatting" with an LLM in 2025 is still highly reminiscent of typing commands into a 1980s terminal console. Text is a highly efficient representation for computers and LLMs, but it is not the ideal format for humans. Reading large blocks of text is slow, linear, and cognitively effortful. Humans process information far more efficiently when it is presented visually and spatially—which is why the Graphical User Interface (GUI) was originally invented.

LLMs should communicate in our preferred visual format: through interactive web apps, diagrams, infographics, slides, whiteboards, and animations. Early versions of this are simple formatting languages like Markdown and emojis, which visually structure raw text with tables, bolding, lists, and headers. Gemini Nano "banana" represents the first step toward a native LLM GUI, where the model's capabilities in text generation, image rendering, and world knowledge are deeply integrated within the model weights to natively output rich visual layouts.

• The Shift to RLVR: The production stack has evolved. Reinforcement Learning from Verifiable Rewards (RLVR) has become the dominant driver of reasoning capabilities, shifting focus from raw pretraining compute to test-time "thinking" scaling laws.
• Jagged Minds over Biological Models: LLM capabilities do not mirror human development. They possess "jagged" profiles—genius-level capabilities in niche verifiable fields alongside extreme fragility—making traditional benchmarks highly vulnerable to gamification.
• Orchestration & Localhost Agents: Specialized applications (like Cursor) succeed by orchestrating complex DAGs of LLM calls, while tools like Claude Code highlight the massive friction reduction of running agents locally on localhost.
• The Software Dematerialization: "Vibe coding" has commoditized code creation, transforming software into a free, disposable, and highly malleable resource that can be generated dynamically via natural language.
• Visual Interfaces (LLM GUIs): Human-AI interaction is evolving past command-line-style text chat toward native, model-generated graphical user interfaces that process and display information spatially.

This article was cross-posted to my personal blog. For further thoughts on the future of AI, you can listen to my conversation on the Dwarkesh pod.