2025 LLM Year in Review

unnamed

2025 has been a strong and eventful year of progress in Large Language Models (LLMs). Rather than a linear continuation of old trends, this year was defined by critical paradigm changes that fundamentally altered the AI landscape. From new training architectures to novel software interfaces, these developments have reshaped how we conceptualize and build with AI.

At the start of 2025, the standard LLM production stack across major labs consisted of three established, sequential steps:

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

In 2025, Reinforcement Learning from Verifiable Rewards (RLVR) emerged as the de facto fourth stage of this pipeline. By training models against automatically verifiable, non-gameable environments (such as mathematical proofs or code execution), LLMs spontaneously develop strategies that look like human "reasoning."

[Pretraining] ──> [Supervised Finetuning (SFT)] ──> [RLHF] ──> [RLVR (New in 2025)]

During RLVR, models learn to break down problems into intermediate calculations and iteratively correct their course when encountering errors (as detailed in the DeepSeek R1 paper). These reasoning traces are incredibly difficult to teach via SFT alone because it is unclear what an "optimal" intermediate thought process looks like for a neural network—the LLM must discover what works best through direct optimization against objective rewards.

Unlike SFT and RLHF, which are computationally cheap finetuning steps, RLVR allows for much longer optimization runs. In 2025, this paradigm proved to be highly efficient in terms of capability-per-dollar, ultimately consuming compute budgets originally earmarked for traditional pretraining. Consequently, 2025 saw models of similar parameter sizes achieving dramatic capability jumps purely through longer reinforcement learning runs.

Furthermore, RLVR introduced a new scaling law: test-time compute. By allowing models to generate longer reasoning traces and increasing their "thinking time," developers gained a direct lever to scale model capability at runtime. While OpenAI's o1 (late 2024) served as the initial proof of concept, the early 2025 release of o3 marked the clear industry inflection point where this capability became undeniable.

In 2025, the industry began to internalize the actual "shape" of LLM capabilities. Rather than building "evolving animals," we are "summoning ghosts."

Because the entire LLM stack—from neural architectures and training data to optimization pressures—is fundamentally alien to biological evolution, we should not expect these models to behave like human minds.

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

As a result, LLM capabilities are highly jagged. A model can simultaneously behave like a genius polymath in complex domains and a cognitively challenged grade-schooler in simple tasks, remaining highly susceptible to basic jailbreaks and data exfiltration tricks.

G6zymj4a0AMNJkJ Human intelligence (blue) vs. AI intelligence (red) showcases distinct shapes of jaggedness.

This realization has led to widespread skepticism toward traditional evaluation benchmarks in 2025. Because benchmarks are, by definition, verifiable environments, they are immediately susceptible to RLVR optimizations and synthetic data generation. In a process dubbed "benchmaxxing," labs actively construct environments adjacent to these benchmarks, growing targeted "jaggies" to cover the test sets.

Training on the test set has officially become a new art form, prompting the question: What does it look like to crush all the benchmarks but still not get AGI?

For a deeper dive into these conceptual shifts, explore these essays:

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

The meteoric rise of the Cursor editor in 2025 demonstrated the immense value of a thick, domain-specific application layer built on top of foundation models, sparking a gold rush for "Cursor for X" startups.

As outlined in Andrej Karpathy's Y Combinator talk (available via this transcript and video below), successful LLM apps do not simply pass-through API keys. Instead, they handle complex orchestration under the hood:

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

Specifically, these advanced applications:

1. Perform sophisticated context engineering to surface relevant data.
2. Orchestrate multiple LLM calls structured into complex Directed Acyclic Graphs (DAGs), balancing performance and cost.
3. Provide tailored, highly interactive graphical user interfaces (GUIs).
4. Offer an "autonomy slider" allowing users to choose between copilot and agentic modes.

While some debate whether foundation model labs will eventually sherlock these tools, there remains a massive opportunity for dedicated applications. Foundation labs will likely continue to graduate highly capable "college student" models, while specialized LLM applications will organize, fine-tune, and orchestrate teams of these models into elite, domain-specific professionals by supplying private data, actuators, and localized feedback loops.

