The zero-cost developer
Imagine a software company that can hire a thousand developers before breakfast, expand the team to ten thousand by lunch and dismiss the entire workforce before dinner without conducting a single interview.
These developers never sleep. They rarely stop to ask questions, can read enormous codebases in seconds and can produce code at a rate no human organisation could approach. Give them a product specification in the morning and they could potentially design the architecture, build the application, generate the tests, write the documentation and prepare the deployment before most human teams have finished discussing the requirements.
This is one possible destination of increasingly capable AI agents and, eventually, artificial general intelligence. Software development stops being constrained by the number of humans available to write software because intelligence itself becomes an abundant computational resource.
The obvious conclusion is that software engineering becomes dramatically easier. The more interesting possibility is that it becomes dramatically stranger.
Software engineering has never been difficult simply because programmers type slowly. Its hardest problems involve deciding what should exist, understanding how thousands of decisions interact, coordinating changes across a system, controlling dependencies, detecting unexpected behaviour and determining whether the final product can actually be trusted.
Key ideaAGI could make software production extraordinarily cheap without making software complexity cheap.
Two old ideas from computing help explain why. Fred Brooks showed why adding developers can increase rather than reduce the difficulty of software projects. Niklaus Wirth observed how software has a remarkable tendency to consume improvements in computing power.
Both ideas emerged in a world of expensive computers and scarce programmers. AGI invites us to reconsider them in a world where computation and artificial developers could both become abundant.
The result may not be the end of Brooks and Wirth. It may be their revenge.
Brooks and the infinite team
When Fred Brooks published The Mythical Man-Month in 1975, one of its most memorable arguments appeared almost absurd: adding programmers to a late software project can make it later.
The reason was not that additional developers were incompetent. Software development contains work that cannot simply be divided indefinitely. Developers must understand requirements, architecture, interfaces, dependencies and decisions made elsewhere in the project. Every additional person brings productive capacity, but also another participant who must somehow remain coordinated with the whole.
AGI appears to attack this problem directly.
Artificial developers do not require lengthy recruitment, onboarding sessions or weekly meetings. They can exchange information almost instantly, read documentation at extraordinary speed and potentially share far more context than human colleagues ever could.
Yet faster communication is not the same thing as shared understanding.
Imagine one agent changing an authentication interface while another modifies the mobile application against the previous interface. A third restructures the database, a fourth regenerates the tests and a fifth discovers the resulting failures and repairs them according to an architectural assumption that disappeared several minutes earlier.
Nothing requires any individual agent to be incompetent. Every decision can appear reasonable within its local context while the combined system moves steadily towards incoherence.
Key ideaBrooks’s problem has not disappeared. It has acquired a faster processor.
The agent coordination tax
The genuinely interesting question is not whether an AI agent can program. We already know increasingly capable systems can generate, explain, debug and modify software. The harder question is what happens when organisations can deploy hundreds, thousands or eventually millions of such agents simultaneously.
Human organisations have always faced natural limits on software production. Developers are expensive, recruitment takes time, management becomes difficult and large projects require substantial capital. These limitations are frustrating, but they also place an accidental ceiling on how much complexity an organisation can create.
Artificial developers weaken that ceiling.
A human engineer might hesitate before creating another service, dependency or abstraction because somebody will eventually have to understand and maintain it. An artificial agent has no natural reason to experience the same hesitation unless restraint has been deliberately incorporated into its objectives.
The economics therefore change. Creating another component becomes cheap, while understanding the relationship between ten thousand components may remain expensive.
This creates an agent coordination tax. Every new artificial developer can increase productive capacity while simultaneously increasing the number of assumptions, interfaces, dependencies and decisions that must remain compatible with everything else.
Key ideaThe scarce resource is no longer the ability to generate code. It is the ability to preserve coherence while generation becomes almost unlimited.
The review bottleneck
There is another uncomfortable consequence of making software creation cheap: somebody still has to determine whether the resulting software is correct.
Today, a developer might write a piece of code and another developer reviews it. AI changes the scale of this relationship because a machine can potentially generate more code in an hour than a human team can meaningfully inspect in a week.
The natural response is obvious. Use another AI to review the first AI.
Then another system can generate the tests, another can perform security analysis, another can evaluate the test coverage and another can investigate failures. Eventually we can employ an AI agent to determine whether the AI reviewer correctly reviewed the AI-generated code.
We begin with automation and gradually construct a synthetic bureaucracy.
This bureaucracy might be extremely effective. Automated verification could become vastly better than human code review. Yet the structure reveals an important shift in the economics of software engineering: generation scales almost effortlessly, while confidence requires additional machinery.
Key ideaThe bottleneck moves rather than disappears. Yesterday’s scarce resource was creation. Tomorrow’s scarce resource may be trust.
Machine-speed technical debt
Technical debt traditionally accumulates slowly because humans can create bad software only as quickly as humans can write it.
AI removes much of that speed limit.
A weak architectural decision made on Monday could be reproduced across hundreds of generated components before anyone notices it. Other agents can then build integrations around those components, generate tests that confirm their behaviour and produce documentation explaining the resulting architecture as though it had always been intentional.
Within a remarkably short period, a questionable decision can become infrastructure.
The problem is not simply that AI might produce bad code. Human developers have been doing that successfully for decades. The important difference is the potential velocity at which assumptions can spread through an automatically generated system.
Key ideaTechnical debt becomes capable of compounding at machine speed.
AI can also attack that debt at machine speed, which makes the situation more interesting than a simple story of technological decline. The same systems that generate thousands of unnecessary components could continuously inspect them, consolidate them, rewrite them and delete them.
Future software systems may therefore exist in a strange equilibrium where machines create complexity and remove complexity continuously.
Software engineering begins to resemble gardening in permanent fast-forward, with growth and pruning happening simultaneously.
Wirth and infinite compute
Niklaus Wirth identified another uncomfortable tendency in computing: improvements in hardware do not automatically produce faster or simpler software because software expands to consume the resources made available to it.
Processors become faster and applications acquire additional layers. Memory becomes cheaper and software consumes more memory. Storage expands and applications become larger. Each technological improvement creates an opportunity for efficiency, but also creates room for additional complexity.
Artificial intelligence gives this tendency an entirely new scale.
Models become cheaper to run, so we invoke them more frequently. Context windows become larger, so applications provide more context. GPUs become faster, so models become more capable. Inference becomes cheaper, so applications introduce reasoning. Reasoning becomes practical, so systems introduce tools. Tools become reliable, so developers introduce agents. Agents become useful, so we create teams of agents.
The efficiency gain has not disappeared. We have simply found more ambitious ways to spend it.
This is Wirth’s Law translated from conventional software into machine intelligence: every improvement in computational abundance creates another opportunity to build something computationally extravagant.
The intelligence bloat problem
Traditional software bloat was relatively easy to recognise. An application that once required a few megabytes eventually required hundreds. A simple program became surrounded by frameworks, dependencies, background services and abstraction layers until the machinery required to perform the task became larger than the task itself.
AI introduces the possibility of intelligence bloat.
Consider something as ordinary as deciding whether an invoice is overdue. Traditional software can read a date and compare it with today’s date. An AI architecture could retrieve the invoice, extract its contents, convert them into tokens, send them through a language model, reason about the payment terms, call an external tool, ask another model to verify the interpretation and finally generate a polished explanation that the invoice should have been paid last Tuesday.
There are situations where that intelligence is genuinely valuable. Contracts can be ambiguous, invoices can contain unusual conditions and real business processes rarely fit perfectly into neat database fields.
There are also situations where we have constructed an astonishing computational machine to compare two dates.
The distinction will become increasingly important as AI becomes cheaper because affordability can hide architectural absurdity.
The question should not merely be whether AI can perform a task. Software engineers will increasingly need to ask whether the task deserves intelligence in the first place.
Key ideaA civilisation capable of building extraordinary reasoning machines should still know when anifstatement will do.
When Brooks meets Wirth
Brooks and Wirth become most interesting when their ideas collide.
Brooks warns that increasing the number of developers can increase coordination complexity. Wirth warns that increasing computing capacity encourages software to consume that capacity. AGI potentially gives software organisations enormous quantities of artificial developers and computational power simultaneously.
More compute makes artificial developers cheaper. Cheaper developers produce more software. More software creates more dependencies. More dependencies require more testing. More testing encourages more verification agents. More agents require orchestration. Orchestration requires infrastructure. Infrastructure creates additional failure points. Those failures require monitoring, diagnosis and repair, all of which can themselves be performed by additional AI systems.
A feedback loop appears in which increasing intelligence produces complexity that requires additional intelligence to manage.
Eventually we could reach the peculiar situation where a significant proportion of AI engineering activity exists primarily to manage the consequences of previous AI engineering activity.
Key ideaThe machines do not need to malfunction for this to happen. They may be performing exactly as requested.
The failure would be confusing our ability to generate complexity with our ability to control it.
The complexity flywheel
The better machines become at producing software, the easier it becomes to create software that no individual human fully understands. That is the deeper paradox at the centre of AI-driven engineering. Documentation can accelerate with generation, but documentation does not automatically create comprehension. Tests can multiply, but coverage does not guarantee architectural understanding. Agents can explain individual components while behaviour emerging from millions of interactions becomes harder to reason about as a whole.
Software has always contained systems larger than any individual person’s mental model. AGI could push this characteristic much further by allowing the rate of system expansion to detach almost completely from human cognitive limits.
We may therefore create systems that are not designed in the traditional sense. They are generated, tested, observed, corrected and continuously regenerated. At that point software engineering begins to change character.
Key ideaWe stop asking whether anyone understands the entire machine and start asking whether we have enough evidence to trust what the machine does.
The hive-mind escape
There is, however, a serious challenge to this argument: a sufficiently capable AGI might defeat Brooks’s Law rather than amplify it.
Brooks’s coordination problem exists because separate humans possess separate mental models. Information has to move between them imperfectly through conversations, documents, meetings and code. Artificial agents may eventually share memory, project history, architectural knowledge and objectives so effectively that the communication problem changes fundamentally.
Context is copied, summarised and reconciled.
Context is available as common state.
Key ideaTen thousand artificial developers might not behave like ten thousand employees. They might behave like one intelligence with ten thousand hands.
The same challenge applies to Wirth’s Law. AI does not have to generate bloated systems merely because it can. A sufficiently capable system could continuously remove unnecessary dependencies, replace complex implementations with simpler ones, compress models, consolidate services and search relentlessly for more efficient architectures.
Perhaps the most impressive future coding demonstration will not involve an AI generating a million lines of software in an afternoon. It will involve an AI examining a million lines and returning twelve thousand.
The technology capable of creating extraordinary complexity may also become the most powerful tool ever invented for eliminating it. The real question is whether we will ask it to.
The new engineering
For most of computing history, software engineering developed under conditions of scarcity. Processing power was scarce, memory was scarce, storage was expensive, developers were expensive and time was limited.
Those constraints caused enormous frustration, but they also imposed discipline. AGI could remove several of them simultaneously.
When producing another thousand lines of code costs almost nothing, choosing not to produce them becomes important. When another hundred agents can be created instantly, deciding not to create them becomes an architectural decision. When a powerful reasoning model can be inserted into almost every business process, recognising that a deterministic function is sufficient becomes a mark of engineering judgement.
The economics of software therefore change the meaning of expertise.
When code was scarce, the valuable engineer was someone capable of producing it. When code becomes abundant, the valuable engineer may increasingly be someone capable of rejecting it, simplifying it, verifying it and deleting it.
The defining question moves from how much software we can create towards how much complexity we are prepared to own.
AGI may not repeal the old laws of software engineering. It may expose their deeper meaning by removing the natural limits that once kept software production relatively close to human speed.
Brooks warned us that more developers do not automatically create more progress. Wirth warned us that more computing power does not automatically create more efficiency. AGI could give us almost unlimited quantities of both and force us to discover whether we actually learned either lesson.
The great software engineering challenge of the AGI era may therefore have surprisingly little to do with generating code. It may be learning when to stop generating it.
Key ideaWhen machines can build almost anything, engineering becomes the discipline of deciding what deserves to exist.