The Capability Inflection Point

“The future is already here — it’s just not evenly distributed.” — William Gibson

Learning Objectives

By the end of this module, you will be able to:

Identify the specific capabilities that changed in late 2025
Explain why these changes enable qualitatively different workflows
Distinguish between incremental improvement and capability thresholds
Recognize agentic AI as the defining shift of this moment
Calibrate your expectations for what AI can and cannot do now

Why This Module Exists

If you’d taken this course in early 2024, we’d teach you to use AI as a sophisticated autocomplete — helpful for drafts, dangerous for anything complex.

That advice is now outdated.

Something changed in late 2025. Not just “models got better” — they crossed thresholds that enable fundamentally different ways of working. Understanding what changed helps you use these tools appropriately, neither underestimating nor overestimating them.

The November-December 2025 Shift

Two major releases marked the inflection point:

Claude Opus 4.5 (Anthropic, November 2025) GPT-5.2 (OpenAI, December 2025)

These weren’t just version bumps. They represented capability thresholds being crossed:

What Actually Changed

Capability	Before Late 2025	After Late 2025
Context coherence	Quality degraded after ~30K tokens, especially middle content	Maintains coherence across 200K+ tokens
Multi-step reasoning	Failed on 5+ step problems	Handles 10-20 step chains reliably
Tool use	Unreliable, required hand-holding	Significantly more reliable autonomous tool execution
Code generation	Single files, simple functions	Multi-file projects, complex architectures
Self-correction	Rare, usually made things worse	Can identify and fix own errors

The Numbers That Matter

Cursor’s agent swarm built a functional web browser from scratch — over 1 million lines of code across multiple coordinated agents. (This was a capability demonstration, not production software, but it showed what’s now possible.)
Context windows expanded to 200K-1M tokens while maintaining quality (not just accepting more input, but actually using it)
Tool calling reliability improved dramatically — tasks that previously required constant human intervention now complete autonomously

These observations come from practitioners like Simon Willison and others who document real-world AI usage. The field moves fast; specific numbers become outdated, but the qualitative shift is real.

The Threshold Concept

Why do we call this an “inflection point” rather than just “improvement”?

Incremental vs. Threshold Change

Incremental improvement: A car that goes 5% faster is still a car. You use it the same way.

Threshold crossing: A car that can now fly isn’t just faster — it changes what’s possible. You plan trips differently.

The late 2025 models crossed thresholds:

Before: AI could help you write a function. You had to architect, integrate, test.

After: AI can build and test a feature while you specify requirements. You can focus on what to build, not how to build every piece.

This isn’t about AI replacing humans — it’s about AI handling more of the mechanical work so humans can focus on judgment work.

The Five Key Capabilities

Let’s examine each capability shift in detail:

1. Extended Coherent Context

What it means: The model can “hold in mind” an entire codebase, long document, or extended conversation without losing track.

Before: Give the model 50K tokens of context, and information in the middle would be effectively ignored. Long conversations would drift as the model “forgot” earlier content.

After: A 200K token context actually works. The model references information from early in the context appropriately. Conversations remain coherent over hundreds of exchanges.

Practical impact: You can paste an entire codebase and ask questions about it. You can have day-long working sessions without starting over. You can provide extensive background that the model actually uses.

2. Reliable Multi-Step Reasoning

What it means: The model can work through complex problems requiring many sequential steps.

Before: Give the model a problem requiring 7 steps, and it would often fail at step 4 or 5 — either skipping steps, making logical errors, or losing track of the goal.

After: Problems requiring 10-20 steps are handled reliably. The model maintains goal orientation and tracks intermediate state.

Practical impact: Complex debugging, architectural planning, multi-stage transformations — tasks that required human oversight at each step can now be delegated.

3. Autonomous Tool Use

What it means: The model can use tools (file systems, APIs, terminals, browsers) reliably without human intervention at each step.

Before: Tool use was fragile. The model would call tools incorrectly, fail to interpret results, or get stuck in loops. Human supervision was required.

After: Tools work. The model reads files, executes code, checks results, and iterates — autonomously. It recognizes errors and adjusts.

Practical impact: This enables agents — AI that doesn’t just answer questions but performs tasks. Claude Code, Cursor Agent, and similar tools became practical because the underlying models became reliable.

4. Complex Code Generation

What it means: The model can generate not just functions, but entire systems with multiple interacting components.

Before: AI could write a function, maybe a class. Anything requiring coordination across multiple files, understanding of architecture, or consistent style across a codebase was unreliable.

After: Multi-file projects with consistent architecture. The model understands how pieces fit together, maintains conventions, and generates code that actually integrates.

Practical impact: You can describe a feature and get a working implementation across multiple files — routes, models, views, tests. The 1M-line browser built by Cursor’s agents is the extreme example.

5. Self-Correction

What it means: The model can recognize when it made an error and fix it without human intervention.

Before: If the model made a mistake, pointing it out often made things worse. It would apologize, then make a different mistake. Or defend the original error.

After: The model tests its own output, recognizes failures, and iterates toward working solutions. Not perfectly — but reliably enough to be useful.

Practical impact: You can set the model on a task and trust it to work through initial failures rather than hand-holding every step.

What This Enables: Agentic AI

The combination of these capabilities enables something qualitatively new: agentic AI.

What “Agentic” Means

An agent is AI that:

Takes a goal, not just a prompt
Plans steps to achieve the goal
Executes those steps using tools
Monitors results and adjusts
Continues until the goal is achieved (or determines it can’t be)

