Software That Builds Better Software—Then Improves Itself

Software That Builds Better Software—Then Improves Itself

How cumulative human innovation could lead to a new way of creating computational systems

It is tempting to tell the history of technology by naming a single inventor and the day an invention appeared. That makes for a memorable story. The more revealing story unfolds afterward, as people test an idea, discover its weaknesses, exchange knowledge, and make it useful to others. An invention can occur in a moment. Innovation usually requires people working across years, organizations, and sometimes generations.

In How Innovation Works, published in 2020, Matt Ridley explores that distinction through many histories of practical ingenuity. He follows innovations in energy, health, transport, food, communications, and other fields. Two of those histories are especially useful for understanding the opportunity now before us: the steam engine and the cellular telephone. Ridley recounts many more such histories; these two offer a focused comparison of the same human process unfolding at very different speeds.

The steam engine: a century of people solving one another's problems

Imagine a mine in England three centuries ago. Water collects in the workings, blocking miners' access to the coal below. The problem is immediate and physical. Someone must remove the water faster than laborers or horses can pump it. In the late seventeenth century, Thomas Savery developed a steam-powered pumping device. It was ingenious, with operating limits that restricted its practical applications. The challenge remained open for someone who could take a promising idea and make it more useful.

Thomas Newcomen, an ironmonger from Dartmouth, approached that problem with a different arrangement of cylinder, piston, beam, steam, and atmospheric pressure. In 1712, an engine of his design was installed near Dudley Castle to pump water from a mine. It was an important working advance suited to stationary mine pumping. Its heavy demand for fuel made it most economical where coal was inexpensive. Yet the machine created something precious: an operating starting point. Other people could study it, maintain it, copy it, and improve it.

Decades later, James Watt was a young instrument maker working with the University of Glasgow. In 1763, when asked to repair a small model of a Newcomen engine, he encountered a frustrating design problem. Each cycle wasted heat by repeatedly cooling and reheating the cylinder. Watt eventually developed the idea of condensing steam in a separate vessel, allowing the cylinder to remain hot. It was a major improvement, although a working idea was still a long distance from a reliable industrial machine. Watt needed precise metal parts, financial support, customers, manufacturing knowledge, and people willing to solve the practical problems revealed by production and field use.

This is where Matthew Boulton enters the story. Boulton was not simply a name attached to Watt's patent. He was a manufacturer and businessman in Birmingham who recognized both the promise and the difficulty of turning the improved engine into an industrial product. Their partnership, formed in 1775, connected technical invention with factories, financing, installation, sales, and service. They found ways to make the expensive engines commercially attractive by relating payments to the fuel savings they produced. Behind those business arrangements stood teams of mechanics, patternmakers, founders, and installers whose names are less familiar but whose work determined whether an engine succeeded in the field.

Another person, ironmaster John Wilkinson, helped make better steam engines possible by developing techniques for boring large cylinders more accurately. Precise piston-to-cylinder fitting was essential. Better machining reduced leakage and made other improvements useful. William Murdoch, who worked with Boulton and Watt, contributed to the machinery that converted the engine's reciprocating action into rotary motion. Rotary power expanded the engine's use from pumping water to driving equipment in factories. Engineers continued to refine valves, linkages, seals, speed regulation, boilers, and the methods of manufacturing them.

At the turn of the nineteenth century, Richard Trevithick pursued high-pressure steam engines, demonstrating how a smaller, more powerful engine could be used for movement as well as stationary work. Others adapted steam power for locomotives, ships, and an increasing variety of machinery. These improvements came from people working across different businesses, workshops, and countries. Some participants cooperated, some competed, and some struggled over patents and credit. Their shared contribution was the accumulation of useful knowledge through repeated practical change.

We remember James Watt partly because the international unit of power bears his name. The steam engine that became a workhorse of industrial civilization grew from the combined achievements of Watt, Savery, Newcomen, Boulton, Wilkinson, Murdoch, Trevithick, and many less-remembered craftspeople. Across many decades, numerous changes—large and small—reinforced one another until steam power could transform production, transportation, and daily life. The invention mattered; the long sequence of innovation multiplied its consequences.

