This week's AI coding tool releases are about infrastructure, not headlines. Claude Code shipped three rapid-fire updates (2.1.260 through 2.1.263) that add a live diff panel, prompt-cache diagnostics, and a larger inline output window. VS Code 1.135 introduced a Rubber Duck review agent and a multi-window Agent Host Protocol. Meanwhile, GitHub Copilot quietly became an Anthropic distribution channel, now running Claude Fable 5.1 natively. The theme: AI assistants are graduating from chatbots to first-class IDE subsystems, and the engineering orgs that treat them that way now will have a structural advantage by Q4.

Anthropic shipped four patch releases this week. One is a pure bug-fix drop (2.1.263). The other three carry real workflow changes.

The highest-impact addition is the live diff panel that opens beside the conversation in fullscreen mode, toggled with `/diff`. As Claude edits your files, you see uncommitted changes in real time without switching windows or running `git diff` manually.

Why does this matter more than it sounds? It collapses the review loop. In a traditional agentic session, you'd delegate a task, wait, then open a diff tool to understand what changed. Now the delta is visible continuously. That changes the cognitive model from "delegate and review later" to "pair-program with a fast collaborator you can watch." For teams that have been hesitant to let AI agents touch production-adjacent code, this visibility lowers the risk threshold considerably. Your engineers aren't flying blind.

This one is underrated in every roundup I've seen. Claude Code now surfaces an estimated cause for prompt-cache misses in the `/cost` command and the status line. The reported culprits: changes to tool definitions, changes to the system prompt, or sessions idling past the cache TTL.

Here's the operational implication: prompt-cache misses aren't just a latency issue, they're a cost issue. If your team is running Claude Code at scale across dozens of engineers, unexpected cache misses can meaningfully inflate your API spend without anyone noticing until the invoice arrives. This diagnostic surface gives you the visibility to debug that. If your `/cost` output is showing repeated cache misses due to tool definition churn, that's an actionable signal: stabilize your plugin configuration and stop rotating tool schemas mid-session.

Two more from the 2.1.261 release:

VS Code 1.135 introduced `/rubber-duck` in agent sessions. It invokes a secondary model to review the primary coding agent's plans, code, and tests before they're committed. The name is playful but the mechanism is serious. This is automated, multi-model review inside the IDE, not a post-hoc code review step in your PR workflow. The agent explains its reasoning, and a second model pushes back. For teams using AI agents to write production code autonomously, this is meaningful risk mitigation baked into the session itself rather than bolted on afterward. It also signals where the tooling is headed: toward agent-on-agent review as a standard development primitive, not a premium feature. Teams that start building their workflows around this now will have muscle memory when it becomes table stakes in 12 months.

VS Code 1.135 also shipped Agent Host Protocol, which lets multiple VS Code windows connect to the same agent session. More importantly, it surfaces work started in external agents, specifically GitHub Copilot and Claude Code, inside VS Code. This is the quiet convergence story of the week. A developer can start a task in Claude Code's terminal interface, switch to VS Code, and see that same session's state. The wall between tools is dissolving at the workflow level, not just the API level. If your team uses a mix of Claude Code and Copilot (and most do at this point), the Agent Host Protocol is the connective tissue that makes that mix feel coherent rather than chaotic.

GitHub shipped several updates this month that compound into a significant posture shift. Claude Fable 5.1 is now generally available inside GitHub Copilot as of early September. This is cross-vendor model interoperability at production scale. Copilot is no longer a single-model product, it's a runtime that routes work to the best available model. That's a fundamentally different category of tool than what shipped two years ago. Copilot Code Review defaults to "Balanced" effort on September 28. Previously "Lite" by default, the shift means more thorough review passes for every PR, automatically. Two other changes arrived alongside this: the 20,000-line review cap is removed, and bot-authored pull requests (including those generated by Copilot itself) are now reviewed. That last point is significant. AI-written code will now be reviewed by AI by default. The human-in-the-loop is still there, but the first pass is automated end-to-end. Agent Plugins 1.0 reached general availability across VS Code, Copilot CLI, and the Copilot app, with Slack and Teams integrations added as well.

No single tool wins across every dimension. The clear signal: you need more than one.

Most roundups will treat the diff panel as a UX win and move on. That misses the structural shift. Look at what actually shipped across all three tools: cache diagnostics, output limits, org policy surfaces, multi-window agent sessions, secondary review models, bot PR review. None of these are model improvements. All of them are AI-agent runtime infrastructure: the tooling that makes AI agents governable, observable, and composable inside real engineering organizations.

The model quality arms race is still running, but it is no longer the only front. The next competitive battleground is who builds the most reliable, governable, cost-observable AI-agent runtime inside the tools your engineers already use. This week's releases are all moves on that board. For engineering leaders, this matters for hiring and team design. The engineers who thrive in this environment are not the ones who can prompt an AI well in isolation. They're the ones who can operate within a multi-agent, multi-tool workflow: understanding cache behavior, configuring org policies, interpreting agent-on-agent review output, and reading cost signals. That's a new skill profile, and it's not evenly distributed across the candidate pool.

The direction is clear: AI agents are becoming infrastructure, not tools. The engineering leaders who govern them like infrastructure, with policies, observability, and cost controls, will get the compounding benefits. The ones still treating them as experimental productivity hacks will spend next year catching up.