Grady Booch, a foundational figure in software engineering (co-creator of UML, IBM Fellow, pioneer of object-oriented design), argues that AI is not ending software engineering but launching its third golden age — a period defined by rising levels of abstraction, just as the field has seen twice before. He draws on decades of personal experience and deep historical knowledge to explain why the core human skills of software engineering — balancing technical, economic, legal, and ethical forces — remain essential, and why developers should see AI as a liberating force rather than an existential threat.
The three golden ages of software engineering
The term “software engineering” was coined by Margaret Hamilton during the Apollo program in the 1960s to give legitimacy to software work among hardware engineers, and it stuck after the NATO conference on software engineering gave it wider recognition.
Software engineering is defined by building reasonably optimal solutions that balance static and dynamic forces — physical laws, hardware constraints, algorithmic limits, human/organizational capacity, legal requirements, and ethical considerations — in a medium (software) that is extraordinarily flexible.
First golden age (late 1940s–late 1970s): Software becomes an industry
Software was initially inseparable from hardware (e.g., ENIAC plugboards). The key breakthrough was decoupling software from machines, driven by IBM’s decision in the 1960s to create a common architecture across hardware lines, preserving software investments.
The primary abstraction was algorithmic — focused on mathematical operations and business process automation (accounting, payroll), dominated by Fortran and assembly language.
The real innovation happened on the fringe, especially in defense: the SAGE air defense system consumed an estimated 20–30% of all U.S. software developers, driving advances in distributed systems, real-time processing, and graphical user interfaces (Whirlwind, “mother of all demos”).
Key figures: Edsger Dijkstra, Tom DeMarco, Larry Constantine, David Parnas. Flowcharts were invented. A division of labor emerged (analysts, programmers, keypunch operators, computer operators), driven by the economics of expensive machines.
Open-source-like sharing existed: IBM SHARE was a customer-organized group that freely shared software. Software was essentially given away free by manufacturers until IBM decoupled and started charging in the late 1960s–70s.
The software crisis (late 1970s–early 1980s)
NATO publicly identified the crisis: insatiable demand for software, but the industry could not produce quality software fast enough, at scale, or affordably.
The U.S. military counted ~14,000 programming languages across its systems, prompting the Ada project to consolidate around one language.
This period saw the emergence of new abstraction ideas: abstract data types (Goguen), information hiding (Parnas), separation of concerns, literate programming (Knuth), and the rise of object-oriented programming (Simula, then Bjarne Stroustrup’s C++).
A deep philosophical split — traceable to Plato — played out: should we model the world through processes (functions, algorithms) or through things (objects, classes)? The first golden age was process-centric; the second would be object-centric.
Functional programming also emerged (influenced by John Backus after Fortran) but remained niche because, as Backus himself noted, it makes hard things easy but easy things nearly impossible.
Second golden age (1980s–1990s): Object-oriented programming and distributed systems
Driven by growing complexity, the demand for distributed systems, and the personal computer revolution (itself a product of Cold War–driven micro-miniaturization).
The primary abstraction shifted to objects and classes, combining data and behavior. This proved highly effective for managing complexity.
Key figures: Grady Booch, Ivar Jacobson, Jim Rumbaugh (“the Three Amigos”), Pete Coad, Ed Yourdon.
Open-source principles carried over and expanded: libraries for CRT graphics, messaging, etc., were shared freely.
Platforms and service-oriented architectures (SOA) emerged: SOAP, HTTP as a higher-level protocol for passing information and processes. These laid the groundwork for today’s API-driven platform economy (AWS, Salesforce).
Software moved from being a business tool into the interstitial spaces of civilization — email (Grady got his in 1987 on ARPANET), the internet, personal computing.
The dot-com crash and Y2K marked the tail end. Y2K is an example of invisible technology working: massive effort prevented a crisis that never materialized, which is exactly what good engineering looks like.
Third golden age (turn of the millennium–present): AI, platforms, and systems at scale
The shift is from writing individual programs to composing systems from libraries, packages, and platform services (messaging, data processing, etc.).
AI coding assistants (Cursor, Copilot, ChatGPT) are a reaction to this rise in abstraction — they accelerate the use of the vast ecosystem of existing libraries and patterns.
Current problems are different: managing enormous volumes of software, security and supply chain integrity (e.g., SolarWinds/xk052), companies that are “too big to fail” (Microsoft, Google), and ethical dilemmas (should we build what we can build?).
Grady argues we’ve been in this third golden age for roughly two decades; AI coding tools are a continuation of its forces, not the beginning of it.
Why software engineers will still be needed
This is not the first existential crisis developers have faced. When compilers and Fortran emerged, assembly programmers feared obsolescence. When high-level languages rose, the same fears appeared. Each time, the skills at one level of abstraction became less relevant, but the fundamentals endured.
The pattern: tools automate the lower level, freeing engineers to work at a higher level of abstraction. This is what’s happening now with AI.
Grady’s direct response to Dario Amodei’s claim that “software engineering will be automatable in 12 months”:
Grady calls this “utterly wrong” (his polite scientific term). His reasons:
Amodei has a business incentive to make outrageous statements to stakeholders and investors.
He fundamentally misunderstands what software engineering is: it’s not just writing code, it’s balancing technical, economic, legal, and ethical forces — none of which are within the scope of current AI automation.
Current AI agents are trained on patterns seen hundreds of times before (CRUD apps, web-centric systems). The world of computing is vastly larger than this — embedded systems, real-time systems, safety-critical systems, and domains that haven’t been automated.
As Grady paraphrases Shakespeare: “There are more things in computing, Dario, than are dreamt of in your philosophy.”
AI tools are best understood as another level of abstraction, akin to compilers — they reduce the distance between intent (English) and implementation (code), but only in well-structured domains.
What becomes obsolete vs. what becomes more important:
Likely to be automated away: routine infrastructure plumbing, simple app development (iOS CRUD apps), and tasks that are messy, complex, and repetitive — where automation has clear economic and security value.
New skills that matter more:
Thinking in terms of systems, not just programs or apps.
Managing complexity at scale.
Dealing with the human forces (organizational, economic, ethical) that are rare and delicate and cannot be automated.
The ability to express intent clearly and critically evaluate AI-generated output — which requires deep foundational knowledge.
Grady’s advice: “Move up a level of abstraction. Start worrying about systems.”
Foundations and resources for the new era
Grady’s own “happy place” when facing difficult problems is systems theory:
Herbert Simon and Allen Newell, Sciences of the Artificial — foundational work on complex systems and AI.
Santa Fe Institute — research on complexity science.
Marvin Minsky, Society of Mind — architecting multiple agents, directly relevant to today’s agent-based programming.
Blackboard architectures and global workspace theory (from early AI systems like Hearsay).
Neuroscience and embodied cognition — most current AI is disembodied; real-world systems (spacecraft, robots) require understanding how intelligence is grounded in physical reality.
Grady’s work on NASA’s Mars mission involved building a “holon” (a whole that is also a part of a larger whole), drawing on these biological and systems principles.
His closing advice: “The main thing that constrains us in software is our imagination.” AI removes friction and cost, unleashing the ability to build things that were previously impossible due to team size, budget, or reach. The opportunity is to soar — and the people who will thrive are those with deep foundations who can ride the wave of rising abstraction rather than being paralyzed by it.
