AI Coding H1 2026 Retrospective: Cursor, Claude Code, Codex Data

H1 2026 was the half AI coding stopped being a side experiment in most engineering organisations and became a default — Cursor, Claude Code, and Codex CLI all crossed the chasm into mainstream adoption, multi-agent workflows moved from demo to production, MCP consolidated as the connector standard, and observability + governance features started appearing inside the IDE rather than bolted on after the fact.

What changed is not the underlying model story — the frontier model cadence is its own quarterly retrospective. What changed is the shape of the developer surface: how teams actually use the tools, how the tools ship features, what the productivity numbers look like when measured honestly, and where pricing settled after a year of cost compression. The data below is a six-month look at that surface, drawn from vendor announcements, team adoption surveys, and the configurations we've been rolling out for clients.

This guide covers adoption rates across seven tools, the feature-shipping cadence that defined the half, productivity benchmarks measured against honest baselines, the pricing-tier shifts that mattered, the four trend lines that explain the half, and a calibrated projection for what H2 probably looks like for engineering teams planning rollouts now.

Retrospectives are easy to write badly. The temptation is to list every release announcement, count the version numbers, and call it a story. The harder and more useful framing is to ask what changed about the work itself — which teams reorganised around which capabilities, which patterns moved from experimental to production, and what the steady-state shape of the half looks like in hindsight.

By that test, H1 2026 is the cleanest inflection point we've seen since the original Copilot launch. The defining shift is not that the tools got better — though they did. The defining shift is that the cohort of engineering teams treating AI coding as background plumbing rather than a meeting-worthy experiment crossed from minority to majority. That is what "crossed the chasm" means in this context: the default question stopped being whether to roll out and became how.

Three signals confirm the inflection. First, the rollout conversations we have with clients changed shape — early-half calls were about pilot selection and seat counts; late-half calls are about governance, cost attribution, and which subagents to standardise. Second, the vendor roadmaps stopped competing on raw capability and started competing on enterprise readiness — audit logs, RBAC, MCP server registries, billing consolidation. Third, the productivity benchmarks normalised: the wild claims of the early days got replaced by measured 15–40% per-engineer hour reductions on the tasks AI coding actually helps with.

The rest of this retrospective is organised around the four questions a leadership team typically asks when planning H2: which tools are people actually using and at what intensity, what did the vendors ship that matters, what productivity numbers can we honestly expect, and what is the pricing reality after a year of compression. We close with the four trend lines that explain the half — and a calibrated view of what H2 will consolidate.

Adoption rarely settles into a single number. Different team archetypes adopt different tools, often in parallel, and the interesting story is not the average — it's the shape of the distribution. Across the seven tools we tracked in H1, engineering teams clustered into four archetypes that explain most of the rollout variance.

The archetypes below are drawn from a combination of vendor disclosures, the rollouts we've directly observed with clients, and the public adoption surveys that ran across H1. They are intentionally rough — the point is to give leaders a mental model for where their team probably sits, not to claim precision the underlying data can't support.

The headline read on the archetype distribution is that the market is meaningfully bifurcated between IDE-first and CLI-first cohorts, with the enterprise baseline pattern sitting alongside both as a procurement-driven third group. What the distribution does not show — and what we think matters for H2 planning — is that the IDE-first and CLI-first cohorts have started converging on workflow even while their primary surface differs. Cursor users increasingly run Claude Code in the integrated terminal; Claude Code users increasingly use Cursor or VS Code as the host. The terminal and the IDE are blending.

For teams choosing now, the practical move is to pick a primary surface based on the work that dominates your day-to-day, then layer the second tool deliberately rather than waiting for the tools to converge further. A backend platform team adopting Claude Code in the terminal will benefit from VS Code as the host for syntax highlighting and file navigation. A front-end product team adopting Cursor will benefit from a Claude Code terminal for repo-wide refactors that Composer is less suited to. The right rollout is rarely a single tool.