Claude Code (CC) emerged as the first truly convincing demonstration of a developer agent. It seamlessly strings together tool use, environment execution, and multi-step reasoning to solve complex software engineering tasks.

Crucially, Claude Code operates directly on your local machine (localhost), accessing your actual environment, local data, tools, and configurations.

[Cloud-hosted Sandboxes] (OpenAI's early focus) vs. [Localhost Environment] (Claude Code)
   └── Isolated containers                           └── Instant low-latency execution
   └── Limited context & secrets                     └── Full access to local data, tools, & config

While running massive agent swarms in the cloud remains a long-term goal, running agents locally makes far more sense in our current "slow takeoff" era of jagged capabilities. By executing on the developer's pre-configured computer, Claude Code bypasses the latency, context isolation, and setup barriers of cloud containers. Packaged as a minimal CLI, Claude Code feels less like a traditional search engine or remote chatbot and more like a helpful local entity living directly inside your development workspace.

In 2025, LLMs crossed a major capability threshold, allowing people to build complex, production-grade applications using pure English without ever looking at the underlying source code—a phenomenon now widely known as "vibe coding."

The term, coined in a shower-of-thoughts tweet, quickly became a defining concept of the year. This shift demonstrates how LLMs flip the script on traditional technology diffusion, as discussed in Power to the people: How LLMs flip the script on technology diffusion. Unlike prior technologies that primarily empowered large institutions, LLMs provide the greatest relative leverage to individuals and non-professional creators.

However, vibe coding is not just for novices; it also allows seasoned professionals to write software that previously would have been too time-consuming to justify.

• Custom Rust Tokenizer: Built for nanochat to deliver a highly efficient, custom BPE tokenizer without needing to manually learn Rust at a system level.
• menugen: An interactive restaurant menu generator.
• llm-council: A multi-agent consensus engine.
• reader3: A clean web-content extractor.
• hn-time-capsule: A temporal interface for Hacker News.

Vibe coding treats code as something cheap, malleable, and discardable. When creating a single-use script or debugging an ephemeral issue is practically free, our relationship with software development undergoes a permanent shift.

Google's Gemini Nano (specifically the "banana" iteration) highlighted a massive evolution in how humans interact with models.

If LLMs are the next foundational computing paradigm (similar to the personal computers of the 1970s and 80s), then current chat interfaces are the equivalent of early command-line consoles. While text is the native language of computing systems, it is highly inefficient for human consumption. Humans process information far faster when it is presented visually and spatially.

[Console / Command Line]  ──>  [Graphical User Interface (GUI)]
      (Text Chat)                    (Visual, Spatial, Interactive)

Just as traditional operating systems evolved from DOS to Windows and Macintosh, LLM interactions must shift toward rich, spatial, and visual interfaces. Early precursors include Markdown tables, emojis, and basic UI blocks.

Models like Gemini Nano point to a future where text generation, image generation, and deep world knowledge are natively integrated within the model weights. Instead of outputting walls of text, these cognitive engines can directly communicate using custom interfaces, infographics, dynamic slides, live whiteboards, and interactive web apps tailored instantly to the user's cognitive needs.

• RLVR is the New Training Standard: Transitioning from human feedback to automated, verifiable reward systems has unlocked deep reasoning traces and test-time scaling.
• Intelligence is Non-Linear and "Jagged": LLMs do not scale like biological animals. They are spiky, brilliant polymaths in some domains and fragile, easily jailbroken systems in others, rendering traditional static benchmarks increasingly obsolete.
• The Agent UX is Moving Local: Products like Claude Code show that running agentic workflows directly on a user's local machine (localhost) provides a much more intuitive, low-latency, and context-rich environment than isolated cloud containers.
• Software has Become Ephemeral: "Vibe coding" has commoditized software creation. Writing, deploying, and discarding custom applications on the fly is now a viable workflow for both non-programmers and professional developers.
• We are Heading Toward the LLM GUI: Chatting in plain text is the command line of the AI era. The future of AI interaction lies in native, multimodal model outputs like Gemini Nano that speak to us visually and spatially.

As discussed on the Dwarkesh Podcast, we are simultaneously on a path of hyper-rapid progress while still having an immense amount of foundational engineering left to do. The industry has realized less than 10% of the potential of our current models—the design space is wide open.