Something interesting happened in the AI coding space recently. Claude Code, Anthropic’s terminal-based coding assistant, jumped from its 1.x roots to a genuine 2.x architecture. The version number understates the change.

What actually shifted? Three things matter.

---

---

Agents Became Teams

The original Claude Code worked like a single consultant: you ask, it reads code, it edits, repeat. The 2.x series introduced multi-agent collaboration. You can now spin up background agents that work in parallel, hand off tasks between specialized agents, and isolate risky work in git worktrees that don’t touch your main branch.

This sounds like enterprise-speak until you actually use it. Debugging a nasty race condition last week, I had one agent tracing the call graph while another searched for similar patterns in the codebase and a third monitored the test runner. Three perspectives, one context window coordinating them. The cognitive load shifted from “track all this in my head” to “review what they found.”

---

Skills Became Composable

Skills are the Claude Code equivalent of plugins: packaged instructions that extend the assistant’s capabilities. Previously, you wrote them, you invoked them, done. Now they hot-reload, nest inside each other, fork their own subagent contexts, and expose directory variables for templating.

The practical effect: I wrote a “gemini” skill that wraps Google’s API for image generation and code review. Writing it took maybe thirty minutes. Invoking it with /gemini analyze this function now spawns a focused subagent, sends the code to Gemini, captures the response, and files it in a memory directory without polluting my main conversation. The skill doesn’t know about my project structure; it just does its job and returns.

Composition was the missing piece. Individual skills were useful. Skills that call other skills, that spawn agents, that pipe results: that’s infrastructure.

---

Memory Got Real

Context windows in LLMs are famously finite. Hit the limit and older messages vanish. Claude Code’s answer is auto-memory: the assistant now writes important facts to persistent files between sessions. Forgot what you discussed three days ago? Claude didn’t.

This combines with partial compaction (manually summarizing older conversation turns) and session resume (picking up exactly where you left off with 68% less memory overhead). The result is something approaching genuine continuity across coding sessions.

---

What Doesn’t Work Yet

The agent teams feature requires an environment flag to enable. It’s not hidden, but it’s not default either. Anthropic is being cautious: multi-agent systems are notoriously hard to debug when they go sideways.

Voice input added ten languages, but speech-to-code still has recognition errors that need manual cleanup. And while VS Code integration exists, the terminal experience remains primary. If you live in VS Code, expect some friction.

---

The Larger Pattern

What Claude Code 2.x signals matters more than the feature list. Anthropic is betting that AI coding assistants evolve toward orchestration: not smarter single models, but coordinated systems of models with persistent memory, composable skills, and parallelized workflows.

That’s a different bet than “make the model bigger.” It’s an architecture bet. Whether it pays off depends on whether the coordination overhead is worth the capability gains.

Early returns: for complex, multi-file refactoring tasks, absolutely. For quick one-liners, probably overkill.

The assistant grew up. Now we get to figure out what to build with it.