The cell phone: the same human process on a compressed timetable

Now jump forward to the twentieth century, when a different group of engineers faced a different problem. Early mobile radio telephones were largely tied to automobiles, large batteries, or limited networks. The dream was personal communication: a telephone that a person could carry wherever life took them. That meant solving several problems together—radio engineering, battery power, antennas, switching, network capacity, size, cost, and regulatory approval.

At Motorola, engineer Martin Cooper led a team pursuing a truly handheld cellular telephone. On April 3, 1973, Cooper made a public demonstration call in New York City using a prototype. Cooper drew on the talents of a multidisciplinary team, including Rudy Krolopp, Motorola's industrial design director, whose team rapidly developed competing physical designs. The engineers and designers had to work together: the instrument needed to contain working electronics and an antenna, survive handling, and be recognizable as a telephone that someone could actually carry. Cooper and Krolopp helped move an idea from the realm of technical possibility toward something people could imagine using.

That 1973 demonstration began a further decade of engineering and commercial development. Motorola and others spent years refining devices and networks, testing performance, improving reliability, and meeting the requirements for commercial service. The DynaTAC 8000X received U.S. regulatory approval in 1983 and reached consumers in 1984. The interval matters: engineering, capital, infrastructure, and public adoption transformed a demonstration on a city street into a commercial reality.

Then the hardware kept changing. Batteries improved; electronics became smaller; the telephone became easier to carry and operate. Motorola's MicroTAC arrived in 1989 with a distinctive hinged cover, and the StarTAC appeared in 1996 in a compact clamshell form. The Smithsonian's Cooper Hewitt collection credits Albert Nagele and Leon Soren as designers of the StarTAC. Their contributions to the shape and usability of the device helped mobile technology move from an extraordinary gadget toward an ordinary possession. Industrial design was itself a central form of engineering innovation, making the technology more usable and appealing.

By 2007, Steve Jobs and Apple's engineering and design teams could bring together technologies that had been developing along multiple paths: cellular networks, capable microprocessors, compact batteries, displays, software, internet access, and touch-based interaction. When Jobs introduced the iPhone in January of that year, his achievement was an unusually effective synthesis of those advances: a phone, a digital media device, and a practical pocket internet computer joined by software and a new interface. After the original iPhone went on sale in June, further hardware, networks, applications, and services enlarged what a smartphone could do.

Martin Cooper is essential to the early handheld phone story. Krolopp, Nagele, and Soren are part of the story of making that device physically useful and desirable. Jobs is essential to the story of the modern smartphone as an integrated computing experience. Their contributions build on one another, alongside the work of countless engineers, manufacturers, network builders, software developers, and customers whose feedback pushed the technology forward. The mobile phone passed through its most visible transformations in decades, compared with the more than a century over which steam power developed from mine pumping into a general industrial force. The human pattern remained recognizable even as the pace accelerated.

Understanding the consequences of innovation

In The General Architecture of Technological Consequence: The Consequences of Innovation, I describe a way to think about the positive consequences that can follow a technological or institutional change. The sequence begins with a Positive Trigger Event—a discovery, invention, innovation, reform, or investment. It proceeds through the Impact Radius, the initial extent of consequences; Diffusion, as the change spreads; the Emergence Horizon, where new possibilities become visible; Synthesis, as capabilities combine; and Compounding Advancement, when those combinations create further opportunities for change.

This conceptual architecture traces how technological consequences emerge and accumulate at intervals shaped by circumstances and human action. The steam engine's impact widened as the machinery became practical and affordable. Diffusion created an expanding population of users and problem-solvers. Its emergence horizon grew as people recognized uses beyond draining mines. Synthesis with precision manufacturing, factories, iron production, and transportation helped compound the advance. The cell phone followed a comparable pattern, with an emergence horizon that moved more quickly as electronics, digital networks, software, and consumer design converged.

The lesson for the present is larger than either story: a technological capability can change the means by which later capabilities are created. What happens when the system that designs software becomes capable of improving the software-design process itself? Could it preserve what people know about a computation, learn from failed and successful implementations, and carry that knowledge forward into each new generation?