This is different from chat-style interaction where you prompt → get response → prompt again.

The Agent Loop

┌─────────────────────────────────────────────────────┐
│                                                     │
│   Goal: "Add user authentication to this app"      │
│                        │                            │
│                        ▼                            │
│   ┌─────────────────────────────────────────┐      │
│   │ PLAN: Identify what exists, design      │      │
│   │       approach, list implementation     │      │
│   │       steps                             │      │
│   └─────────────────────────────────────────┘      │
│                        │                            │
│                        ▼                            │
│   ┌─────────────────────────────────────────┐      │
│   │ EXECUTE: Read files, write code,        │      │
│   │          run tests, check results       │      │
│   └─────────────────────────────────────────┘      │
│                        │                            │
│              ┌─────────┴─────────┐                 │
│              ▼                   ▼                  │
│         [Success]            [Failure]             │
│              │                   │                  │
│              ▼                   ▼                  │
│          Complete           Diagnose &             │
│                             Retry                   │
│                                                     │
└─────────────────────────────────────────────────────┘

Tools That Use This

You’ll encounter agentic AI in:

Claude Code: Anthropic’s CLI agent that reads your codebase, makes changes, runs tests
Cursor Agent: IDE-integrated agent that implements features across files
GitHub Copilot Workspace: Agent for planning and implementing GitHub issues
Claude Cowork (2026): Agent for general office tasks, not just coding

These tools are practical because the underlying models crossed the capability thresholds.

Calibrating Your Expectations

Understanding the inflection point helps you calibrate what to expect.

What’s Now Realistic

✓ “Build a REST API with these endpoints and tests” ✓ “Refactor this module to use the new pattern, updating all call sites” ✓ “Debug why this test is failing and fix it” ✓ “Add this feature, following the existing code conventions” ✓ “Review this PR and identify potential issues”

What’s Still Unreliable

✗ “Build me a startup” (too vague, requires judgment about what to build) ✗ “Make this code perfect” (no clear success criteria) ✗ “Figure out what users want” (requires real-world investigation) ✗ Tasks requiring information the model doesn’t have (private data, recent events) ✗ Tasks where being 95% right isn’t good enough (security-critical, legally binding)

The Key Insight

The inflection point didn’t make AI intelligent — it made AI reliable enough to be useful for complex tasks.

There’s still no understanding, no judgment, no accountability. But for tasks that are:

Well-specified
Decomposable into steps
Verifiable (you can check if it worked)

…current AI can handle them with minimal supervision.

What Didn’t Change

Lest we get carried away, here’s what’s still true:

Costs Increased Too

These powerful models aren’t free. More capability means:

Higher API costs: The most capable models cost more per token
More compute: Agentic tasks that run for hours use many tokens
Subscription tiers: Advanced features often require paid plans

For this program, costs are handled for you. But in the real world, the economics of AI usage matter. Powerful doesn’t mean cheap.

Fundamental Limitations Remain

Hallucinations: Models still confidently state falsehoods. Verification is still essential.
Knowledge cutoffs: Models don’t know recent events unless told.
No real understanding: It’s still pattern matching, not comprehension.
Brittleness: Edge cases and unusual situations still cause failures.
Security risks: Prompt injection and other vulnerabilities remain unsolved (Module 10).

Human Judgment Is Still Required

The models got better at execution, not judgment. You still need to:

Decide what to build
Evaluate whether the output is correct
Make ethical and strategic choices
Verify security implications
Take responsibility for the result

This is what Simon Willison calls “vibe engineering” — the professional approach to AI collaboration that we’ll explore in Module 04. It means using AI power while maintaining human judgment and accountability.

Practical Exercise: Experiencing the Difference

Exercise 1: Context Coherence Test

Start a conversation with Claude
Paste a substantial document (3-5 pages of text)
Ask questions about specific details from different parts
Notice: the model references information from throughout, not just the beginning/end

Exercise 2: Multi-Step Task

Give Claude Code (or Cursor) a moderately complex task: “Create a simple to-do app with add, complete, and delete functionality”
Watch how it:
- Plans the approach
- Creates multiple files
- Tests its own code
- Fixes errors it encounters
Compare: How would this have worked with 2023-era tools?

Exercise 3: The Judgment Boundary

Ask an agent: “What feature should I build next for my app?”
Notice: It can suggest ideas, but it can’t actually know what your users need
Reflection: Where does AI capability end and human judgment begin?

Key Insights

Concept	Implication
Threshold vs. incremental	Late 2025 models enable different workflows, not just faster workflows
Extended context	You can work with entire codebases, not just snippets
Reliable tool use	Agents are now practical — AI that acts, not just advises
Agentic AI	Give goals, not just prompts; AI handles execution
Limitations persist	Hallucinations, judgment, security — still your responsibility

Connection to What’s Next

Now you understand what’s possible with current tools:

Module 03: Goes deeper on capabilities and limitations — when to trust, when to verify
Module 04: Your first hands-on session applying these capabilities
Module 10: The security implications of agentic AI (must-read before using agents)

The tools you’ll use in this program represent the current frontier. They’re powerful. They’re imperfect. Learning to work with them effectively is the skill we’re here to build.

Reflection Questions

The inflection point made certain tasks dramatically easier. What tasks in your own experience might now be approachable that weren’t before?
“Reliable enough to be useful” is different from “reliable.” When does 95% reliability matter, and when is it insufficient?
The 1-million-line browser was built by AI agents. What do you think human engineers contributed that the AI couldn’t provide?