For most of the history of generative AI, the claim that it would transform software development ran ahead of the technology.
Early coding assistants were impressive, but they were assistants in the literal sense. They completed functions, explained unfamiliar code and generated useful snippets. They could make an individual programmer faster, but nobody was seriously handing them responsibility for building and maintaining enterprise applications.
That is changing remarkably quickly. And that is precisely why calls to slow the development of frontier AI models are arriving at the wrong moment.
Anthropic CEO Dario Amodei recently called for the industry to “pace the frontier”, arguing that capability development should slow sufficiently for alignment, evaluation and safeguards to catch up. OpenAI has reached a similar decision in a more limited context: in August it said it had temporarily slowed the pace of model scaling after seeing evidence that an upcoming model could cross a critical cybersecurity capability threshold.
The safety concerns deserve to be taken seriously. But deliberately slowing capability development risks misunderstanding where we actually are in the transformation of software engineering.
We are not near the end. We are barely at the beginning.
Only now are frontier models becoming capable enough to move beyond coding assistance towards meaningful autonomous engineering. OpenAI says Codex can reason across large repositories, use tools, make changes, execute tests and prepare work for human review.
Millions of developers are already using it, while enterprises including Cisco, Datadog, Dell and Nvidia have deployed it.
Anthropic describes a similar transition. Its latest models are designed for coding projects spanning entire codebases and for autonomous sessions lasting hours or days. At Anthropic itself, AI already “leads” 26% of measured AI research and development work, while more than 90% involves AI at least collaborating with humans. Yet Anthropic also says Claude is not operating fully autonomously across any of the R&D categories it measured.
That last point matters.
For all the extraordinary progress, we have not arrived at autonomous software development. We have reached the point where we can begin discovering what autonomous software development actually looks like.
There is an enormous difference between an agent solving a programming problem and an agentic network developing a production application. Enterprise software has architecture, dependencies, security policies, databases, APIs, legacy systems, regulatory requirements and operational histories measured in decades. Requirements change. Tests are incomplete. Documentation contradicts reality. Decisions made today constrain developers five years from now.
Current models are only beginning to handle this environment reliably.
Anthropic’s own research on long-running coding agents illustrates the problem. Even a frontier coding model placed in a capable agent harness can struggle to produce a production-quality application from a high-level instruction without additional mechanisms for planning, context management and continuity.
That should not be interpreted as evidence that AI has gone far enough. It is evidence that it has further to go.
The software industry needs models with better reasoning, longer effective memory, stronger understanding of architectural intent and a better ability to recognize when they are wrong. We need agents capable of maintaining coherent objectives across millions of lines of code and thousands of autonomous actions. We need them to understand not merely whether software compiles, but whether the system they are creating is maintainable, secure and appropriate for the organization running it.
Those are frontier-model problems as much as they are tooling problems.
There is also a danger that slowing fundamental capability improvements shifts too much complexity into the infrastructure surrounding imperfect models. Every weakness in an agent creates another opportunity to build a harness, workflow or supervisory system compensating for it. Anthropic itself has noted that assumptions embedded in agent harnesses can become obsolete as models improve.
The history of computing suggests we should be cautious about building permanent infrastructure around temporary technological limitations.
None of this means ignoring safety. The opposite is required.
As agentic networks become responsible for more software development, monitoring them becomes essential. Organizations need to know what agents are doing, what tools they access, what instructions they receive, how much they spend, what code they modify and when their behavior deviates from expectations. Anthropic says roughly 30,000 agents were simultaneously performing research and engineering work on its most-used internal platform in August, with their actions passing through automated monitoring.
That points towards a different answer to the risks created by rapidly improving AI. Do not slow the models. Accelerate the safety infrastructure around them. Improve monitoring. Strengthen containment. Build better evaluations. Require auditable agent activity. Restrict privileges. Develop independent supervision. Make it possible to detect and stop an agent when it behaves incorrectly.
Because better models themselves can also make agentic software development safer. A model that reasons more accurately makes fewer bad architectural decisions. A model that understands context better needs fewer corrective iterations. A model capable of recognizing uncertainty can escalate a decision rather than confidently implementing the wrong one.
We should therefore be careful about assuming that capability and safety sit on opposite sides of the equation.
Software development is standing at an unusual threshold. For decades, every generation of development tools still ultimately required humans to perform the intellectual work of turning requirements into functioning software. We now have systems beginning to perform significant portions of that work themselves.
And they are only just becoming good enough.
This is not the moment to decide that progress has become fast enough. It is the moment to find out how far this transformation can go — while building the controls required to go there safely.
