In the 1950s, a programmer was someone who punched holes in cardboard. Each hole was a bit. Each card was a line of code. A program of modest complexity required a stack of cards thick enough to fill a shoebox. If you dropped the stack, you were in serious trouble - the cards had to be fed into the reader in exact sequence, and re-sorting a scattered deck by hand could take hours. Programmers drew diagonal lines across the edge of the stack with a felt-tip pen so they could see at a glance if a card was out of order. It looked like a barcode. It was a barcode, of a kind.
Grace Hopper, who in 1952 built the first compiler - the program that translates human-readable instructions into machine code - described the experience of early programming as a form of puzzle-solving under severe physical constraints. You wrote your logic on paper. You translated it to card format. You walked the cards to the computer room, handed them to an operator, and waited. If you were lucky, the turnaround was an hour. If the system was busy, you waited until the next day. One typo meant starting the cycle over.
Seventy-four years later, a developer types a sentence in plain English and an AI agent writes, tests, and deploys the code in minutes. Andrej Karpathy, who coined the term for this workflow, recently declared it had already evolved past its original name. The practice once called "vibe coding" is now "agentic engineering" - orchestrating autonomous systems that do the typing for you.
Between the punch card and the agent, the job changed seven times. Each change felt like the end of programming. Each time, the programmer survived by becoming something else.
Age 1: The Machine Whisperer (1940s-1960s)
The first programmers were mathematicians. They worked in machine code and assembly language - raw binary instructions that mapped directly to the hardware. Writing a program meant understanding, at the level of individual electrical signals, what the computer was physically doing. The abstraction layer between the programmer and the machine was zero.
These early practitioners were not called programmers. They were called "computers" - the same word used for the humans (mostly women) who had performed calculations by hand during the war. The machines inherited the job title. The humans kept it for a while, awkwardly, until new vocabulary caught up.
The skill required was patience. A single program could take weeks to write and debug. Errors were caught by re-reading code printed on fan-fold paper, line by line, looking for a misplaced bit. The computer offered no help. It did exactly what you told it, which was almost never what you meant.
Age 2: The Language Speaker (1960s-1980s)
FORTRAN arrived in 1957. COBOL in 1959. BASIC in 1964. C in 1972. Each language added a layer of abstraction between the programmer and the hardware. Instead of specifying electrical signals, you could now write something that resembled English - or at least resembled mathematics.
This was the first time the profession predicted its own death. If machines could understand FORTRAN, went the argument, then soon they would understand plain English, and programmers would be unnecessary. That prediction has been made, in various forms, every decade since. It has been wrong every time, for the same reason: the bottleneck was never the typing. It was the thinking.
The languages freed programmers from hardware. The cost was that a new skill became essential: reading other people's code. With machine code, every program was bespoke - written from scratch for a specific machine. With high-level languages, code became portable and reusable, which meant inheriting someone else's decisions, someone else's naming conventions, someone else's bugs. The ability to understand a codebase you did not write became as important as the ability to write one.
Age 3: The Toolmaker (1980s-1990s)
Personal computers changed who could be a programmer. Before the PC, programming required access to a mainframe - which meant working at a university, a corporation, or a government lab. After the PC, programming required a desk and a power outlet.
The 1980s and 1990s were the age of the toolmaker. Developers built the tools that other developers used. Compilers, editors, debuggers, version control systems, build tools. The infrastructure of software development itself became a domain of specialisation. Richard Stallman wrote GNU Emacs. Linus Torvalds wrote Git. James Gosling wrote Java.
The cultural shift was significant. Programming stopped being a craft practiced in isolation and became a community activity. Bulletin boards, Usenet groups, and eventually mailing lists connected programmers across geographies. For the first time, a developer in Finland could collaborate with a developer in California without either one leaving their desk. Open source was born not from a philosophy but from a practical reality: shared tools made everyone faster.
Age 4: The Web Builder (1995-2010)
The web changed what software was for. Before the browser, software was a product you installed from a disk. After the browser, software was a service you accessed through a URL. The distinction sounds trivial. It transformed everything.
Web development introduced a new species of programmer - one who needed to understand not just logic but design, not just data but users, not just performance but accessibility. The full-stack developer emerged: a person who could wire a database to a server to a browser and make the result look presentable. HTML, CSS, JavaScript, PHP, MySQL, Apache. The stack kept growing. Nobody mastered all of it. Everyone pretended to.
The web also introduced a new tempo. Software shipped in real time. A bug could be fixed and deployed within the hour. This was exhilarating after decades of shrink-wrapped release cycles, but it also meant the work was never finished. Software became a living system that required continuous maintenance, and the developer became its caretaker.
Age 5: The Stack Assembler (2010-2020)
Somewhere around 2010, the job of a software developer shifted from writing code to choosing code. The explosion of open source libraries, frameworks, and platforms meant that most of the hard problems had been solved by someone else. Your job was to find the right package, wire it up correctly, and handle the edge cases.
Stack Overflow launched in 2008. Within a few years, it became the single most important resource for working developers - more useful than any documentation, any textbook, any mentor. The running joke was that programming had become the art of copying from Stack Overflow and modifying until it worked. The joke was funny because it was partly true.
GitHub launched in the same year. It turned code sharing from a fringe activity into the default mode of professional development. Your GitHub profile became your resume. Your contribution graph became your proof of work.
The skill in this era was integration. The best developers were not the ones who wrote the most elegant algorithms. They were the ones who could glue together fifteen different libraries, deploy to three cloud providers, configure a CI/CD pipeline, and ship a working product before the competitor did. Speed replaced elegance as the primary virtue.
Age 6: The Prompt Whisperer (2022-2025)
GitHub Copilot launched in 2021. ChatGPT launched in November 2022. Within eighteen months, 84% of developers reported using or planning to use AI-assisted programming in their workflow, according to Stack Overflow's 2025 survey.
The term "vibe coding" was coined by Karpathy in February 2025 to describe a workflow where the developer describes intent in natural language and accepts whatever the model produces. "I just talk to Composer with SuperWhisper so I barely even touch the keyboard," he wrote. "I 'Accept All' always, I don't read the diffs anymore." Collins Dictionary named it Word of the Year for 2025.
The speed was staggering. Twenty-five percent of Y Combinator's Winter 2025 batch had codebases that were 95% AI-generated. Garry Tan, YC's CEO, called it a paradigm shift. CEOs who had not written code in a decade - Tobi Lütke at Shopify, Brian Armstrong at Coinbase - returned to active development. Lütke went from 94 commits in all of 2024 to 957 in the first 45 days of 2026.
But vibe coding had a problem. It worked for prototypes and demos. It broke in production. The code looked correct on the surface but lacked error handling, introduced security vulnerabilities, and created unmaintainable architecture. The industry coined a term for this too: "AI slop."
The skill in this era was judgment. You did not need to type the code. You needed to know if the code was right. The bottleneck moved from production to evaluation - from "can you build this?" to "should you ship this?"
Age 7: The Orchestrator (2026-)
In February 2026, on the one-year anniversary of coining "vibe coding," Karpathy declared the term passé. He proposed a replacement: agentic engineering. "Agentic, because the new default is that you are not writing the code directly 99% of the time. You are orchestrating agents who do and acting as oversight. Engineering, to emphasize that there is an art and science and expertise to it."
The shift from vibe coding to agentic engineering mirrors every previous transition in the profession. A new layer of abstraction is added. The old skill is automated. A new skill emerges. The developer survives by moving up the stack.
In the orchestrator age, the developer does not write code. They do not even prompt a model. They design systems of agents - specialised AI workers that research, plan, write, test, review, and deploy in parallel. The developer defines the architecture, sets the quality gates, reviews the output, and maintains accountability. Stripe's agent system produces over 1,000 merged pull requests per week. The human developers supervise.
The word "developer" itself may not survive this transition. "Agentic engineer" is the current candidate. But the history of the profession suggests that titles change faster than skills, and the core skill has been the same across all seven ages: understanding what needs to be built, and making sure it gets built correctly.
Punch cards required it. Assembly required it. FORTRAN required it. The web required it. Stack Overflow required it. Copilot required it. Agent swarms require it.
The tools change. The thinking doesn't.
What Your Atlas Shows
Every age leaves a trace on the contribution graph. The Stack Assembler era shows up as dense, steady activity - daily commits, continuous integration, the rhythm of a well-oiled pipeline. The Prompt Whisperer era shows up as sudden bursts - rapid prototyping, quick spikes of output that appear and disappear. The Orchestrator era is still being written, and its pattern is not yet clear.
But here is what is already visible: the graphs are getting brighter. More commits, more frequently, across more projects. The tools are amplifying output in ways that show up as physically denser star fields on the atlas. The developers of 2026 are producing more visible artifacts per day than the developers of 2020, who produced more than those of 2010.
The atlas does not show which lines were typed by a human and which by an agent. It does not distinguish vibe-coded prototypes from carefully reviewed production code. It shows only that work happened, that someone showed up, that something was built.
Across seven ages, that has never changed.
See the shape of your own era. Enter your GitHub username at codexstellarum.com and preview your atlas - free to try, prints from £25.