3 Eight Trends Defining How Software Gets Built in 2026
3.1 The Year Software Became Agentic
At the start of 2026, Anthropic published a comprehensive analysis of the eight trends reshaping how software gets built. The report, grounded in data from thousands of organizations using Claude in production, painted a picture of an industry in the middle of a fundamental shift: coding agents were no longer tools that completed your lines — they were collaborators that took on entire tasks, owned design decisions, and shipped code.
What made the report notable was not the optimism but the specificity. Rather than declaring that “AI changes everything,” it quantified exactly how much, for whom, and where the gaps remained. Developers were using AI in roughly 60% of their work, but they “fully delegated” only 0–20% of tasks. That gap — between assistance and delegation — defined the frontier for the year.
This chapter walks through all eight trends, organized into three tiers: foundation trends that established the baseline, capability trends that expanded what was possible, and impact trends that showed the real-world consequences.
3.2 The Central Data Point: 60% Usage, 0–20% Delegation
Before diving into individual trends, it is worth dwelling on the headline statistic. Across the organizations surveyed, developers reported that AI was involved in approximately 60% of their daily work — answering questions, generating boilerplate, writing tests, reviewing diffs, and debugging. But when asked what fraction of tasks they fully delegated to an agent — handing over the entire task and accepting the output with minimal edits — the number was between 0% and 20%, varying by team and task complexity.
| Metric | Value | Implication |
|---|---|---|
| AI involvement in daily work | ~60% | AI is ubiquitous in the workflow |
| Tasks fully delegated | 0–20% | Trust and verification lag behind usage |
| Gap to close | 40–60 points | The frontier of progress |
The gap between using AI and trusting AI to own a task is the single most important variable in agentic coding. Every product decision, every capability investment, and every organizational change in 2026 was aimed at narrowing it.
3.3 Tier 1: Foundation Trends
3.3.1 Trend 1 — Coding Agents Become Collaborators
The first and most foundational trend was the shift from autocomplete to collaboration. In 2025, the dominant interaction pattern was “human writes, AI completes.” By early 2026, the pattern had inverted for many tasks: the agent scoped the work, explored the codebase, proposed an approach, and the human reviewed and approved.
This shift required three things to happen simultaneously:
- Longer context windows so agents could hold an entire codebase in mind.
- Tool use so agents could run commands, read files, and verify their own work.
- Trust mechanisms — checkpoints, diffs, and approval flows — so humans could intervene at the right moments.
The result was a qualitative change in how developers described their work. “Writing code” increasingly meant “directing an agent that writes code,” with the human acting as a senior reviewer and architect.
3.3.2 Trend 2 — Trust and Oversight Become First-Class Problems
As delegation increased, so did the need for oversight. The second foundation trend was the recognition that human-agent oversight needed to be designed, not improvised. Organizations began adopting explicit patterns:
- Checkpoint workflows where agents paused for human review at defined stages.
- Adversarial review where a second agent (or human) actively tried to find problems in the first agent’s output.
- Observable agent behavior — logs, traces, and diffs that made it possible to understand what an agent did and why.
The insight was that trust is not binary (you either trust the agent or you don’t) but graded and task-specific. A team might fully trust an agent to write unit tests while requiring human review for any change to authentication logic.
3.4 Tier 2: Capability Trends
3.4.1 Trend 3 — Multi-Agent Coordination
The third trend was the rise of multi-agent coordination. As tasks grew larger than any single agent could handle in one context, organizations began orchestrating teams of agents — sometimes dozens or hundreds working in parallel.
The patterns that emerged included:
- Fan-out and synthesize: one agent splits a task into subtasks, each handled by a specialist, and a synthesizer merges results.
- Adversarial verification: one agent produces work, another tries to break it.
- Classifier routing: a router agent inspects each incoming task and sends it to the right specialist.
Multi-agent coordination is most valuable when subtasks are genuinely independent. If agents need to coordinate tightly, the overhead of passing context between them often exceeds the benefit. Use agent teams for parallelizable work, not for sequential pipelines.
This trend directly motivated later products like dynamic workflows in Claude Code (Chapter 2) and multiagent orchestration in Managed Agents (Chapter 13).
3.4.2 Trend 4 — Agents Extend Beyond Engineering
The fourth trend was geographic, in the organizational sense: agentic coding began spreading beyond the engineering team. Product managers used agents to write specs and prototypes. Designers used them to generate and iterate on component variations. Data scientists used them to build and validate pipelines.
The implication was that the tools and guardrails built for engineers needed to generalize. A product manager does not want to read a git diff; they want a summary of what changed and why. A designer does not want a test suite; they want a visual preview. This drove investment in output styles and surface-appropriate interfaces — themes that recurred throughout 2026.
3.4.3 Trend 5 — Security Embedded From the Start
The fifth trend was the embedding of security into the agentic workflow from the very beginning, rather than as a final-stage gate. In a traditional SDLC, security review happened near the end. In an agentic SDLC, where code is generated and shipped at machine speed, that model breaks: by the time a human reviews security, hundreds of changes have already landed.
The new approach treated security as a continuous, automated property:
- Agents ran security scans on their own output before presenting it.
- Hooks enforced policies deterministically (e.g., “no secrets in committed code”).
- Sandboxing limited what agents could touch.
Anthropic’s own experience — where Claude authored a significant majority of merged code — demonstrated that security could keep pace, but only if it was designed into the system rather than bolted on.
3.5 Tier 3: Impact Trends
3.5.1 Trend 6 — Measurable Productivity Gains
The sixth trend was the arrival of hard, credible data on productivity gains. Early claims about AI coding tools were often anecdotal or self-reported. By early 2026, organizations had been running agentic workflows long enough to measure outcomes rigorously.
The report highlighted several case studies:
| Organization | Outcome | Metric |
|---|---|---|
| Rakuten | Fine-tuning vLLM with near-perfect accuracy | 99.9% accuracy in vLLM |
| TELUS | Deployed AI solutions at scale | 13,000 AI solutions, 500,000 hours saved |
| Zapier | Near-universal adoption internally | 89% AI adoption among engineers |
These were not pilots or proofs of concept — they were production deployments with measurable business impact. TELUS’s 500,000 hours saved, in particular, illustrated that the gains compound: once an organization builds the infrastructure to deploy one AI solution, the marginal cost of the next is far lower.
3.5.2 Trend 7 — Large-Scale Migrations Become Routine
The seventh trend was the normalization of large-scale, agent-driven migrations. Tasks that would have taken a human team months — porting a codebase between languages, upgrading a major framework, refactoring a monolith into services — were being completed in days or weeks with agent orchestration.
This was enabled directly by the multi-agent coordination trend. A migration that touches 10,000 files can be parallelized across 100 agents, each handling 100 files, with a synthesizer resolving conflicts. The bottleneck shifted from doing the work to defining the transformation rules and verifying the results.
3.5.3 Trend 8 — The Skills Gap and the Reskilling Imperative
The final trend was the recognition of a skills gap — not in coding, but in agent direction and oversight. The most valuable engineers were no longer the fastest typists or the deepest framework experts. They were the ones who could decompose a problem for an agent, write clear acceptance criteria, review agent output critically, and design workflows that leveraged parallelism.
Organizations began investing in training programs, and a new set of best practices emerged around prompt design, context engineering, and verification — practices that would be codified later in the year in posts about context engineering (Chapter 8) and steering (Chapter 9).
3.6 The Four Areas to Watch
Looking ahead from the January vantage point, the report identified four areas where progress would be most consequential for the rest of 2026:
- Multi-agent coordination — better orchestration primitives, shared state, and conflict resolution.
- Human-agent oversight — richer observability, graded trust, and review tooling.
- Extending agentic coding beyond engineering — making agents useful for non-engineers.
- Embedding security from the start — continuous, automated, and sandboxed.
Each of these four areas became the seed of major product investments over the following months, as the rest of this book documents.
3.7 Case Study Deep Dives
3.7.1 Rakuten: Fine-Tuning for Accuracy
Rakuten’s achievement of 99.9% accuracy in vLLM demonstrated that domain-specific fine-tuning, combined with agentic workflows, could reach reliability levels suitable for production. The key was not just model quality but the verification loop — agents that checked their own outputs against ground truth and iterated until the standard was met.
3.7.2 TELUS: Scale Through Infrastructure
TELUS’s deployment of 13,000 AI solutions — saving an estimated 500,000 hours — illustrated the power of building reusable agent infrastructure. Rather than treating each AI use case as a bespoke project, TELUS invested in a platform that let business units spin up agents with shared governance, monitoring, and security.
3.7.3 Zapier: Internal Adoption
Zapier’s 89% AI adoption rate among its engineers showed what happens when a tool crosses the chasm from optional to expected. At that level of adoption, the question stops being “should we use AI?” and becomes “how do we use it well?” — which drove Zapier to develop internal best practices for prompting, review, and workflow design.
3.8 Understanding the Delegation Gap
The 60% usage / 0–20% delegation statistic deserves deeper analysis because it drives so much of the agentic coding narrative. Understanding why the gap exists is essential to closing it.
3.8.1 Why Usage Outpaces Delegation
AI is used in ~60% of work because the bar for usage is low: any time an AI helps complete a line, suggests a function name, or answers a question, that’s “usage.” The bar for delegation — handing over an entire task and accepting the output — is much higher. Delegation requires trust, which requires verification, and verification is expensive when the output is complex.
The gap narrows in specific domains where verification is cheap. A developer might fully delegate writing unit tests because tests are self-verifying (they pass or fail). They might fully delegate formatting code because formatting is deterministic (it’s right or wrong). But they won’t fully delegate designing an API because “is this API well-designed?” is a subjective judgment that requires expert review.
3.8.2 What Closes the Gap
The report identified several factors that were closing the delegation gap:
- Better verification tooling — automated tests, linters, and adversarial review make it cheaper to verify agent output, raising the delegation threshold.
- Clearer acceptance criteria — when “done” is unambiguous, delegation is safer because the agent can self-check.
- Trust calibration — organizations learning which tasks are safe to delegate and which require oversight.
- Checkpoint workflows — pausing for review at defined stages makes delegation feel less like a leap of faith.
The delegation gap is not a fixed property of AI — it’s a function of verification cost. Every improvement in verification (better tests, adversarial agents, clear criteria) raises the delegation ceiling. This is why Anthropic’s later investment in dynamic workflows, adversarial verification, and outcomes-based grading (Chapters 2, 3, 13) directly targeted the gap.
3.9 The Organizational Maturity Model
Beyond individual trends, the report implicitly defined a maturity model for organizations adopting agentic coding. The maturity levels map roughly to the delegation spectrum:
| Maturity Level | Characteristics | Delegation Rate |
|---|---|---|
| Level 1: Experimentation | Individual developers trying AI tools ad hoc | 0–5% |
| Level 2: Adoption | Team-wide use, informal best practices | 5–10% |
| Level 3: Integration | Formal workflows, verification tooling, guardrails | 10–15% |
| Level 4: Transformation | AI-native processes, redefined roles, full trust in scoped areas | 15–20%+ |
Most organizations at the start of 2026 sat between Level 2 and Level 3. The frontier organizations — the ones whose case studies appear in this report — were pushing into Level 4, demonstrating what full integration looks like.
The maturity model matters because it shows that progress is not just about better AI; it’s about organizational evolution. Tools enable delegation, but processes, trust, and culture determine how much delegation actually happens.
3.10 Implications for Engineering Leadership
For engineering leaders reading the trends report, several strategic implications emerged:
- Invest in verification infrastructure. The single highest-leverage investment is making agent output cheap to verify. Test suites, CI/CD pipelines, type checkers, and review tooling all raise the delegation ceiling.
- Redefine senior engineering roles. The most valuable engineers become “agent directors” — those who can decompose problems, write clear criteria, and verify results — rather than individual contributors writing every line.
- Build shared agent infrastructure. Like TELUS, organizations that invest in reusable agent platforms see compounding returns as each new use case costs less.
- Embed security continuously. Don’t treat security as a final gate; build it into the agent workflow from the start.
3.11 The Year Ahead
Looking from January 2026 forward, the eight trends and four priority areas defined a clear roadmap. As the rest of this book documents, each area saw major product investment:
- Multi-agent coordination → dynamic workflows (Chapters 2–3), multiagent orchestration (Chapter 13).
- Human-agent oversight → session management (Chapter 7), steering methods (Chapter 9), context engineering (Chapter 8).
- Extending beyond engineering → products and surfaces (the later parts of this book).
- Embedded security → managed sandboxes (Chapter 14), vaults (Chapter 15), security governance.
The trends report was, in retrospect, a remarkably accurate forecast of where 2026 would go.
3.12 Key Takeaways
- The delegation gap is the key metric. Developers use AI in ~60% of work but fully delegate only 0–20%. Closing this gap is the frontier of progress.
- Eight trends, three tiers. The trends span foundation (collaboration, oversight), capability (multi-agent, beyond-engineering, security), and impact (productivity, migrations, skills).
- Multi-agent coordination unlocked scale. Parallel agents made large migrations and codebase-wide work routine.
- Security must be continuous, not final-stage. In an agentic SDLC, security is embedded from the start via hooks, sandboxes, and self-verification.
- The skills gap shifted from coding to direction. The most valuable skill became the ability to decompose problems, write clear criteria, and verify agent output.
- Case studies proved real ROI. Rakuten (99.9% accuracy), TELUS (500K hours saved), and Zapier (89% adoption) showed measurable, production-scale impact.
- Four areas defined the roadmap. Multi-agent coordination, human-agent oversight, extending beyond engineering, and embedded security became the axes of investment for 2026.