That question is the basis of the proposed self-improving software architecture. This ambitious aspiration has a precise starting point.

Make the specification the enduring invention

Today's software systems often carry their knowledge in a collection of source-code files, configuration settings, tests, documents, and unwritten assumptions. Even well-engineered code is tied to particular programming languages, libraries, operating systems, processors, and the choices of the people who built it. As environments change, programmers port, modify, replace, or rewrite software. In that work, the original purpose of the system can gradually become obscured.

Consider a financial application that must calculate amounts according to carefully defined rules, reject unauthorized transactions, preserve an audit trail, and handle failures while protecting its data. The business needs may remain recognizable for decades, while the computers running the application change repeatedly. The lasting intellectual asset should be the exact description of what the system is required to do; each generation of program code becomes an implementation of that enduring description.

I call that enduring description the Universal Computational Specification, or UCS. A UCS would describe the functions, inputs, outputs, states, permitted changes, operating constraints, security obligations, expected performance, and means of checking the result. 'Universal' expresses the intended breadth of the architecture; developing a comprehensive specification language and implementing the complete system remain research objectives. Establishing the range of supported computational meanings is itself part of the research.

A developer might express a requirement in English, Spanish, or another language, and the system would resolve its meaning into a precise, machine-interpretable form that can be reviewed. When requirements conflict or wording permits several interpretations, the system would identify the ambiguity and seek clarification. Authorized human stakeholders would review and approve the meaning that governs the resulting software.

From the UCS, specialized engineering systems could produce an application for a conventional processor today and another implementation for a different platform tomorrow. Each generation would be checked against the same underlying obligations, as revised by authorized changes. Reusable capability specifications could be assembled into larger systems, with their connections, permissions, and failure behavior specified explicitly.

The goal is to preserve the knowledge of what must be accomplished, while allowing the means of accomplishment to evolve.

Software engineering becomes a coordinated system of specialists

A sophisticated software engineering system would operate as a disciplined team of specialized agents, each with defined responsibilities and independent checks. One specialized system would help people express requirements. Another would translate the approved meaning into a formal representation. Others would generate implementations, test behavior, search for vulnerabilities, evaluate performance, and document results. A separate improvement system would study what succeeded and failed, then propose better ways to perform these jobs.

This arrangement is deliberately cybernetic: results are measured and fed back into controlled decisions about what should change. Crucially, independent reviewers would control the standards by which a generated program is judged. The builder and its examiner would have distinct authority: one creates the code and the other checks it against an approved answer key. A code-generating AI could propose revised tests, while changes to acceptance criteria would require separate authorization.

There is also an essential difference between proposing a solution and proving that it works. Artificial intelligence can produce candidate programs, test cases, and proofs very quickly. Those proposals require independent evaluation. For a precisely modeled calculation or state transition, mathematics may establish important correctness properties; independent checking can reject invalid claims. For behavior involving images, speech, uncertain predictions, or changing real-world conditions, assurance must also address real-world variability through rigorous evaluation, statistical evidence, monitoring, and explicit limits. Each kind of behavior requires evidence appropriate to its risks and semantics.

Human experience remains central. Users define the purpose; engineers refine the methods; domain specialists resolve difficult requirements; security authorities protect the boundaries; and independent reviewers approve consequential changes. The proposed architecture would make their knowledge more durable and their work more effective, while keeping human judgment central to design and governance.

A learning system that improves the way it builds

The phrase 'self-improving software' describes several complementary mechanisms for making the engineering system more capable. Training an AI model is one such mechanism. The architecture includes at least five distinct subjects of improvement.

The system could improve a model's parameters, using well-tested tuning or carefully controlled edits. It could improve the harness surrounding a model—the instructions, tools, memory, research access, routing, and workflows that determine how its capability is used. It could improve the specifications and knowledge on which it works, uncovering ambiguities or adding validated reusable components while preserving approved goals and requiring authorization for substantive changes. It could improve the architecture of the engineering system, changing how specialists collaborate. And it could propose changes to model architecture, such as a more efficient method of using memory or processing long inputs.