Vendors shipped a lot across H1. The pattern worth noticing is that the releases clustered around four themes rather than scattering across the surface — and the four themes overlap remarkably across Cursor, Claude Code, Codex CLI, and the adjacent tools. That convergence is itself a signal: when independent vendors arrive at the same feature set in the same half, the underlying product category is consolidating.

The four themes below are described in the order they crystallised across the half — multi-agent execution shipping first in late January, MCP standardisation reaching critical mass in March, skills and subagent libraries proliferating from March onwards, and observability + governance arriving as the late-half push that defines where H2 starts.

The single most consequential of the four themes for engineering leaders is the MCP consolidation. Before H1, every IDE-to-tool integration required a bespoke plugin or extension, with different auth flows, different schemas, and different maintenance burdens. After H1, MCP servers became the default connector — and the practical effect is that adding a new backing system to your AI coding setup went from a multi-week integration project to a one-line configuration change.

The skills-plus-subagents pattern compounded the consolidation. Once MCP made it cheap to wire connections, skills made it cheap to encode procedures over those connections, and subagents made it cheap to scope those procedures to least-privilege execution. The three ship together, and teams that adopted all three reported the largest productivity gains in the half. We cover the numbers in the next section.

For teams planning H2 rollouts, the operational read is that the feature set has stabilised enough to commit. The big primitives — multi-agent execution, MCP, skills, subagents, observability — are not going to be obsolete by Q3. They will be deepened, refined, and made more enterprise-ready, but the architectural shape is settled. That is the right environment in which to standardise — for a deeper dive on Claude Code specifically, see our Claude Code 1.3 deep dive.

Productivity claims in AI coding range from absurd to indefensible, and the gap between them is mostly down to how the baseline gets defined. The most honest framing we've seen across H1 is a triplet of measures — engineer-hours saved on tasks AI coding actually helps with, PR throughput on repo-scoped work, and defect rates on AI-assisted versus unassisted changes. The bars below are H1 medians from the rollouts we've observed, weighted toward teams that adopted at least three of the four feature themes from Section 03.

The bars to read most carefully are the two in the secondary colour. Defect rate is largely flat versus unassisted — slightly up on teams that skipped review discipline, slightly down on teams that invested in subagent-based pre-review. The headline "AI coding reduces bugs" claim is not supported by the H1 data we've seen; what is supported is that defect rate is roughly stable while throughput climbs meaningfully. That is still a strong business case, but it's a different business case than the one many rollout decks claim.

The other secondary bar — code review burden — is the cost most teams underestimate. AI-generated PRs are larger on average, touch more files, and require reviewers to understand context the original author didn't fully author themselves. The honest reading is that review burden rises 10–18% on AI-assisted PRs unless review discipline gets paired with the rollout. Teams that invested in AI-assisted review (subagent pre-review, automated PR summaries, lint gates) saw that number stay flat or fall; teams that didn't saw it climb.

For engineering leaders setting H2 OKRs, the conservative calibration is a 15–25% per-engineer hour reduction on AI-amenable work, paired with a flat or slightly elevated defect rate, and a 10–18% rise in review burden that requires a corresponding investment. Teams hitting 30–40% gains consistently are running a deliberate stack — multi-agent execution plus skills plus subagents plus governance — not simply "Cursor turned on for everyone."

Pricing shifted meaningfully across H1, but the headline number — list price per seat — moved less than the underlying value calculation. What changed more is the bundling: which features sit inside the base tier, which require the pro tier, and how usage-based pricing interacts with seat-based pricing. The matrix below is the decision framework we use with clients to navigate the tier landscape now.

The H1 pricing shift worth highlighting is that the Max-tier pattern emerged as the dominant mid-team rollout. The $200/month Max plans started as power-user oddities in January and ended the half as the obvious destination for engineering leaders and senior staff doing the bulk of agentic work. The mental model is straightforward: put your top quintile of engineers on Max, put everyone else on Pro, and let the productivity asymmetry justify the spend differential. The math works for almost any team that has measured its own throughput gains honestly.

