The agentic coding flywheel

The progression matters. The first wave of AI coding was an LLM in ChatGPT, where developers pasted snippets back and forth. The second wave arrived with GitHub Copilot and Cursor that brought that chat into the developer environment (IDE), where the LLMs could read and write files directly. The current breakthrough came when Anthropic’s Claude Code put the agent into the terminal itself, giving it the same tools a developer uses: a file system, a shell, a test runner, a version control system. Suddenly, the agent could plan an approach, execute it, observe what broke, and try again, all without the developer copying anything. 

That same logic inspired tools such as Peter Steinberger’s OpenClaw, a deliberately autonomous, proactive AI assistant that can operate a computer through its own terminal and broad system access. As Summer Yue, director of alignment at Meta's Superintelligence Labs, experienced firsthand, agents can also take unintended actions – she described having to run to her Mac mini “like I was defusing a bomb.”¹ 

That is the agentic part. Autonomy is a slider, not a switch. At one end, a developer accepts a single-line completion. At the other end, a non-technical colleague writes a request in Slack, and a coding agent picks up the task, gathers context, writes code, runs tests, opens a pull request, and, crucially, pings a human for review. 

The value of coding agents really comes down to how much data they can access and how much autonomy they are given to act on a user’s behalf. Most teams sit somewhere between manual assistance and full delegation, and the right point on that slider depends on system criticality and the maturity of the surrounding guardrails.

The year agents came alive 

For most of 2023 and 2024, professional developers tolerated AI assistants but did not depend on them. The output was good enough to save typing, not good enough to trust. 

Three things have changed in the last twelve months: 

1. Models have become markedly better at code 

Frontier labs poured training and reinforcement learning into coding specifically. Scores on SWE-bench Pro, the benchmark that measures whether a model can resolve real GitHub issues end-to-end, went from roughly 40% a year ago to 80.3% on Claude Mythos 5/Fable 5 in early 2026.³ Hallucinations in common programming languages have dropped sharply, and context windows large enough to hold an entire mid-sized codebase are now routine. 

2. Standards have emerged 

In November 2024, Anthropic introduced the Model Context Protocol (MCP), an open specification for how agents discover and use external tools. Within a year it had been adopted by OpenAI, Google DeepMind, Cursor, and several major cloud providers, and in December 2025 it was donated to the Linux Foundation’s new Agentic AI Foundation.⁴ As of Q2 2026, more than 200 community-built MCP servers exist for systems ranging from GitHub and PostgreSQL to Figma and Kubernetes. For the first time, coding agents have a common way to plug into the rest of the enterprise. 

A second standard, Agent Skills, extends this logic from tools to know-how. Introduced by Anthropic in October 2025 and later published as an open standard, Skills package instructions, scripts, and reference materials into reusable modules that an agent can load on demand. If MCP gives agents a common way to connect to enterprise systems, Skills give organisations a common way to encode how specific tasks should be done. 

3. Practitioners have learned how to use the tools 

Context engineering, skills, custom instructions, sub-agents, and review pipelines have moved from individual experiments to shared playbooks.

As the illustration above shows, experienced users increasingly let Claude run without any manual approval. In our experience, the reason for this learning curve is twofold: 

1. Users increasingly learn to navigate the ‘jagged frontier’ – the uneven distribution of tasks AI handles brilliantly versus poorly.
2. Users become more fluent in reviewing the larger quantity of outputs and grow confident in the model’s capabilities. 

The two camps, and why both are wrong 

The conversation around agentic coding has split into two unhelpful camps. The first is the vibe coders, who treat the agent as a black box. They describe what you want, accept whatever appears, and ship it. The second is the artisan coders, who refuse to let an agent touch anything that matters because the output is not deterministic. 

Both miss the point. Vibe coding is fine for a weekend prototype, but the costs might surface later in the form of cognitive debt. When agents write the code, the rationale behind design decisions, the interactions between components, and the collective understanding of how it all fits together drain from the team's mind. 

The organisation might no longer understand the system it owns. If the developer who shipped a vibe-coded customer-relationship system over a weekend then leaves, the company is left with software it cannot maintain, with no backups, no two-factor authentication, and no one to call when it breaks. 

The sceptics are wrong for the opposite reason. The evidence that agents materially raise productivity and baseline quality, when paired with proper review, is now overwhelming. And the honest position is the one most senior engineers are quietly converging on: agentic coding is a productivity multiplier, but only for teams that double down on the engineering disciplines that made software safe in the first place. Strong tests, clear pipelines, security scanning, code review, and architectural ownership matter more in an AI-assisted world, not less.