Each mechanism changes a different part of the engineering process. Improving a prompt changes how a model is guided; redesigning a neural network changes how it computes. Reducing model size offers an efficiency gain when measured reliability remains acceptable. Faster generated code counts as an improvement when correctness and security requirements continue to be met. Each proposed change would need a stated hypothesis, a repeatable experiment, and an independent decision about whether the measured benefit justified adoption.

The recursive possibility is the important one. If a system improves its testing harness today, that improved harness could help it identify a better code-generation method tomorrow. A better generator might then help implement a better version of the engineering system itself. Throughout this process, independent authorities would govern acceptance standards, deployment permissions, and trusted security controls. Learning from results could proceed within those boundaries, with changes to governing obligations reserved for authorized reviewers.

One purpose, changing machines

The same principle applies to the hardware on which generated software runs. Ordinary processors remain essential, while graphics processors and AI accelerators are useful for particular kinds of work. Optical and quantum computing may expand future possibilities for selected problems, bringing specialized capabilities, distinct constraints, and additional integration costs.

A UCS would describe a computation independently of any particular hardware target. Generation systems could choose a suitable platform while considering speed, numerical precision, energy, memory, reliability, security, and the cost of moving data between devices. Each new platform would offer an opportunity to create a different implementation of the same authorized purpose, supported by fresh evidence that it satisfies the applicable requirements.

From an ambitious idea to a testable achievement

The complete architecture remains a research objective. Several of its foundations are already established—formal methods, verified compilers, automated analysis, AI-assisted programming, reproducible testing, and security controls. Integrating them across many kinds of computation, while adding controlled recursive improvement, is the challenge.

The first demonstration should therefore be serious but contained. Take an application with clear rules, persistent data, authorization checks, and failures that matter. Write and validate its UCS. Generate an implementation. Have independent tools test or prove specified properties. Change one authorized requirement, regenerate the program, and verify that the intended behavior changed while unaffected obligations remained satisfied. Then deliberately introduce flaws to see whether the evaluators detect them. Finally, test a limited improvement to the engineering machinery and determine whether the claimed gain survives independent evaluation.

The first milestone should be a transparent, repeatable result that others can inspect, challenge, and extend, including a clear record of its failures and limitations. A credible success in a narrow domain can become a new starting point, just as Newcomen's practical pumping engine became a starting point for later generations who discovered further applications of steam power.

A moonshot for the people who will build what comes next

On May 25, 1961, President John F. Kennedy asked the United States to commit to landing a person on the Moon and returning that person safely to Earth before the decade was out. At Rice University on September 12, 1962, he gave the challenge its enduring public language: 'We choose to go to the Moon.' He established the destination while engineers still had to develop essential rockets, guidance systems, materials, and procedures. He named an objective that would require people to create what was missing.

The Apollo program became possible through the work of scientists, engineers, technicians, contractors, pilots, administrators, and countless others. Kennedy supplied direction; many people supplied invention, experimentation, production, and disciplined execution. That human reality is what gives the moonshot example its power. Ambition supplied the destination, while organized work and evidence gave the mission its practical foundation.

A Universal Computational Specification architecture that can generate, verify, and improve software—including carefully bounded improvements to its own engineering methods—is a suitable research moonshot for a new era of computing. It demands precision about the desired result, honesty about present limits, independent standards for success, and a community of people willing to discover and build the missing capabilities.

Imagine standing at the bow of a ship, looking toward the distant horizon. Much of what lies beyond remains out of view, yet we can begin to recognize the possibilities taking shape. Today, we stand at just such an emergence horizon in the evolution of computing. We can envision software generated from a universal specification, independently verified, and capable of improving the very methods by which it is created. It may sound like science fiction, but we almost know how to do it. Many of the essential technologies already exist. What remains is to bring them together, discover what is missing, and demonstrate that the complete system can work. Like the generation challenged by President Kennedy to reach the Moon, we have the opportunity to turn a vision of the future into an engineering achievement by the middle of the 2030s.

Readers who want the formal architecture, proposed validation program, technical limitations, and sources supporting both articles can consult the technical companion, Software That Builds Better Software—Then Improves Itself: A Cybernetic Architecture for Universal Computational Specification and Recursive Self-Improvement. Its bibliography contains the references for this public article as well.