The trend that did not happen in H1 — despite repeated predictions — is a price war. The list prices on Pro tiers held remarkably steady from January to May. What moved is what those tiers include: more requests per month, broader model access, and (selectively) governance features that used to live in business tiers. The signal is that vendors are competing on value per dollar rather than headline price, and that pattern looks likely to continue into H2.

Pull the threads from the prior sections together and four trend lines define H1 2026. They are not surprising individually — each was visible by Q1 — but the fact that they all consolidated within the same six-month window is the structural story of the half.

1. Multi-agent went mainstream. Background agents in Cursor, formalised subagents in Claude Code, and agent modes in Codex CLI moved multi-agent execution from experimental to default. The pattern we see in senior engineering teams: a primary interactive agent, one or two specialised subagents (code review, security audit, documentation), and the occasional one-shot background agent for long-running work. That stack is now ordinary.

2. MCP-as-standard consolidated.Before H1, connecting your AI coding tool to Supabase, Linear, Vercel, or Zoho required a vendor-specific plugin and a multi-week integration. After H1, it requires an MCP server entry. The implication for tool selection is that "does this tool speak MCP?" is now a meaningful filter — and almost every serious tool says yes.

3. Subagent + skill libraries compounded. The teams getting the largest productivity gains share a structural pattern: a library of skills encoding repeatable procedures, a roster of subagents enforcing least-privilege execution on those procedures, and an MCP layer wiring both to the systems-of-record. The compounding is real because each addition makes the others more valuable — more skills make subagents reach further, more subagents make MCP connections safer, more MCP connections make skills more powerful.

4. Observability + governance moved to the IDE. The late-half push was audit logs, cost dashboards, permission gates, and policy enforcement inside the IDE rather than as separate platforms. Teams previously assembled governance externally; H1 closed with vendors shipping it natively. H2 will accelerate the pattern.

For engineering leaders, the practical synthesis is that the shape of a senior AI coding rollout is now legible. It is not a single tool. It is a multi-agent execution model, plumbed through MCP, encoded in a skill library, scoped by subagent policy, and instrumented for audit and cost. Teams that built that stack across H1 are well-positioned for H2; teams still at the "Cursor turned on for everyone" stage have a visible playbook to follow.

Projections age badly, so the calibration here is deliberate: H1 was a phase change, and H2 reads more like a consolidation phase than another inflection. The new primitives — multi-agent, MCP, skills, observability — are not going to be replaced. They are going to be refined, deepened, and integrated. The interesting H2 questions are about scope, not category.

Vendor convergence continues.Cursor, Claude Code, and Codex CLI will keep adopting each other's distinguishing features. Background agents, MCP server registries, skill-style reusable procedures, and IDE-level observability are likely to be table stakes by Q4. The differentiation will move to ergonomics, governance depth, and which model partnerships unlock the best models at the best prices.

Governance becomes the buying decision. In H1, enterprise rollouts hinged on capability and licensing. In H2, we expect them to hinge on governance — audit log depth, cost-per-team attribution, policy expressiveness, and integration with corporate SSO and DLP. Vendors that nail governance will out-sell vendors that ship one more model partnership.

Productivity ranges tighten and lift modestly. The 15–40% range in Section 04 will probably tighten to roughly 20–35% with the bottom of the range lifting as average teams adopt the patterns the top quartile already uses. Defect rates and review-burden patterns will not change much without deliberate investment in review-side tooling, which is the H2 gap we expect to see closed.

Pricing stays mostly flat at list, value rises. Continued bundling of features into Pro tiers, with Max-tier adoption expanding from senior engineers to a broader cohort as the productivity case gets clearer. We do not expect a price war; we do expect the value-per-dollar gap between laggard vendors and leaders to widen.