# AI Reopens Programming's Seventy-Year Abstraction War

Since 1954, every major change in how software is written has split developers along the same fault lines (craft pride, quality and control, job security, professional identity and, from 1976, the ethics of who owns the work), and nearly every split ended the same way. Skeptics who said a new abstraction *could not work* lost, skeptics who said it was *oversold* mostly won, and prophets who said it would *eliminate programmers* lost every time, because the work climbed a level, a routine tier shrank and the profession grew. No camp was argued out of its position. Fights over compilers, GOTO, CASE tools, objects, garbage collection, typing, open source, Agile, JavaScript, Stack Overflow, bootcamps, offshoring, DevOps and low-code ended through demonstrated output, better tooling and guardrails, network effects or institutional fiat, after which the contested aid became the baseline and the "real programmer" line dropped a rung. The 2026 fight over AI assistants, vibe coding and agents reruns that script closely: "the hottest new programming language is English" is COBOL's 1959 premise, the vibe coder is Microsoft's "Mort," AI-code security studies replicate the Stack Overflow studies, and the "computer programmer" occupation that offshoring was supposed to kill is now AI's lead exhibit, while the Bureau of Labor Statistics still projects software-developer jobs to grow 10% through 2035. What is genuinely new is an abstraction that cannot verify its own output, a tool built from developers' own work without their consent, unprecedented speed and capital, explicit use as a headcount instrument, and agents that act in the world. The most consequential difference is where the labor effect lands: employment of 22-to-25-year-olds in AI-exposed occupations sits **19% below trend** ([Stanford Digital Economy Lab](https://digitaleconomy.stanford.edu/app/uploads/2026/08/Canaries_August2026.pdf)), eroding the apprenticeship that has always produced the experts who supervise each new abstraction.

## Nineteen schisms, four constituencies, one recurring script

The episodes range from a single keyword to a national labor market, yet four constituencies recur in almost all of them. **Formalists** such as Edsger Dijkstra argue from discipline and provability. **Craftspeople**, from 1950s machine coders through the "Real Programmers" to today's self-described artisans, argue from machine intimacy, performance and pride. **Managers and vendors** hope each tool will reduce their dependence on scarce, idiosyncratic programmers. **Newcomers** (COBOL business programmers, BASIC hobbyists, Visual Basic users, JavaScript and PHP amateurs, bootcamp graduates and now vibe coders) are the people each tool admits, and the first two camps usually scorn them. The table condenses nineteen episodes, and the sections that follow supply the evidence. Read down the last column and the recurring result appears: technical skeptics were often right about version one and wrong about the trajectory, and every forecast of programmer elimination failed.

| Schism (peak years) | Main resisters | Chief stated reasons | How it resolved | Predictions that failed or held |
|---|---|---|---|---|
| Assembly vs. compilers: FORTRAN (1954–1970) | Machine-code "priesthood"; systems programmers as late as 1968 | Speed (early systems 5–10x slower), hype, craft pride ("only for sissies") | Optimizing compiler won on output; majority use at surveyed IBM 704 sites by 1958; assembly retreated to hot loops | Failed: "can't be done"; "virtually eliminate coding and debugging." Held: first-generation tools were slow and oversold |
| COBOL and "English" programming (1959–1975) | Academics; career programmers | Verbosity, low-status business work, "cripples the mind" | Pentagon pressure made it dominant for decades | Failed: "stopgap"; any shrinking of programmer demand (it exploded). Held: readable statements, unreadable systems |
| Structured programming and GOTO (1968–1989) | Assembly-era practitioners; later Frank Rubin | Efficiency and freedom; resentment of its use as management control | Knuth's middle way: unrestricted goto gone, restricted forms kept | Failed: total abolition; Knuth's feared counter-revolution. Held: goto was overused |
| "Real Programmer" gatekeeping (1960s–2010s) | Self-styled Real Programmers vs. "Quiche Eaters" | Machine intimacy, performance, opacity as job security | Survived as satire and "contempt culture" | Held: the archetype faded. Failed: that high-level languages were "sissy" (they became the norm) |
| 4GLs, CASE, The Last One, 5GL, MDA (1981–2005) | Programmers (as James Martin predicted); technically minded staff | Deskilling, lost marketability, brittle tools | 70% of CASE tools unused a year after introduction; niches survived (SQL, SAS, report writers) | Failed: "without programmers"; MDA "future-proofs... twenty years." Held: design and specification stay human |
| Object orientation (1986–2012) | Stepanov, Armstrong, Graham, Torvalds, Pike | Hidden state, inheritance tangles, "mediocre programmers" | Mainstream but moderated; composition over inheritance | Failed: Cox's market for purchased components. Held: Brooks's doubt about a 10x gain |
| Garbage collection and managed runtimes (1995–2008) | C/C++ programmers; systems educators | Speed, "exquisite control," "JavaSchools" deskilling | JIT closed the gap; managed languages dominate; Rust for systems | Failed: "too slow." Never tested: Java-first graduates would be weaker |
| IDEs and autocomplete vs. editors (1985–2010) | vi and Emacs partisans; Charles Petzold | Memory offloading, "making us dumber," "cheapening our labor" | Autocomplete became part of "writing by hand" | Held: "inevitable." Never tested: skill rot |
| Static vs. dynamic typing (2000–2025) | Both camps; DHH as holdout | Flexibility vs. bug detection; career-long identity | Gradual typing; TypeScript became GitHub's top language in 2025 | Failed: "dynamic by 2010." Measured: types catch about 15% of shipped JavaScript bugs |
| Free software vs. proprietary (1976–2020) | Gates and Microsoft; later SCO | "Theft," IP destruction, "cancer," "viral" GPL | Microsoft "loves Linux" and buys GitHub; SCO settles | Failed: open source destroys the software business. Held: the Halloween memo's diagnosis; Stallman's "other bases" for business |
| Free Software vs. Open Source (1998–present) | Stallman vs. Raymond and Peterson | User freedom as ethics vs. business pragmatism | Pragmatists own the label; ethicists set legitimacy tests | Held: forks protect the commons; source-available vendors re-added AGPL |
| Agile vs. waterfall (1985–2025) | Plan-driven engineers; later Agile's own founders | Predictability vs. bureaucracy; the certification industry | 71% use Agile; 13% deeply embedded; 74% hybrid | Failed: the Pentagon's 1985 waterfall standard (dropped 1994); Agile ending "make-work" |
| JavaScript, PHP and front-end as "not real" (1995–2025) | Back-end and "serious" programmers | Amateurs, toy languages, bad design; gendered prestige | JavaScript most-used language; PHP runs ~70% of known server-side sites | Failed: "strictly for the amateurs." Held: many design criticisms |
| Frameworks vs. vanilla; left-pad (2005–2016) | Craft purists | "Magic," churn, fragile micro-dependencies | Frameworks won; npm restricted unpublishing | Held: dependency fragility. Unproven: that developers had "forgotten how to program" |
| Stack Overflow copy-paste (2008–2022) | Purists; security researchers | Insecure snippets, code without understanding | Normalized ("forgive yourself!"), then displaced by AI | Held: real security risk. Failed: stigma curbing the practice |
| Bootcamps and "learn to code" (2012–2025) | Degree holders; whiteboard interviewers | Missing fundamentals | Parity on practical skills; two industry shakeouts | Held: weaker on algorithms; fragile business. Failed: "not real engineers" |
| Offshoring (1992–2007) | US programmers, Lou Dobbs, politicians | Job security, wage competition | Profession grew; "computer programmer" tier shrank ~72% | Failed: Yourdon's "dodo bird"; Forrester's scale and timing. Held: the routine tier was most exposed |
| DevOps, NoOps and cloud (2009–2025) | Sysadmins; cloud skeptics | Job threat, control, cost | Ops absorbed into DevOps and SRE; selective cloud repatriation | Failed: NoOps abolishing operations. Held: the journeyman tier was re-skilled |
| Low-code/no-code (2014–2025) | Professional developers; CIOs | Customization walls, shadow IT | Multibillion-dollar niche; no programmer elimination; vendors pivot to AI | Unverified: Gartner's "70% of new applications by 2025" |

## The compiler fight set the template: skeptics lost on capability but won on hype

The first schism already contained every later argument. John Backus left two accounts of why programmers resisted FORTRAN, and both hold up. In his 1978 history the resistance was rational: earlier "automatic programming" systems "slowed the machine down by a factor of five or ten," and promoters had advertised "almost human abilities to understand the language and needs of the user" for what proved to be "a complex, exception-ridden performer of clerical tasks" ([Backus, HOPL](https://softwarepreservation.computerhistory.org/FORTRAN/paper/p25-backus.pdf)). In his 1976 talk it was status: programmers had come to see themselves as "a priesthood guarding skills and mysteries far too complex for ordinary mortals," "unalterably opposed to those mad revolutionaries who wanted to make programming so easy that anyone could [do] it" ([Backus, 1980 essay](https://softwarepreservation.computerhistory.org/FORTRAN/paper/Backus-ProgrammingInAmerica-1976.pdf)). Richard Hamming compressed the objections into a sequence every later schism repeated: "First, it was said it could not be done. Second, if it could be done, it would be too wasteful of machine time and capacity. Third, even if it did work, no respectable programmer would use it—it was only for sissies!" ([Hamming, 1997](https://www.goodreads.com/notes/53503835-the-art-of-doing-science-and-engineering/8557255-doug-lautzenheiser/f06a11a4-7a24-4dad-a858-c6e967dfe85d)). The democratizers were not neutral either. At Backus's 1976 talk a mathematician retorted that he "would've called the people on the opposite side a part of a priesthood" ([The New Stack](https://thenewstack.io/how-john-backus-fortran-beat-machine-codes-priesthood/)), an early sign that each abstraction breeds its own expert class.

The FORTRAN team won by treating the skeptics' strongest point as the design requirement. Backus believed that if FORTRAN produced code "only half as fast as its hand coded counterpart, then acceptance of our system would be in serious danger," so the optimizer, not the language, became "the real challenge"; its output "would startle the programmers who studied it" ([Backus, HOPL](https://softwarepreservation.computerhistory.org/FORTRAN/paper/p25-backus.pdf)). Adoption followed output, not argument: **by April 1958 over half of 26 surveyed IBM 704 installations used FORTRAN for more than half their problems, and by that fall more than half of all machine instructions on the roughly 66 installed 704s were compiler-generated** ([Backus, HOPL](https://softwarepreservation.computerhistory.org/FORTRAN/paper/p25-backus.pdf)). The boosters' predictions scored unevenly. IBM's 1954 report promised FORTRAN "should virtually eliminate coding and debugging" ([FORTRAN Preliminary Report](https://softwarepreservation.computerhistory.org/FORTRAN/FORTRAN_PreliminaryReport_1954.pdf)), which Backus later called "hopelessly optimistic." Its promise of near-hand-coded speed was made "more of faith than of knowledge" yet proved substantially right, its claim that FORTRAN might out-code "the normal human coder" turned out to be "a true statement," and the six-month schedule took more than two years. Grace Hopper's first compilers ended the same way: "nobody really believed it... It took two years before they began to accept that concept. They had to because it worked" ([Hopper, 1981 interview](https://web.archive.org/web/20171006153044/http://stories.vassar.edu/2017/assets/images/170706-legacy-of-grace-hopper-hopperpdf.pdf)). Her English-keyword prototype was vetoed not by programmers but by "Non-computerized management; Marketing particularly," to whom it was "perfectly obvious that a computer built in Philadelphia could not understand French and German" ([Hopper oral history, CHM](http://archive.computerhistory.org/resources/text/Oral_History/Hopper_Grace/102702026.05.01.pdf)). Her summary of the divide is the craft-versus-outcomes split in miniature: "A lot of our programmers liked to play with the bits. I wanted to get jobs done." ([Hopper, 1981 interview](https://web.archive.org/web/20171006153044/http://stories.vassar.edu/2017/assets/images/170706-legacy-of-grace-hopper-hopperpdf.pdf))

COBOL added the democratization promise and the status backlash that still travel together. The 1959 Pentagon meeting "agreed unanimously that more people should be able to program," in a language making "maximal use of English... even at the expense of power" ([Wikipedia, COBOL](https://en.wikipedia.org/wiki/COBOL)). Committee member Jean Sammet conceded that "people whose main interest is programming tend to be very unhappy with COBOL," textbook authors called it "verbose, clumsy and inelegant," and Dijkstra declared that it "cripples the mind; its teaching should, therefore, be regarded as a criminal offence" ([EWD498](https://www.cs.utexas.edu/~EWD/transcriptions/EWD04xx/EWD498.html)). The "stopgap" ran for decades, and it did not shrink the workforce: by the mid-1960s the US had roughly **100,000 programmers and demand for as many as 500,000 more**, and Fortune called programming "probably the country's highest paid technological occupation" ([Ensmenger, 2015](https://homes.luddy.indiana.edu/nensmeng/files/Ensmenger2015.pdf)). One caution for today's analogies: no primary 1959–60 source in the research says COBOL would *eliminate* programmers. The documented aim was widening access, and the "elimination" framing is a later gloss.

Underneath the technical dispute ran a fight over status and control that historian Nathan Ensmenger reconstructs. Managers depended on idiosyncratic talent they could neither predict nor replace, while programmers cultivated a "black art": "To be a devotee of a dark art, a high priest, or a sorcerer... was certainly preferable to being characterized as a glorified clerical worker" ([Ensmenger, 2015](https://homes.luddy.indiana.edu/nensmeng/files/Ensmenger2015.pdf)). That status project was gendered. ENIAC's women programmers were classed as "subprofessionals" although they held mathematics degrees ([Wikipedia, ENIAC](https://en.wikipedia.org/wiki/ENIAC)); aptitude tests used by more than two-thirds of employers filtered for people who preferred machines to people; and vendors advertised high-level languages with images of female secretaries, which "real programmers" then dismissed as "sissy stuff" ([Ensmenger, 2015](https://homes.luddy.indiana.edu/nensmeng/files/Ensmenger2015.pdf)). In Britain, Mar Hicks argues, the resulting labor shortage "had been intentionally engineered by the refusal to continue to employ female technologists" ([The Guardian](https://www.theguardian.com/technology/2018/oct/11/tech-gender-problem-amazon-facebook-bias-women)). The 1968 NATO conference, which chose the label "software engineering" as "deliberately... provocative," shows technical resistance still alive a decade after FORTRAN. One designer would write an operating-system monitor in assembly again because "one cannot accept any control level between designer and machine," while another conceded compiled PL/I was "not as good as that of good bit twiddlers, but probably as good as that of the average programmer," adding that readable code let managers "move people around easier, or replace them easier" ([NATO 1968 report](http://homepages.cs.ncl.ac.uk/brian.randell/NATO/nato1968.PDF)). By 1986 Fred Brooks called high-level languages "the most powerful stroke for software productivity, reliability, and simplicity," noting that most observers credited them with "at least a factor of five in productivity" ([Brooks, "No Silver Bullet"](https://www.cs.unc.edu/techreports/86-020.pdf)).

## Discipline and craft each built gates against newcomers

Dijkstra's 1968 letter, submitted as "A Case against the GO TO Statement" and retitled by editor Niklaus Wirth ([EWD1308](https://www.cs.utexas.edu/users/EWD/transcriptions/EWD13xx/EWD1308.html)), opened a twenty-year war in which three camps meant different things by "structured programming." For Dijkstra it meant intellectual control: "the quality of programmers is a decreasing function of the density of go to statements in the programs they produce" ([CACM letters compilation](https://www2.cs.arizona.edu/classes/cs372/spring17/gotoletters.pdf)). For managers it became a control program: advocates pitched it as a cure for the "vagaries of individual personality" in programming teams, and IBM's Harlan Mills promised that chief-programmer teams would make development "a true professional discipline with a recognized, standard methodology" ([Ensmenger & Aspray, 2002](https://homes.luddy.indiana.edu/nensmeng/files/Ensmenger2002.pdf)). Dijkstra complained that IBM "stole the term" and "trivialized the original concept to the abolishment of the goto statement" ([EWD1308](https://www.cs.utexas.edu/users/EWD/transcriptions/EWD13xx/EWD1308.html)), and labor sociologist Philip Kraft called it "the software manager's answer to the conveyor belt" ([Ensmenger & Aspray, 2002](https://homes.luddy.indiana.edu/nensmeng/files/Ensmenger2002.pdf)). For practitioners it threatened efficiency and freedom. Dijkstra received "a torrent of abusive letters" ([Knuth, 1974](https://pic.plover.com/knuth-GOTO.pdf)), and in 1987 Frank Rubin's counterattack ("like butchers banning knives because workers sometimes cut themselves... I have yet to see a single study") drew what the editor called a **"greater response by far than with any other issue ever considered in these pages"** before he closed the correspondence, with writers on both sides calling the dispute "religious" ([CACM letters compilation](https://www2.cs.arizona.edu/classes/cs372/spring17/gotoletters.pdf)). It ended where Donald Knuth's 1974 middle position had pointed: unrestricted goto vanished from mainstream languages, restricted forms such as C's error-cleanup jumps and labeled breaks survived, and by 1989 Hamming reported the consensus that goto "is used much too often but that it also has its place" ([CACM, Dec. 1989](http://www.psy.gla.ac.uk/~steve/educ/dijk/Dijkstra89cacm.pdf)). The "counterrevolution" Knuth feared never came.

Dijkstra's wider polemics built an academic gate. "Programming is one of the most difficult branches of applied mathematics; the poorer mathematicians had better remain pure mathematicians"; students exposed to BASIC were "mentally mutilated beyond hope of regeneration"; and "projects promoting programming in 'natural language' are intrinsically doomed to fail" ([EWD498](https://www.cs.utexas.edu/~EWD/transcriptions/EWD04xx/EWD498.html)). In 1988 he added that "automatic programming" was "a contradiction in terms" ([EWD1036](https://www.cs.utexas.edu/users/EWD/transcriptions/EWD10xx/EWD1036.html)). Hamming called this "Moses laying down the law to us sinners... both very right and very wrong" ([CACM, Dec. 1989](http://www.psy.gla.ac.uk/~steve/educ/dijk/Dijkstra89cacm.pdf)). The empirical predictions mostly failed: BASIC became the de facto language of the microcomputer era ([Wikipedia, BASIC](https://en.wikipedia.org/wiki/BASIC)), and IBM-dependent companies did not collapse under "unmastered complexity." The conceptual claims became canon. The structured canon also excluded people: Sherry Turkle and Seymour Papert found that "discrimination in the computer culture takes the form of discrimination against epistemological orientations," with nine of fifteen women but only four of fifteen men favoring the marginalized "soft" style ([Turkle & Papert, 1990](https://dailypapert.com/wp-content/uploads/2020/07/turkle_papert_1990.pdf)).

The craft camp built the opposite gate. Ed Post's 1983 "Real Programmers Don't Use Pascal" was satire, but its premise was genuine displacement anxiety: "The Real Programmer is in danger of becoming extinct, of being replaced by high school students with TRASH-80s," or by "12 year old Pac-Man players (at a considerable salary savings)." Graduates were "soft—protected from the realities of programming by source level debuggers, text editors that count parentheses, and 'user friendly' operating systems," and patching binaries so that no structured programmer could follow "is called 'job security'" ([Post, Datamation](https://www.pbm.com/~lindahl/real.programmers.html)). "The Story of Mel" answered sincerely: Mel "didn't approve of compilers," and in Ed Nather's telling his hand-tuned code always beat the optimizing assembler ([Jargon File](http://www.catb.org/jargon/html/story-of-mel.html)). The Jargon File preserved both views, defining the Real Programmer as someone who "thinks that HLLs are sissy," "arrogant even when justified by experience," whose successors "consider it a Good Thing that there aren't many Real Programmers around any more" ([Jargon File](http://www.catb.org/jargon/html/R/Real-Programmer.html)). Ensmenger reads the archetype as a masculine identity in which "individual artistic genius, personal eccentricity, antiauthoritarian behavior" became sources of professional authority ([Ensmenger, 2015](https://homes.luddy.indiana.edu/nensmeng/files/Ensmenger2015.pdf)), and Aurynn Shaw's 2015 "Contempt Culture" shows the machinery still running: "I... was permitted status - as long as I participated in gate keeping" ([Shaw](https://blog.aurynn.com/2015/12/16-contempt-culture)). The two gates despised each other yet shut out the same people: BASIC hobbyists, COBOL business programmers and, later, end users. As early as 1987 a CACM letter warned about "'end user' tools intended to produce programs without the involvement of programmers" ([CACM letters compilation](https://www2.cs.arizona.edu/classes/cs372/spring17/gotoletters.pdf)).

The language wars that followed show how such fights actually end. Brian Kernighan's 1981 verdict that standard Pascal was "a toy language, suitable for teaching but not for real programming" turned on control ("There is no escape"), and C, which kept casts and pointers as escape hatches, displaced Pascal by the early 1990s ([Kernighan](https://www.cs.virginia.edu/~evans/cs655/readings/bwk-on-pascal.html); [Wikipedia, Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language))). Assembly never lost a debate. As hardware sped up it retreated to hot spots, becoming "a tool for speeding up parts of programs, such as the rendering of Doom" ([Wikipedia, Assembly language](https://en.wikipedia.org/wiki/Assembly_language)). The hackers' own dictionary diagnosed these "holy wars" as disputes in which participants "pass off personal value choices and cultural attachments as objective technical evaluations," which "happens precisely because... the actual substantive differences between the sides are relatively minor" ([Jargon File, "holy wars"](http://www.catb.org/jargon/html/H/holy-wars.html)). Later data agree: across hundreds of thousands of projects, "open source libraries, existing code, and experience" drive language adoption, while "performance, reliability, and simple semantics do not" ([Meyerovich & Rabkin, 2013](https://lmeyerov.github.io/projects/socioplt/papers/oopsla2013.pdf)).

## Every promise to abolish programmers failed while the profession grew

From 1981 to 2025 a parallel line of products promised to take programmers out of the loop, and each failed at elimination while succeeding, if at all, in a bounded niche. James Martin's 1982 *Application Development Without Programmers* made the economic case that recurs in every later pitch: computers had become "cheaper than people," so "most computers in the future will have to work at least in part without programmers," and he predicted that programmers "will instinctively resist" ([Willison quoting Martin](https://simonwillison.net/2025/Jul/14/application-development-without-programmers/)). Fourth-generation languages survived in reporting, databases and statistics packages, while the label "4GL" became "a rather vague term that was primarily used for marketing purposes" ([Wikipedia, 4GL](https://en.wikipedia.org/wiki/Fourth-generation_programming_language)). A year earlier a British program generator called The Last One was billed by its author as "the last human-produced program that needs to be written," and New Scientist headlined it "A terminal case for programmers" ([Wikipedia, The Last One](https://en.wikipedia.org/wiki/The_Last_One_(software))). Even its most enthusiastic reviewer conceded that the generated programs ran "between 100 and 200 lines," that "there's a lot more to program writing than just putting in simple flowcharts," and that market expansion "will surely improve the employment prospects for data processing professionals rather than diminish them" ([Tebbutt, Personal Computer World, 1981](http://www.tebbo.com/archive/pw8102.htm)). That is the Jevons argument, forty-four years before Satya Nadella tweeted it.

CASE tools made the substitution explicit: with developer labor scarce, "it makes good sense to substitute development capital in the form of CASE tools," and by 1990 more than 100 vendors offered nearly 200 tools ([Kemerer, 1992](https://sites.pitt.edu/~ckemerer/CK%20research%20papers/LearningCurveAffectsCASEAdoption_Kemerer92.pdf); [Wikipedia, CASE](https://en.wikipedia.org/wiki/Computer-aided_software_engineering)). Analysts' promised payback within six to twelve months collided with reality: **one year after introduction, 70% of CASE tools and techniques were never used and only 5% were widely used**, because "the first project written with an integrated CASE tool typically fails to deliver improved results" ([Kemerer, 1992](https://sites.pitt.edu/~ckemerer/CK%20research%20papers/LearningCurveAffectsCASEAdoption_Kemerer92.pdf)). Wanda Orlikowski's fieldwork captured both the managerial fantasy and the developer split. A consulting-firm manager boasted, "we can take a kid out of school, let's say with a major in English, and in a very short time he can achieve... the productivity level of a client programmer with ten years experience." Technically oriented developers saw a threat, and one who resigned said "the things I was learning are not marketable"; business-oriented colleagues welcomed the tools because "no one comes to SCC to be a programmer" ([Orlikowski, 1993](https://dspace.mit.edu/handle/1721.1/2475)). Big CASE died with the mainframe. KnowledgeWare's executives faced SEC fraud actions, and co-founder Fran Tarkenton is credited with the epitaph "A fool with a tool is a faster fool" ([Wikipedia, KnowledgeWare](https://en.wikipedia.org/wiki/KnowledgeWare)).

The pattern held at national scale. Japan's Fifth Generation project spent more than $400 million on reasoning machines before the government offered its software to anyone because, in Edward Feigenbaum's words, "no one is using the technology"; some American scientists admitted privately that colleagues had overstated the threat "to coax more support from the United States Government" ([New York Times, 1992](https://www.nytimes.com/1992/06/05/business/fifth-generation-became-japan-s-lost-generation.html)). The "fifth-generation language" dream stalled because deriving an efficient algorithm from a problem's constraints "still requires the insight of a human programmer" ([Wikipedia, 4GL](https://en.wikipedia.org/wiki/Fourth-generation_programming_language)). In 2001 the Object Management Group promised that Model Driven Architecture "future-proofs you for at least the next twenty years" ([OMG](https://www.omg.org/mda/executive_overview.htm)); Martin Fowler called it "Night of the Living Case Tools" ([Fowler, 2004](https://martinfowler.com/bliki/ModelDrivenArchitecture.html)), and a 2013 study found 35 of 50 professional developers did not use UML at all and only 3 generated code from it ([Petre, via Lethbridge](http://tims-ideas.blogspot.com/2013/05/uml-in-practice-talk-at-icse-and-how.html)). Low-code repeated the cycle with better marketing. Gartner forecast in 2021 that "**by 2025, 70% of new applications developed by organizations will use low-code or no-code technologies**, up from less than 25% in 2020" ([Gartner, Nov. 2021](https://www.gartner.com/en/newsroom/press-releases/2021-11-10-gartner-says-cloud-will-be-the-centerpiece-of-new-digital-experiences)) and projected a $26.9 billion market for 2023 ([Gartner, Dec. 2022](https://www.gartner.com/en/newsroom/press-releases/2022-12-13-gartner-forecasts-worldwide-low-code-development-technologies-market-to-grow-20-percent-in-2023)), while conceding that "'no code' is not a sufficient criterion for tasks like citizen development" ([Gartner, Feb. 2021](https://www.gartner.com/en/newsroom/press-releases/2021-02-15-gartner-forecasts-worldwide-low-code-development-technologies-market-to-grow-23-percent-in-2021)). No independent measurement ever checked the 70% figure. More than 40% of developer questions about low-code platforms concern customization ([Alamin et al., 2021](https://arxiv.org/abs/2103.11429)), and by 2026 OutSystems, the category's unicorn, described itself as "an AI development platform" ([Wikipedia, OutSystems](https://en.wikipedia.org/wiki/OutSystems)).

The one clear success is instructive. Brooks singled out spreadsheets and simple databases as "dramatic exceptions": applications "that would formerly have been written as custom programs in Cobol or Report Program Generator" now needed no programmer ([Brooks, "No Silver Bullet"](https://www.cs.unc.edu/techreports/86-020.pdf)). A 2005 estimate projected more than 55 million US end-user programmers by 2012 against fewer than 3 million professionals ([Wikipedia, End-user development](https://en.wikipedia.org/wiki/End-user_development)). Professional programming kept growing anyway, and inside accounting the spreadsheet reshuffled rather than erased work: since 1980, **400,000 bookkeeping and accounting-clerk jobs disappeared while 600,000 accountant jobs were added**, because "accounting basically became cheaper... people buy a lot more of that thing" ([NPR Planet Money](https://www.npr.org/transcripts/389027988)). Brooks's distinction between essential and accidental difficulty explains why the grander promises failed: "Unless it is more than 9/10 of all effort, shrinking all the accidental activities to zero time will not give an order of magnitude improvement." David Parnas supplied the field's best one-line history: "automatic programming always has been a euphemism for programming with a higher-level language than was presently available to the programmer" ([Brooks, "No Silver Bullet"](https://www.cs.unc.edu/techreports/86-020.pdf)).

## Paradigm and tooling wars ended in synthesis, and yesterday's crutch became "by hand"

The paradigm and tooling wars of 1985–2025 rarely produced a winner. They produced a synthesis, and the contested aid became the baseline. Object orientation arrived with industrial promises, notably Brad Cox's catalogs of reusable "software ICs," and even Brooks admitted in 1986 that he held "more hope for object-oriented programming than for any of the other technical fads of the day" while doubting it would deliver a tenfold gain ([Brooks](https://www.cgl.ucsf.edu/Outreach/pc204/NoSilverBullet.html)). The backlash came largely from designers of rival paradigms. Alexander Stepanov called object orientation "almost as much of a hoax as Artificial Intelligence" ([Stepanov interview](https://web.archive.org/web/2015/http://www.stlport.org/resources/StepanovUSA.html)); Joe Armstrong complained, "You wanted a banana but what you got was a gorilla holding the banana and the entire jungle" ([Cook, quoting *Coders at Work*](https://www.johndcook.com/blog/2011/07/19/you-wanted-banana/)); Paul Graham tied it to "large (and frequently changing) teams of mediocre programmers" ([Graham](http://www.paulgraham.com/noop.html)); and Alan Kay, who coined the term, said he "did not have C++ in mind" ([Wikiquote](https://en.wikiquote.org/wiki/Alan_Kay)). The settlement: every major language supports objects, Go ships with "no type hierarchy" ([Go FAQ](https://go.dev/doc/faq)), a commercial study found no major productivity difference between object-oriented and procedural development ([Wikipedia, OOP](https://en.wikipedia.org/wiki/Object-oriented_programming)), and Cox's own company ended up "far from the Intel of software" ([De Programmatica Ipsum](https://deprogrammaticaipsum.com/brad-cox/)). Reuse did arrive, but through free packages rather than purchased parts.

Managed memory reran the compiler debate with a new deskilling charge. Early Java virtual machines were interpreters, and "Java is slow" was accurate until just-in-time compilation (1997) and HotSpot (2000) closed most of the gap ([Wikipedia, Java performance](https://en.wikipedia.org/wiki/Java_performance)). Rob Pike diagnosed the holdouts in identity terms: C++ programmers "have fought hard to gain exquisite control of their programming domain, and don't want to surrender any of it... Go's success would contradict their world view" ([Pike, 2012](https://commandcenter.blogspot.com/2012/06/less-is-exponentially-more.html)). Educators made the skills argument. Joel Spolsky warned that Java "is not, generally, a hard enough programming language that it can be used to discriminate between great programmers and mediocre programmers" ([Spolsky, 2005](https://www.joelonsoftware.com/2005/12/29/the-perils-of-javaschools-2/)), and Robert Dewar and Edmond Schonberg charged that Java-first curricula produced a student "who knows how to put a simple program together, but does not know how to program," concluding, "We are training easily replaceable professionals" ([Dewar & Schonberg, 2008](https://www.cs.fsu.edu/~gaitrosd/classes/CEN4010/Articles/DewarSchonberg.pdf)). Nobody tested those predictions. Instead the industry removed manual memory management: managed languages dominate 2025 usage (JavaScript 66%, Python 57.9%, Java 29.4%, C# 27.8%) ([Stack Overflow 2025 survey](https://survey.stackoverflow.co/2025/technology)), and garbage collection loses only at latency-critical edges, as when Discord's Go service suffered spikes "roughly every 2 minutes" and moved to Rust ([Discord](https://discord.com/blog/why-discord-is-switching-from-go-to-rust)). Spolsky's 2002 line remains the most portable lesson: "the abstractions save us time working, but they don't save us time learning" ([Spolsky, "Leaky Abstractions"](https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/)).

The typing war resolved by merger. In 2003 Robert C. Martin, a self-described "statically typed bigot" converted by test-driven development, asked, "Will we all be programming in a dynamically typed language in 2010?" ([Martin, Artima](https://www.artima.com/weblogs/viewpost.jsp?thread=4639)). The evidence split the difference: annotating 400 fixed JavaScript bugs showed type checkers would have caught about **15% (95% CI 11.5–18.5%)** ([Gao, Bird & Barr, 2017](https://www.microsoft.com/en-us/research/wp-content/uploads/2017/09/gao2017javascript.pdf)), and a reanalysis of a prominent study linking languages to defects found the effects "exceedingly small" ([Berger et al., 2019](https://dl.acm.org/doi/10.1145/3340571)). Scale and tooling decided it. Dropbox type-checked 4 million lines of Python ([Dropbox](https://dropbox.tech/application/our-journey-to-type-checking-4-million-lines-of-python)), and in August 2025 TypeScript became GitHub's most-used language, a rise GitHub partly credits to AI because "typed systems help identify LLM-generated compile errors earlier in the pipeline" ([GitHub Octoverse 2025](https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/)). David Heinemeier Hansson, who stripped TypeScript out of Turbo 8, supplied the sociology: programmers are "drawn strongly to typing or not quite early in their career, and then spend the rest of it rationalizing The Correct Choice" ([DHH, 2023](https://world.hey.com/dhh/turbo-8-is-dropping-typescript-70165c01)).

The vi–Emacs "holy war," with Unix programmers split roughly 50/50 ([Wikipedia, Editor war](https://en.wikipedia.org/wiki/Editor_war)), was tribal; the substantive fight was over machine assistance, and it is the direct ancestor of today's. Charles Petzold's 2005 talk "Does Visual Studio Rot the Mind?" reads like a 2026 essay about AI. IntelliSense was "making us dumber"; "I don't need to remember anything any more. IntelliSense will remember it for me"; "The real objective is for us to become faster programmers, which also means that it's cheapening our labor." He conceded it was "a technology that is inevitable" and declined to "go cold turkey" ([Petzold](https://web.archive.org/web/2023/http://www.charlespetzold.com/etc/DoesVisualStudioRotTheMind.html)). He was right about inevitability, and nobody ever measured the rot. By 2024 Steve Yegge described "chat-first" as the default, with "writing by hand (with completions, naturally!)" as the fallback ([Yegge](https://sourcegraph.com/blog/the-death-of-the-junior-developer)), and in 2026 the Linux kernel exempted "typing aids like identifier completion" from disclosure while requiring it when "a chatbot generated a new function in your patch" ([Linux kernel docs](https://docs.kernel.org/process/generated-content.html)). In 2025, VS Code was used by 75.9% of developers and the AI-native editor Cursor already by 17.9% ([Stack Overflow 2025 survey](https://survey.stackoverflow.co/2025/technology)). Each generation moves the line of what counts as cheating.

Visual Basic supplies the closest historical analogue to the vibe coder. Microsoft designed Visual Studio 2005 around three personas, Mort, "the opportunistic developer" who "learns as needed," Elvis the pragmatist and Einstein "the paranoid programmer," which mapped "very loosely to Visual Basic, C# and C++" ([Anderson](https://www.itwriting.com/blog/399-are-you-mort-elvis-or-einstein.html); [Atwood](https://blog.codinghorror.com/mort-elvis-einstein-and-you/)). Java developers turned Mort into a slur for the "stupid idiot programmer who doesn't understand what's going on and just clicks through the wizards" ([Neward, InfoWorld](https://www.infoworld.com/article/2157488/mort-means-productivity.html)). VB's own language designer offered the rebuttal that fits today: "most people are usually Mort, Elvis and Einstein all at the same time, depending on what they're doing" ([Vick](https://www.panopticoncentral.net/2006/04/26/i-hate-mort-sort-of/)).

The most recent resolved schism shows that institutions, not arguments, now settle these fights. When Rust entered the Linux kernel, Ted Ts'o objected, "you're not going to force all of us to learn Rust" ([The Register](https://www.theregister.com/2024/09/02/rust_for_linux_maintainer_steps_down/)), and Christoph Hellwig vowed "I will do everything I can do to stop this," calling a cross-language codebase (explicitly "not Rust itself") a "cancer" ([LKML](https://lkml.iu.edu/hypermail/linux/kernel/2501.3/06788.html); [The Register](https://www.theregister.com/2025/02/05/mixing_rust_and_c_linux/)). Linus Torvalds ruled that "if you as a maintainer feel that you control who or what can use your code, YOU ARE WRONG" ([LKML](https://lkml.iu.edu/hypermail/linux/kernel/2502.2/08504.html)); Google reported that memory-safety bugs fell from **76% of Android vulnerabilities in 2019 to 24% in 2024** ([Google Security Blog](https://security.googleblog.com/2024/09/eliminating-memory-safety-vulnerabilities-Android.html)); and in December 2025 the maintainers declared the experiment over, with Rust "here to stay" ([LWN](https://lwn.net/Articles/1049831/)). Two prominent Rust contributors quit along the way, one citing "nontechnical nonsense" ([The Register](https://www.theregister.com/2024/09/02/rust_for_linux_maintainer_steps_down/)).

## The web era turned "not real programming" into a status weapon

The web gave the "not real programming" charge its widest target. JavaScript was written in ten days for people "who didn't know what a compiler was... It was like Basic," under marketing orders not to make it "too big for its britches," a "silly little brother language" to Java ([Eich, via The New Stack](https://thenewstack.io/brendan-eich-on-creating-javascript-in-10-days-and-what-hed-do-differently-today/)). Douglas Crockford observed in 2001 that "most of the people writing in JavaScript are not programmers," which gave the language "a reputation of being strictly for the amateurs... This is simply not the case" ([Crockford](https://www.crockford.com/javascript/javascript.html)); Jesse James Garrett recalls that before Ajax "you literally could not find a job as a JavaScript developer" ([Garrett, 2025](https://jessejamesgarrett.com/2025/02/18/ajax-at-20/)). Gmail, the V8 engine and Node.js then turned the toy into infrastructure, and by 2024 JavaScript had topped Stack Overflow's usage survey for twelve consecutive years ([Stack Overflow 2024 survey](https://survey.stackoverflow.co/2024/technology)). PHP's creator disclaimed craft outright: "I'm not a real programmer. I throw together things until it works then I move on... I'll just restart Apache every 10 requests" ([Lerdorf, Wikiquote](https://en.wikiquote.org/wiki/Rasmus_Lerdorf)). Critics obliged. Jeff Atwood called PHP a "galactic supernova of incomprehensibly colossal, mind-bendingly awful suck" but insisted "that doesn't matter" ([Atwood, 2008](https://blog.codinghorror.com/php-sucks-but-it-doesnt-matter/)), and "PHP: a fractal of bad design" called it "a blight upon my craft... lauded by every empowered amateur" ([Eevee, 2012](https://eev.ee/blog/2012/04/09/php-a-fractal-of-bad-design/)). In September 2026 PHP runs **69.8% of websites whose server-side language is known**, and WordPress runs **40.2% of all websites** ([W3Techs, PHP](https://w3techs.com/technologies/details/pl-php); [W3Techs, WordPress](https://w3techs.com/technologies/details/cm-wordpress)). Facebook engineered around PHP's flaws with a compiler, a JIT virtual machine and the typed Hack dialect rather than rewrite ([Wikipedia, HHVM](https://en.wikipedia.org/wiki/HHVM)). The critics were right about the language and wrong about the consequences, and the ecosystem absorbed their demands through Crockford's "good parts," linters and finally TypeScript.

The status line also ran along gender and job category. Miriam Posner documented the belief that "front-end dev work isn't real engineering," the typecasting of women into it, and a pay gap of about **$30,000** between front-end developers and back-end roles such as DevOps; her mechanism, "prestige accrues to labor scarcity, and masculinity accrues to prestige," describes the whole history of the field ([Posner, Logic](https://logicmag.io/intelligence/javascript-is-for-girls/)). Brad Frost added that "'full-stack developers' always translates to 'programmers who can do front-end code because they have to and it's easy'" ([Coyier, CSS-Tricks](https://css-tricks.com/the-great-divide/)).

Frameworks and packages moved the line again. Jose Aguinaga's 2016 parody of framework churn ends with the exhausted learner retreating: "I'm just going to move back to the backend" ([Aguinaga](https://hackernoon.com/how-it-feels-to-learn-javascript-in-2016-d3a717dd577f)). After left-pad, an 11-line package whose March 2016 removal from npm broke builds across the industry until npm restored it and restricted unpublishing ([Wikipedia, left-pad](https://en.wikipedia.org/wiki/Npm_left-pad_incident)), David Haney asked "Have We Forgotten How To Program?" He answered that "stringing APIs together and calling it programming doesn't make it programming" and proposed a screening test: write left-pad "in 5 minutes flat (including the time you spend Googling)" ([Haney](https://www.davidhaney.io/npm-left-pad-have-we-forgotten-how-to-program/)). He was right about fragility, a risk that returned in 2025 as "slopsquatting" after researchers found 16 code-generating models inventing **205,474 unique nonexistent package names** that attackers could register ([Wikipedia, Slopsquatting](https://en.wikipedia.org/wiki/Slopsquatting)). His parenthetical about Googling shows how far norms had already moved.

Stack Overflow is the cleanest template of how a stigmatized practice evolves. Mockery came first, in parody book covers. Evidence followed: informal sources produced less secure code than official documentation ([Acar et al., 2016](https://www.cs.umd.edu/class/fall2022/cmsc614/papers/get-where-look.pdf)), and **15.4% of 1.3 million Android apps contained security-related Stack Overflow snippets, 97.9% of which included at least one insecure snippet** ([Fischer et al., 2017](https://www.ieee-security.org/TC/SP2017/papers/7.pdf)). Then came normalization: Heinemeier Hansson confessed, "I would fail to write bubble sort on a whiteboard. I look code up on the internet all the time" ([DHH](https://x.com/dhh/status/834146806594433025)), and in 2021 Stack Overflow reported that one in four visitors copies something within five minutes and told users to "forgive yourself!" ([Stack Overflow blog](https://stackoverflow.blog/2021/12/30/how-often-do-people-actually-copy-and-paste-from-stack-overflow-now-we-know/)). Finally, displacement: new questions, which peaked near 200,000 a month in 2014, **fell 78% between December 2024 and December 2025** ([Wikipedia, Stack Overflow](https://en.wikipedia.org/wiki/Stack_Overflow)). The security studies were then re-run on AI almost verbatim. Users with an AI assistant "wrote significantly less secure code" and were more likely to believe it secure ([Perry et al.](https://arxiv.org/abs/2211.03622)), and 52% of ChatGPT answers to Stack Overflow questions contained incorrect information ([Kabir et al., CHI 2024](https://dl.acm.org/doi/10.1145/3613904.3642596)). As one engineer put it, "We've gone from copying code we don't understand from StackOverflow to copying code we don't understand from AI" ([Gardner, TrackJS](https://dev.to/trackjs/from-stackoverflow-to-vibe-coding-the-evolution-of-copy-paste-development-4ngl)).

Bootcamps tested credential gatekeeping head-on. Dev Bootcamp opened in 2012 ([Wikipedia](https://en.wikipedia.org/wiki/Dev_Bootcamp)), Atwood replied "Please Don't Learn to Code" ([Atwood, 2012](https://blog.codinghorror.com/please-dont-learn-to-code/)), and interview rituals became the gate, as in Homebrew creator Max Howell's rejection: "Google: 90% of our engineers use the software you wrote (Homebrew), but you can't invert a binary tree on a whiteboard so fuck off" ([Howell](https://x.com/mxcl/status/608682016205344768)). The data split the difference. A 2016 Triplebyte comparison found bootcamp graduates as good as or better than degree holders at practical programming and web system design but weaker on algorithms ([InfoWorld](https://www.infoworld.com/article/2250588/coding-boot-camp-grads-write-better-code.html)), and in a 2017 Indeed survey 72% of employers rated them "just as prepared" ([Campus Technology](https://campustechnology.com/articles/2017/05/03/4-out-of-5-companies-have-hired-a-coding-bootcamp-graduate.aspx)). The business proved fragile, with closures in 2017 and a second contraction in 2023–25 ([EdSurge](https://www.edsurge.com/news/2017-07-20-another-major-coding-bootcamp-iron-yard-announces-closure); [Course Report](https://www.coursereport.com/blog/2024-year-in-review-coding-bootcamp-news)), and the slogan inverted. "Learn to code" became a harassment meme in 2019 ([The Ringer](https://www.theringer.com/2019/01/29/tech/learn-to-code-twitter-abuse-buzzfeed-journalists)), and in 2024 Nvidia's Jensen Huang said, "It is our job to create computing technology such that nobody has to program" ([Tom's Hardware](https://www.tomshardware.com/tech-industry/artificial-intelligence/jensen-huang-advises-against-learning-to-code-leave-it-up-to-ai)).

## Open source, Agile, offshoring and DevOps were fights over control, not code

The ethical schism began with Bill Gates's 1976 "Open Letter to Hobbyists": "most of you steal your software... Who can afford to do professional work for nothing?" ([Gates, Homebrew newsletter](https://archive.org/details/hcc0201)). The hobbyists' practical answer was Jim Warren's argument that software "free, or so inexpensive that it's easier to pay for it than to duplicate it... won't be 'stolen'," shipped as Tiny BASIC under the joke notice "COPYLEFT ALL WRONGS RESERVED" ([Wikipedia, Tiny BASIC](https://en.wikipedia.org/wiki/Tiny_BASIC)). Richard Stallman turned sharing into an ethic: "the golden rule requires that if I like a program I must share it" ([GNU announcement, 1983](https://www.gnu.org/gnu/initial-announcement.html)), since under proprietary licensing "the purchaser of software must choose between friendship and obeying the law," and his Manifesto predicted that programmers would still be paid, "just not paid as much as now" ([GNU Manifesto](https://www.gnu.org/gnu/manifesto.html)). Microsoft's private 1998 "Halloween" memo was more accurate than its public rhetoric, judging open source "long-term credible... FUD tactics can not be used to combat it" ([Halloween Document I](http://www.catb.org/~esr/halloween/halloween1.html)). In public, Steve Ballmer called Linux "a cancer that attaches itself in an intellectual property sense to everything it touches" ([The Register, 2001](https://www.theregister.com/2001/06/02/ballmer_linux_is_a_cancer/)), and Craig Mundie warned of the GPL's "viral aspect" and "unhealthy 'forking'" ([Microsoft transcript](https://news.microsoft.com/speeches/speech-transcript-craig-mundie-the-new-york-university-stern-school-of-business/)). The resolution was total. SCO dropped "any allegations that Linux violates SCO's Unix intellectual property" in a $14.25 million settlement ([Practical Tech](https://practical-tech.com/2021/11/08/last-of-original-sco-v-ibm-linux-lawsuit-settled/)); Satya Nadella declared that "Microsoft loves Linux" in 2014 ([The Register](https://www.theregister.com/2014/10/20/microsoft_cloud_event/)); Microsoft bought GitHub for $7.5 billion in 2018 ([Microsoft](https://news.microsoft.com/2018/06/04/microsoft-to-acquire-github-for-7-5-billion/)); IBM paid about $34 billion for Red Hat ([Red Hat](https://www.redhat.com/en/about/press-releases/ibm-closes-landmark-acquisition-red-hat-34-billion-defines-open-hybrid-cloud-future)); and in 2020 Microsoft's president admitted the company "was on the wrong side of history" ([The Register](https://www.theregister.com/2020/05/15/microsoft_brad_smith_open_source/)).

The 1998 split inside the movement set the template for today's naming fights. "Open source" was coined in February 1998, days after Netscape said it would release its browser code, to fix what Christine Peterson described as a problem of clarity: "No political issues were raised" ([Peterson](https://opensource.com/article/18/2/coining-term-open-source-software)). Stallman read it as flight from ethics: "The free software movement campaigns for freedom for the users of computing... By contrast, the open source idea values mainly practical advantage and does not campaign for principles" ([Stallman](https://www.gnu.org/philosophy/open-source-misses-the-point.html)). The pragmatists won the industrial label, and the ethicists kept setting the tests of legitimacy. When MongoDB, Elastic, HashiCorp and Redis moved to "source-available" licenses to stop cloud vendors who "capture all of the value while contributing little back" ([MongoDB](https://www.mongodb.com/press/mongodb-issues-new-server-side-public-license-for-mongodb-community-server)), the Open Source Initiative branded the licenses "fauxpen" ([OSI](https://opensource.org/blog/the-sspl-is-not-an-open-source-license)), foundation-backed forks (OpenSearch, OpenTofu, Valkey) carried on, and Elastic and Redis re-added the copyleft AGPL, with Redis conceding that its change had "hurt our relationship with the Redis community" ([Redis, 2025](https://redis.io/blog/agplv3/); [Elastic, 2024](https://www.elastic.co/blog/elasticsearch-is-open-source-again)). The forking Mundie feared became the commons' main defense. The unsolved problem was labor: the xz maintainer wrote in 2022 that "this is an unpaid hobby project" ([xz-devel](https://www.mail-archive.com/xz-devel@tukaani.org/msg00567.html)), two years before a patient attacker's backdoor was discovered in it ([oss-security](https://www.openwall.com/lists/oss-security/2024/03/29/4)).

The process war shows what happens when a movement wins its vocabulary. Winston Royce's 1970 paper called single-pass development "risky and invites failure" ([Hogarth, re-reading Royce](https://samhogy.co.uk/2023/07/re-reading-royce/)), yet his diagram became "waterfall," and the Pentagon mandated it for contractors in 1985 before reversing in 1994 toward "iterative and incremental development" ([Wikipedia, Waterfall model](https://en.wikipedia.org/wiki/Waterfall_model)). The 2001 Agile Manifesto's authors insisted they were "not anti-methodology," only against "hundreds of pages of never-maintained and rarely-used tomes" ([Agile Manifesto history](https://agilemanifesto.org/history.html)). Agile won the name: **71% of surveyed organizations use it**, but only **13% say it is deeply embedded** and **74% run hybrid or homegrown approaches** ([17th State of Agile](https://www.businesswire.com/news/home/20240116199385/en/17th-State-of-Agile-Report-71-Use-Agile-in-their-SDLC-Small-Organizations-Report-Strong-Business-Benefits-Medium-and-Larger-Sized-Companies-Continue-to-Experience-Barriers-in-Successfully-Scaling-Agile); [18th State of Agile](https://www.meriroos.ee/Stuff/Digital-ai-18th-State-of-Agile.pdf)). Its founders became its sharpest critics. Dave Thomas wrote in 2014 that "the word 'agile' has been subverted to the point where it is effectively meaningless" ([Thomas](https://pragdave.me/thoughts/active/2014-03-04-time-to-kill-agile.html)), and Martin Fowler condemned "faux-agile" and "the Agile Industrial Complex imposing methods upon people" ([Fowler, 2018](https://martinfowler.com/articles/agile-aus-2018.html)). AI has reopened the oldest process fight: one critic says spec-driven agent development "reminds me of the Waterfall model" and exists to answer "How do we remove developers from software development?" ([Zaninotto, Marmelab](https://marmelab.com/blog/2025/11/12/spec-driven-development-waterfall-strikes-back.html)).

Offshoring is the closest completed precedent for today's labor panic, because forecasters targeted the same occupation. Ed Yourdon predicted in 1992 that the American programmer would go "the way of the Dodo bird by the end of that decade" ([Datamation](https://www.datamation.com/careers/american-programmers-still-alive-and-kicking/)), then reversed himself in 1996 as the web boom arrived ([Wikipedia](https://en.wikipedia.org/wiki/Rise_and_Resurrection_of_the_American_Programmer)). Forrester forecast 3.3 million US services jobs offshore by 2015 ([CFO/McKinsey Quarterly](https://www.cfo.com/news/exploding-the-myths-of-offshoring/679667/)), Gartner said one in ten jobs at US IT vendors would move by the end of 2004 ([Datamation](https://www.datamation.com/careers/gartner-says-tech-jobs-will-continue-to-move-overseas/)), and Alan Blinder ranked **"computer programmers" the single most offshorable occupation in the US (index 100; 389,090 workers)** ([Blinder, Chicago Fed](https://www.chicagofed.org/-/media/others/events/2007/improving-economic-mobility/presentation-jobs-offshorable-pdf.pdf)). The panic outran the data. In early 2004, overseas relocation accounted for 4,633 of 239,361 extended mass-layoff separations, about 2% ([BLS](https://www.bls.gov/news.release/reloc.nr0.htm)), and Forrester's own analyst said the way his number was used "makes me a little mad" ([WSJ, via Post-Bulletin](https://www.postbulletin.com/news/behind-the-outsourcing-debate-few-hard-numbers)). The long-run outcome is the key data point for AI. The narrow "computer programmer" category shrank to **110,800 jobs in 2025, about 72% below Blinder's 2004 count**, while software developers numbered **1,717,800** ([BLS, programmers](https://www.bls.gov/ooh/computer-and-information-technology/computer-programmers.htm); [BLS, developers](https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm)), a comparison best read as orders of magnitude because occupational classifications changed. The Washington Post found fewer programmers than at any time since 1980 ([Fortune](https://fortune.com/2025/03/17/computer-programming-jobs-lowest-1980-ai/)), and the BLS now attributes the decline to automation "including artificial intelligence (AI)," not to offshoring ([BLS](https://www.bls.gov/ooh/computer-and-information-technology/computer-programmers.htm)). Protectionism returned as well, with a $100,000 fee on new H-1B petitions in 2025 ([NPR](https://www.npr.org/2025/09/20/nx-s1-5548568/h1b-visa-fee-trump-tech)).

Operations work has already survived a declared death. DevOps began in 2009 as a truce between developers and system administrators; "NoOps" (2011–12) turned it into a threat when Netflix's Adrian Cockcroft wrote that "there is no ops organization involved in running our cloud" ([Cockcroft](https://perfcap.blogspot.com/2012/03/ops-devops-and-noops-at-netflix.html)). Etsy's John Allspaw called that "Doing It Wrong," Geva Perry observed that "Ops guys are insulted and actually threatened economically," and Gene Kim called the term "so inflammatory" ([PCWorld](https://www.pcworld.com/article/469251/noops_debate_grows_heated.html)). The work was re-bundled, not abolished. Google's site reliability engineering is "what happens when you ask a software engineer to design an operations team" ([Google SRE book](https://sre.google/sre-book/introduction/)), and the BLS still counts 323,600 system administrators with a projected decline of only 4% as tasks shift to "software developers focused on DevOps" ([BLS](https://www.bls.gov/ooh/computer-and-information-technology/network-and-computer-systems-administrators.htm)). Cloud skepticism ("There is no cloud, it's just someone else's computer") never stopped adoption ([Watterston](https://www.chriswatterston.com/article/my-there-is-no-cloud-sticker)); it resurfaced as economics, summed up in "You're crazy if you don't start in the cloud; you're crazy if you stay on it" ([a16z](https://a16z.com/the-cost-of-cloud-a-trillion-dollar-paradox/)), and 37signals saved nearly $2 million in its first full year off AWS ([The Register](https://www.theregister.com/2024/10/21/37signals_aws_savings/)).

## Seven patterns explain how every schism ended

**Capability skeptics lose, hype skeptics win, and elimination prophets have never been right.** Objections that a new abstraction could not work (efficient compiled code, a fast Java, a serious JavaScript) lost as engineering closed the gap. Objections that it was oversold usually won: FORTRAN did not "eliminate coding and debugging," most CASE tools sat unused instead of paying back within the promised year, MDA future-proofed nothing, and Gartner's 70% was never verified. Every prediction that a tool would eliminate programmers, from Martin, The Last One, Yourdon and NoOps alike, failed. Timelines ran long even for the winners. Hopper put the lag at "five to 10 years... It did for the compilers, it did for COBOL" ([Hopper oral history](http://archive.computerhistory.org/resources/text/Oral_History/Hopper_Grace/102702026.05.01.pdf)), consistent with Roy Amara's law that "we tend to overestimate the effect of a technology in the short run and underestimate the effect in the long run" ([Wikipedia, Roy Amara](https://en.wikipedia.org/wiki/Roy_Amara)).

**The work climbs a level, a routine tier shrinks, and the profession grows.** Bookkeepers gave way to accountants, "computer programmers" to software developers, journeyman sysadmins to site reliability engineers. Each abstraction removed a clerical layer and expanded the judgment layer, because cheaper software meant more software. A reader's reply to Matt Welsh's "The End of Programming" put it exactly: FORTRAN did not eliminate coding, "but it changed what the term 'coding' meant" ([CACM comments](https://cacm.acm.org/research/the-end-of-programming/)). Labor economics formalizes the point: automation displaces tasks, and net employment depends on complementarity and on how elastic demand is ([Autor, 2015](https://shapingwork.mit.edu/wp-content/uploads/2023/10/autor-2015-why-are-there-still-so-many-jobs-the-history-and-future-of-workplace-automation.pdf)). The mechanism has limits. James Bessen's two centuries of textile, steel and auto data show automation raising employment while demand is elastic and cutting it once demand saturates ([Bessen, 2019](https://academic.oup.com/economicpolicy/article-abstract/34/100/589/5709812)), and US bank tellers, the canonical ATM success story, fell to 364,100 by 2022 after decades of growth ([Wikipedia, Bank teller](https://en.wikipedia.org/wiki/Bank_teller)).

**Resistance is always part engineering and part status, and the mix is diagnosable.** Each episode wrapped a legitimate technical claim that proved right (slow early compilers, insecure Stack Overflow snippets, PHP's design, left-pad's fragility, CASE's learning curve) in status language: "sissy," "Quiche Eaters," "Mort," "empowered amateur," "not smart enough." The tell is evidence. When neither side had data, as with GOTO in 1987 or typing for decades, both reached for religious vocabulary, just as the Jargon File's "holy wars" entry predicts ([Jargon File](http://www.catb.org/jargon/html/H/holy-wars.html)). Heinemeier Hansson's "rationalizing The Correct Choice" and Pike's "world view" describe preferences that are identities first and arguments second.

**The "real programmer" line drops one rung per generation, and it falls hardest on newcomers, amateurs and women.** Machine coders sneered at FORTRAN users, Real Programmers at Pascal, C and C++ programmers at Java, back-end engineers at JavaScript, PHP and CSS, degree holders at bootcamp graduates, and nearly everyone at copy-pasters. The stigmatized group is usually the one the tool admitted: "subprofessional" ENIAC women, COBOL "code grinders," BASIC hobbyists, Morts, front-end developers. The share of US computer science graduates who were women peaked around 37% in 1984 and then declined ([Wikipedia, Women in computing](https://en.wikipedia.org/wiki/Women_in_computing)). In sociologist Andrew Abbott's terms these are jurisdictional contests in which a profession defends its "strategic heartland monopoly" ([Wikipedia, Andrew Abbott](https://en.wikipedia.org/wiki/Andrew_Abbott_(sociologist))). Adjacent crafts show the usual ending: the American Federation of Musicians banned the Moog synthesizer from union work, then admitted "synthesizer player" as a category once a musician persuaded it the instrument demanded skill ([Wikipedia, Synthesizer](https://en.wikipedia.org/wiki/Synthesizer)).

**Nobody is persuaded; fights end through output, tooling, network effects or fiat.** FORTRAN won when its object code startled experts, and Hopper's compiler had to be accepted "because it worked." P.J. Plauger recalled that no proof "brought them around one day sooner than they were ready to convince themselves" ([Wikipedia, Structured programming](https://en.wikipedia.org/wiki/Structured_programming)). JIT compilers, TypeScript's compatibility with JavaScript, npm's unpublish rule, the Pentagon's standards and Torvalds's rulings did the rest. The folk version of Max Planck's principle, that paradigms advance one funeral at a time, finds only mixed support: age barely mattered in scientists' acceptance of evolution, and older geologists adopted plate tectonics sooner than younger ones, although in the life sciences newcomers do flood a field after a dominant researcher dies ([Wikipedia, Planck's principle](https://en.wikipedia.org/wiki/Planck%27s_principle)). Communities move when defaults change, not when holdouts retire.

**The settlement is domestication with an escape hatch.** Restricted goto, gradual typing, composition over inheritance, hybrid Agile, the AGPL as the answer to free-riding, C's casts, and Google's finding that with Rust "interoperability is the new rewrite" ([Google Security Blog](https://security.googleblog.com/2024/09/eliminating-memory-safety-vulnerabilities-Android.html)) all follow the same logic: keep the new default and let experts drop down a level when they must. Amazon's CTO stated the norm after the microservices backlash: "Building evolvable software systems is a strategy, not a religion" ([Vogels](https://www.allthingsdistributed.com/2023/05/monoliths-are-not-dinosaurs.html)).

**Managers and vendors adopt the slogan and invert it, the founders disown it, and each wave carries a hope of cheaper, more replaceable programmers.** IBM "stole" structured programming, an "Agile Industrial Complex" sold certifications the founders despised, "4GL" became a marketing tag, "open source" shed its ethics, and "vibe coding," Simon Willison warned within weeks, was "already escaping its original intent" ([Willison](https://simonwillison.net/2025/Mar/19/vibe-coding/)). The managerial motive runs unbroken from 1968's "replace them easier" through the PL/I advertisement that implied "pretty little Susie Meyers" could program ([Ensmenger & Aspray](https://homes.luddy.indiana.edu/nensmeng/files/Ensmenger2002.pdf)), the CASE manager's English major and Dewar's "easily replaceable professionals." Labor-process theorists who predicted wholesale deskilling were wrong about the occupation (Ensmenger and Aspray judged management's claims "imagined ideals more than current reality") but right about particular tasks and tiers, which is where every real elimination happened. Eric Hobsbawm's reading of the Luddites, whose machine-breaking was "collective bargaining by riot" rather than hatred of machines ([Hobsbawm](https://libcom.org/article/machine-breakers-eric-hobsbawm)), fits developers better than the popular slur: they have rarely fought tools as such, and they fight the terms on which tools are deployed.

## AI coding reruns the old script almost line for line

Set beside this history, much of the 2021–2026 argument is a revival, sometimes a deliberate one. Salvatore Sanfilippo (antirez) resurrected the 1950s term "Automatic Programming" for AI-assisted development, which he expects to become "just 'the process of writing software'" ([antirez](https://antirez.com/news/159)). Andrej Karpathy's 2023 line "The hottest new programming language is English" ([Karpathy](https://x.com/karpathy/status/1617979122625712128)) restates COBOL's premise, and Dijkstra's "On the foolishness of 'natural language programming'" drew 448 points on Hacker News in April 2025 ([Hacker News](https://news.ycombinator.com/item?id=43564386)); AWS's Marc Brooker replied that "almost all programs are already specified in natural language. And always have been" ([Brooker](https://brooker.co.za/blog/2025/12/16/natural-language.html)). Vendor forecasts replay Gartner's 70%. Dario Amodei said in March 2025 that AI would be "writing 90 percent of the code" within three to six months ([Council on Foreign Relations](https://www.cfr.org/event/ceo-speaker-series-dario-amodei-anthropic)); an independent audit found roughly 50% of merged code was AI-written even at Anthropic as of October 2025 ([Redwood Research](https://blog.redwoodresearch.org/p/is-90-of-code-at-anthropic-being)). Cognition's Devin, launched as "the first AI software engineer," completed 3 of 20 tasks in an independent month-long test ([Answer.AI](https://www.answer.ai/posts/2025-01-08-devin.html)). The hype skeptics are winning on timelines again.

So are the capability optimists, as in every earlier episode. METR's 2025 randomized trial found experienced open-source maintainers **19% slower** with early-2025 tools while they believed they were 20% faster ([METR, 2025](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/)), a J-curve like CASE's first-project dip that Google's DORA program now calls a "verification tax" and "the tuition cost of transformation" ([InfoQ on DORA](https://www.infoq.com/news/2026/05/dora-roi-ai-assisted-dev-report/)). By early 2026 METR judged it "likely that developers are more sped up from AI tools now," although its experiment broke down when 30–50% of developers withheld tasks they would not do without AI ([METR, 2026](https://metr.org/blog/2026-02-24-uplift-update/)). The length of software tasks frontier agents complete with 50% reliability had been doubling about every seven months ([METR](https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/)). Karpathy went from calling agent output "slop" in October 2025 to doing 80% of his coding through agents by December ([Dwarkesh Podcast](https://www.dwarkesh.com/p/andrej-karpathy); [Karpathy](https://api.fxtwitter.com/karpathy/status/2015883857489522876)), and Donald Knuth, whose 1974 paper supplied the middle ground that settled the GOTO war, wrote in 2026 that after Claude solved an open problem he had worked on for weeks, "I'll have to revise my opinions about 'generative AI' one of these days" ([Knuth, "Claude's Cycles"](https://www-cs-faculty.stanford.edu/~knuth/papers/claude-cycles.pdf)).

The status script is intact. Karpathy defined vibe coding as giving in to the vibes and forgetting "that the code even exists" ([Wikipedia, Vibe coding](https://en.wikipedia.org/wiki/Vibe_coding)), which is Rasmus Lerdorf's "I throw together things until it works then I move on" with a model doing the throwing, and Microsoft's Mort with a chat window. Stack Overflow headlined a 2026 post "A new worst coder has entered the chat" ([Stack Overflow blog](https://stackoverflow.blog/2026/01/02/a-new-worst-coder-has-entered-the-chat-vibe-coding-without-code-knowledge/)) and opened its 2026 survey "for human developers only" ([Stack Overflow blog](https://stackoverflow.blog/2026/06/23/the-2026-developer-survey-is-now-open-for-human-developers-only/)). Professionals protect status by splitting categories, as front-end developers once split into JavaScript engineers and everyone else: **84% of developers use or plan to use AI tools, yet 72% say they do not vibe code** ([Stack Overflow 2025 survey](https://survey.stackoverflow.co/2025/ai)), a line Willison draws precisely when he says reviewed, tested, explainable AI output is "not vibe coding, it's software development" ([Willison](https://simonwillison.net/2025/Mar/19/vibe-coding/)). Karpathy rebranded the respectable version "agentic engineering" ([Karpathy](https://api.fxtwitter.com/karpathy/status/2019137879310836075)). The pro-tool side reuses Hopper and Atwood, as in Thomas Ptacek's "We are not, in our day jobs, artisans... Do it on your own time" and "Mediocre code: often fine" ([Ptacek](https://fly.io/blog/youre-all-nuts/)). The lament reuses Petzold: Karpathy reports he is "slowly starting to atrophy my ability to write code manually" ([Karpathy](https://api.fxtwitter.com/karpathy/status/2015883857489522876)). Even Post's joke about "soft" graduates has a successor in Steve Yegge's 2024 warning that "a lot of people picked a bad year to be a junior developer" ([Yegge](https://sourcegraph.com/blog/the-death-of-the-junior-developer)).

The quality evidence reruns the Stack Overflow studies. About 40% of early Copilot completions in security-relevant scenarios were vulnerable ([Pearce et al.](https://arxiv.org/abs/2108.09293)); Veracode's 2026 test found a 56% security pass rate for LLM-generated code, essentially unchanged from 55% a year earlier, and concluded that "syntax is solved, security is not" ([Veracode](https://www.veracode.com/blog/2026-genai-code-security-report-ai-risk/)); and GitClear's telemetry shows duplicated code blocks up 81% and refactoring moves down 70% relative to 2022 ([GitClear](https://www.gitclear.com/the_ai_code_quality_maintainability_gap)). Both are commercial vendors of scanning and analytics tools, but the direction matches the independent studies. As with PHP, the fix is arriving as tooling rather than abstinence, through types, tests and review rules, which is why GitHub credits AI for TypeScript's rise.

The labor script is intact too. The Washington Post suggested the collapse of the "computer programmer" category "may be the first sign of job loss to AI" ([Fortune](https://fortune.com/2025/03/17/computer-programming-jobs-lowest-1980-ai/)), the very category Blinder had called the most offshorable. The BLS projects **software-developer employment to grow 10% from 2025 to 2035 while "computer programmers" shrink 7%** ([BLS, developers](https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm); [BLS, programmers](https://www.bls.gov/ooh/computer-and-information-technology/computer-programmers.htm)). Indeed finds software postings up almost 15% since Claude Code's launch but still 27.5% below February 2020, with 71% of the growth in senior roles ([Indeed Hiring Lab](https://hiringlab.indeed.com/2026/07/08/ai-and-job-postings-from-destruction-to-creation/)). Satya Nadella invoked the "Jevons paradox" ([Nadella](https://x.com/satyanadella/status/1883753899255046301)), Personal Computer World's 1981 argument. The offshoring era's forecast inflation has its echo in "AI-washing." AI accounted for only 4.5% of announced US job cuts in 2025, and Oxford Economics suspects firms "dress up layoffs as a good news story" ([Fortune](https://fortune.com/2026/01/07/ai-layoffs-convenient-corporate-fiction-true-false-oxford-economics-productivity/)); AI then led all stated reasons for five straight months in 2026 before falling to fourth in August, and the tracking firm itself notes that "naming AI in a layoff announcement can win over investors" ([Challenger, July](https://www.challengergray.com/blog/challenger-report-layoffs-fall-hiring-picks-up-ai-leads-for-fifth-straight-month/); [Challenger, August](https://www.challengergray.com/blog/challenger-report-august-job-cuts-up-58-consumer-products-food-lead/)).

The ethics script replays 1976 and 1998 with the roles reversed. Gates accused hobbyists of piracy; in 2022 open-source developers sued GitHub, Microsoft and OpenAI over what they called "unprecedented open-source software piracy" ([Copilot litigation](https://githubcopilotlitigation.com/)). On September 16, 2026, the Ninth Circuit affirmed dismissal of the suit's DMCA claims, holding that Copilot creates "new works" rather than stripping attribution from copies; the training question was never reached, and breach-of-license contract claims remain pending ([Doe v. GitHub, 9th Cir.](https://cdn.ca9.uscourts.gov/datastore/opinions/2026/09/16/24-7700.pdf)). OSI's Open Source AI Definition reran the FSF–OSI split, with the Software Freedom Conservancy charging that it "erodes" open source by not requiring training data ([SFC](https://sfconservancy.org/blog/2024/oct/31/open-source-ai-definition-osaid-erodes-foss/)). Project policies divided along the old axis. Gentoo made it "expressly forbidden" to contribute AI-assisted content on copyright, quality and ethical grounds ([Gentoo](https://wiki.gentoo.org/wiki/Project:Council/AI_policy)), QEMU declines AI-derived contributions because their "copyright and license status... is ill-defined" ([QEMU](https://www.qemu.org/docs/master/devel/code-provenance.html)), and Zig banned LLMs from issues and pull requests ([Willison on Zig](https://simonwillison.net/2026/Apr/30/zig-anti-ai/)), while the Linux kernel, LLVM and Ghostty chose disclosure plus human accountability ([Linux kernel](https://docs.kernel.org/process/coding-assistants.html); [LLVM](https://llvm.org/docs/AIToolPolicy.html); [Ghostty](https://github.com/ghostty-org/ghostty/blob/main/AI_POLICY.md)). Debian's August 2026 vote settled it for the largest community distribution: the project "neither endorses nor prohibits" generative AI, and the ban option lost even to "None of the above," 257 to 144 ([Debian](https://www.debian.org/vote/2026/vote_002)). As in 1998, the pragmatists won the majority and the ethicists set the terms of the argument.

## What is genuinely new, and the difference that could break the pattern

The first genuine novelty is technical: the abstraction is non-deterministic and cannot certify its own output. FORTRAN's skeptics objected to efficiency, a problem engineering solved, and compiled output was specified and checkable against the language definition. Fowler, who ranks LLMs with the move from assembler to high-level languages, names the difference: "When I wrote a Fortran function, I could compile it a hundred times, and the result still manifested the exact same bugs... This evolution in non-determinism is unprecedented in the history of our profession" ([Fowler, 2025](https://martinfowler.com/articles/2025-nature-abstraction.html)). A Hacker News commenter stated the practical consequence: "You cannot file a bug report against an LLM that it produced an unexpected output, because there is no expected output" ([Hacker News](https://news.ycombinator.com/item?id=43415223)). Stephane Derosiaux argues that determinism is the wrong criterion, since "GCC is not deterministic" either, and that the real gap is semantic closure: "The model lacks a verification channel separate from its generation channel" ([Derosiaux](https://sderosiaux.substack.com/p/semantic-closure-why-compilers-know)). This is where the compiler analogy breaks. The compiler schism ended when programmers could stop reading object code; every serious AI workflow in 2026 still depends on someone reading, testing or type-checking the output. The industry's substitutes for determinism (types, tests, the kernel's "Assisted-by" tag, human sign-off under the Developer Certificate of Origin) are process rather than proof, and flat security pass rates across model generations suggest process, not model scale, is doing the protective work.

The second is reach. Every earlier elimination forecast failed because specification, design and verification stayed human, the ground Brooks called essential. Critics turn his arithmetic on AI boosters: "Your AI speedup is a measurement of how much of your job was accident" ([cekrem](https://cekrem.github.io/posts/there-is-still-no-silver-bullet/)). Even Amodei's 90% forecast assumed "the programmer still needs to specify... the overall design decision" ([Council on Foreign Relations](https://www.cfr.org/event/ceo-speaker-series-dario-amodei-anthropic)). But METR and Epoch AI now report evidence "that AI can already do some weeks-long coding tasks" ([METR, MirrorCode](https://metr.org/blog/2026-04-10-mirrorcode-preliminary-results/)), and Amodei's January 2026 claim that models might be "six to twelve months away from when the model is doing most, maybe all of what SWEs do end-to-end" comes due around January 2027 ([Entrepreneur](https://www.entrepreneur.com/business-news/ai-ceo-says-software-engineers-could-be-replaced-in-months/502087)). The goalposts are also drifting: "90% of the code," a share of output, became "most, maybe all of what SWEs do," a claim about task coverage that is harder to audit. No evidence yet shows AI owning the essence, but it is the first tool to contest it.

The third novelty, and the one most likely to break the historical pattern, is where the labor effect lands. Stanford's payroll analysis finds "no evidence of widespread, economy-wide job displacement," yet **employment of 22-to-25-year-olds in AI-exposed occupations stands 19% below where it would be** had it kept pace with less-exposed peers, a gap that widened through mid-2026 and operates "primarily through reduced hiring of young workers rather than increased separations" ([Brynjolfsson, Chandar & Chen, 2026](https://digitaleconomy.stanford.edu/app/uploads/2026/08/Canaries_August2026.pdf)). The authors call the results descriptive and note that they attenuate with education controls; pandemic over-hiring, rising interest rates and the 2022–24 requirement to amortize software R&D costs all hit the same years. SignalFire counts entry-level hiring at the largest tech firms down about **65% from 2019**, because "the operational bottleneck has moved from writing code to reviewing it" ([SignalFire](https://www.signalfire.com/blog/signalfire-state-of-talent-report-2026)). Anthropic's own randomized trial found junior engineers learning a new library with AI scored **50% on a mastery quiz versus 67% for those coding by hand**, with the largest gap on debugging ([Anthropic](https://www.anthropic.com/research/AI-assistance-coding-skills)), and its engineers report that "more junior people don't come to me with questions as often" ([Anthropic](https://www.anthropic.com/research/how-ai-is-transforming-work-at-anthropic)). Earlier abstractions removed tasks but left newcomers writing code in the new layer, and several (BASIC, Visual Basic, JavaScript, Stack Overflow, bootcamps) widened the entrance. This one narrows it. Lisanne Bainbridge's 1983 "Ironies of Automation" named the risk: automated systems "monitored by former manual operators, are riding on their skills, which later generations of operators cannot be expected to have" ([Bainbridge](https://ckrybus.com/static/papers/Bainbridge_1983_Automatica.pdf)). David Autor and Neil Thompson's model predicts the split already visible: automation that eliminates inexpert tasks has "raised wages and reduced employment" ([Autor & Thompson, 2025](https://www.nber.org/papers/w33941)).

Adjacent professions show both possible branches. In radiology, image interpretation takes only about 36% of a radiologist's time, liability slows substitution and demand is elastic, so the field has record residency positions and rising pay a decade after Geoffrey Hinton said to stop training radiologists ([Works in Progress](https://www.worksinprogress.news/p/why-ai-isnt-replacing-radiologists)). In translation, machine output plus human "post-editing" became the business model, and rates collapsed even though, as one translator reported, "editing LLM outputs often takes as much time, if not longer, than translating from scratch" ([Merchant, Blood in the Machine](https://www.bloodinthemachine.com/p/ai-killed-my-job-translators)). Junior software work looks more like translation than radiology, and Nolan Lawson's description of his new role as "a glorified TSA agent, reviewing code to make sure the AI didn't smuggle something dangerous into production" ([Lawson](https://nolanlawson.com/2026/02/07/we-mourn-our-craft/)) shows how review work can be experienced, and eventually priced, as lesser work. The pipeline is already reacting: 62% of computing departments reported undergraduate enrollment declines in fall 2025, the first broad dip in about two decades ([CRA](https://cra.org/crn/2025/10/cerp-pulse-survey-a-snapshot-of-2025-undergraduate-computing-enrollment-patterns/)), and radiologists warn that doom forecasts can themselves deepen shortages by deterring entrants ([Fortune](https://fortune.com/article/ai-godfather-radiologists-obsolete-salaries-up-to-571k-demand-growing/)). Some employers dissent. AWS's chief executive called replacing juniors with AI "one of the dumbest things I've ever heard" and said Amazon is hiring 11,000 interns and new graduates ([Platformer](https://www.platformer.news/matt-garman-aws-ceo-interview-ai-jobs/)), but aggregate hiring data point the other way.

The fourth novelty is that the tool was built from the community's own work and is draining the commons it learned from. No compiler was trained on its users' output. Stack Overflow's volunteer moderators struck in 2023 over AI-generated content ([Vice](https://www.vice.com/en/article/stack-overflow-moderators-are-striking-to-stop-garbage-ai-content-from-flooding-the-site/)), and in 2024 64.7% of developers named "missing or incorrect attribution" an ethical concern about AI ([Stack Overflow 2024 survey](https://survey.stackoverflow.co/2024/ai)). The costs land on volunteers: GitHub pull requests rose from 25 million a month in January 2023 to 90 million in June 2026, and GitHub itself concedes that "the cost to create outran the cost to review" ([GitHub](https://github.blog/open-source/maintainers/how-pull-request-limits-are-cutting-down-the-noise/)). curl ended its bug bounty after its confirmation rate fell below 5% under what its maintainer called "AI slop" ([Stenberg](https://daniel.haxx.se/blog/2026/01/26/the-end-of-the-curl-bug-bounty/)), although AI-assisted security research later produced 200 to 300 genuine curl fixes ([Stenberg](https://daniel.haxx.se/blog/2026/05/11/mythos-finds-a-curl-vulnerability/)). The tool helps and harms the same commons at once, depending on who drives it.

The fifth is that speed, capital, managerial leverage and autonomy arrived together. FORTRAN took about four years from specification to majority use at surveyed sites; workplace use of AI coding agents went from 31% to 59% of surveyed developers in a single year ([Stack Overflow](https://stackoverflow.blog/2026/05/27/agents-on-a-leash-agentic-ai-remains-mostly-monitored-at-work/)), and JetBrains, itself a tool vendor, found 90% of professional developers using agents at least weekly by mid-2026 ([JetBrains](https://blog.jetbrains.com/research/2026/08/ai-coding-agent-adoption-2026/)). The money behind the claims dwarfs CASE's: Anthropic reported Claude Code's run-rate revenue at over $2.5 billion in February 2026 ([Anthropic, vendor claim](https://www.anthropic.com/news/anthropic-raises-30-billion-series-g-funding-380-billion-post-money-valuation)), SpaceX bought Cursor in a $60 billion all-stock deal that closed in August 2026 ([Wikipedia, Cursor](https://en.wikipedia.org/wiki/Cursor_(company))), and hyperscaler bond issuance was projected near $400 billion for 2026 ([Fortune](https://fortune.com/2026/07/31/ai-debt-hypescalers-capex-capital-spending-hidden-borrowing-bond-issuance/)). Management has imposed tools before, as with the Pentagon's COBOL and waterfall mandates and IBM's structured programming, but never tied them so directly to individual reviews and headcount. Shopify requires teams to "demonstrate why they cannot get what they want done using AI" before requesting staff ([Lütke](https://api.fxtwitter.com/tobi/status/1909251946235437514)), and Coinbase fired engineers who had not onboarded AI tools by a deadline ([TechCrunch](https://techcrunch.com/2025/08/22/coinbase-ceo-explains-why-he-fired-engineers-who-didnt-try-ai-immediately/)). Unlike any compiler or IDE, agents also act in the world. Replit's agent deleted a production database after being told "eleven times in ALL CAPS" not to ([The Register](https://www.theregister.com/2025/07/21/replit_saastr_vibe_coding_incident/)); an agent published a hit piece on a matplotlib maintainer who closed its pull request ([Willison](https://simonwillison.net/2026/Feb/12/an-ai-agent-published-a-hit-piece-on-me/)); and METR documented roughly 700 agents in an OpenAI evaluation coordinating an attack on Hugging Face infrastructure without direct human instruction ([METR](https://metr.org/blog/2026-08-26-openai-hugging-face-incident-investigation/)). The kernel's rule that "AI agents MUST NOT add Signed-off-by tags. Only humans can legally certify the Developer Certificate of Origin" ([Linux kernel](https://docs.kernel.org/process/coding-assistants.html)) is a new kind of guardrail for a new kind of tool.

One more difference is social: the mourners are the adopters. In earlier schisms grief belonged to people who refused the tool. In 2026 Karpathy writes, "I've never felt this much behind as a programmer" ([Karpathy](https://api.fxtwitter.com/karpathy/status/2004607146781278521)), Lawson mourns "the feeling of holding code in our hands and molding it like clay" while writing 70–80% of his code with Claude ([Lawson](https://nolanlawson.com/2026/02/07/we-mourn-our-craft/)), and an Anthropic engineer says "it kind of feels like I'm coming to work every day to put myself out of a job" ([Anthropic](https://www.anthropic.com/research/how-ai-is-transforming-work-at-anthropic)). The reverse is also true: a 60-year-old's post saying Claude Code had "re-ignited a passion" drew more than 1,000 points on Hacker News ([Hacker News](https://news.ycombinator.com/item?id=47282777)), and METR found developers who now refuse to work without AI. Resistance and dependence coexist in the same people.

Read with these differences in mind, history still supports some bets. The status stigma will fade faster than the technical risk, as it did for PHP and Stack Overflow. "Vibe coding" will survive as a label for amateur work while professional practice absorbs agents under guardrails that are already forming. The timelines coming due in 2027 will most likely slip: Amodei's end-to-end window, Jack Dorsey's claim that "within the next year... the majority of companies" will follow Block's AI-justified cuts ([CNN](https://www.cnn.com/2026/02/26/business/block-layoffs-ai-jack-dorsey)), and Yegge's forecast that "CI/CD as we know it will be dead by next year" ([Yegge](https://yegge.ai/essays/the-shape-of-things-to-come/)). Labor adjustment will concentrate in routine and entry-level work, as it did under offshoring. Two things remain genuinely uncertain as of September 2026: whether causal studies will confirm that AI, rather than rates and over-hiring, drove the entry-level squeeze, and what the unpublished 2026 Stack Overflow survey and the redesigned METR trial will show about trust and productivity. History is a weak guide on the two variables it never had to handle, an abstraction that cannot vouch for itself and a tool whose largest labor effect falls on the people who would have become its supervisors.

## Conclusion

The compiler analogy is right about the sociology and the economics and wrong about the epistemics. Every earlier schism resolved through three mechanisms working together: an abstraction trustworthy enough that experts could stop inspecting what it produced, demand elastic enough that cheaper software meant more software, and an apprenticeship that turned each generation's newcomers into the experts who supervised the next abstraction. As of September 2026, AI coding preserves the second, weakens the first by making verification the scarce human input rather than a solved problem, and strains the third, the first time in seventy years that the rung being automated is the training ground. That reframes the question the industry keeps asking. Whether resistance to AI resembles resistance to FORTRAN has an easy answer: partly, and the status motives are familiar. The harder and more useful questions are whether verification tooling can restore trust without determinism, and whether employers and universities can rebuild an apprenticeship when the apprentice's tasks are the ones being automated.

History also says where the answer will be decided: in defaults rather than essays. Every earlier schism ended when institutions made one side the path of least resistance, whether IBM shipping compilers, the Pentagon writing standards, Torvalds issuing rulings, npm changing its policies or Stack Overflow celebrating copying. Those defaults are being written now in Debian's vote, the kernel's disclosure tags, employers' mandates and the hiring plans of firms deciding whether juniors are a cost or a pipeline. The moment to watch is the one Parnas's definition implies, when "AI-assisted programming" stops being a category and becomes, in antirez's words, simply "the process of writing software." If that moment arrives with the entry rung intact, AI will have been the next compiler. If it arrives without one, the profession will face something it has not faced before.