A rough estimate is that developers can fairly quickly free up roughly 40% of their capacity for more value-adding tasks. This is the point at which the flywheel really begins to spin: better context produces better code, which builds trust, which encourages more delegation, which exposes more workflows to automation. 

What it means for IT and business leaders 

For most organisations, the question is no longer whether to adopt agentic coding but how to do so without building a debt iceberg beneath the surface. A few practical principles stand out. 

1. Take the first step before you have a strategy 

The first stage of the journey is unavoidably bottom-up. Get licences for Claude Code, GitHub Copilot, or a comparable agent into the hands of motivated developers and let them experiment. You cannot plan your way through stage one from a slide deck. 

2. Invest in the harness, not just the seats 

The differentiator between organisations that capture value and those that do not is the context layer: shared skills, MCP connections to internal systems, agreed conventions written down where the agent can read them. This is engineering work, and it should be funded as such. 

3. Keep a human accountable for every change 

Even when an agent writes the code, a named human still has to stand behind the merge. Reviews, tests, and pipelines are non-negotiable, especially as autonomy increases. Without them, productivity gains evaporate into maintenance costs within eighteen months. 

4. Plan for rising user expectations 

As your competitors ship features faster, your customers will notice. Roadmaps that looked ambitious a year ago are about to look slow. The freed-up engineering capacity should not be banked as headcount savings; it should be redirected towards the work users will soon expect as standard. 

5. Treat coding agents as a talent strategy 

Many of the senior developers we speak to describe agentic coding as the most fun they have had in years. The grunt work disappears, leaving more time for all the interesting work. Organisations that adopt thoughtfully will find it easier to attract and retain experienced engineers. 

The forward look 

Even if agentic coding technology stopped advancing today, organisations would spend the next decade absorbing the capabilities that already exist. Most have only just bought their first licences. The institutional learning curve is the bottleneck, not the model. 

The direction of travel is clear enough, however, and it has been ever since the release of ChatGPT in November 2022. OpenAI outlined five levels towards artificial general intelligence, and every step taken so far has followed that progression. The early adopters already built the first agents with LangChain back in 2023 and saw the first autonomous agent in GPTEngineer, an open-source code base that would eventually become Lovable, the fastest growing software startup in history, even surpassing OpenAI.⁶ 

Coding agents will keep moving up the autonomy slider. Interfaces will multiply – from chat, IDE, and command line to standalone orchestration apps, and increasingly the chat tools where business users already work. The teams that thrive will be those that have done the unglamorous work of context engineering, governance, and review, so that when the next capability lands, they are already ready – and itching – to use it. 

Agentic coding is becoming the default way software is written. The organisations that treat it as a collective discipline rather than an individual gadget will compound advantages that are very hard to catch up with. 

Sources 

1. Melissa Locker, "'This Should Terrify You': Meta Superintelligence Safety Director Lost Control of Her AI Agent — It Deleted Her Emails," Fast Company, February 24, 2026, https://www.fastcompany.com/91497841/meta-superintelligence-lab-ai-safety-alignment-director-lost-control-of-agent-deleted-her-emails. 
2. Anthropic, 2026 Agentic Coding Trends Report, 2026, https://resources.anthropic.com/hubfs/2026%20Agentic%20Coding%20Trends%20Report.pdf; Google Cloud, "ROI of AI: How Agents Help Business," accessed July 29, 2026, https://cloud.google.com/transform/roi-of-ai-how-agents-help-business. 
3. Anthropic, "Claude Mythos 5/Fable 5," 2026, https://www.anthropic.com/news/claude-fable-5-mythos-5. 
4. Wikipedia, "Model Context Protocol," last modified 2026, https://en.wikipedia.org/wiki/Model_Context_Protocol. 
5. Miles McCain et al., "Measuring AI Agent Autonomy in Practice," Anthropic, February 18, 2026, https://www.anthropic.com/research/measuring-agent-autonomy. 
6. Iain Martin, "Vibe Coding Turned This Swedish AI Unicorn into the Fastest Growing Software Startup Ever," Forbes, July 23, 2025, https://www.forbes.com/sites/iainmartin/2025/07/23/vibe-coding-turned-this-swedish-ai-unicorn-into-the-fastest-growing-software-startup-ever/.