Farewell To Punch Cards

I am given to understand that programmers who came of age in my father’s generation used what we now call punch cards. Whereas today’s practitioners poke at a keyboard that manipulates files resident in volatile memory, backed by persistent storage, and fed to lightning-fast compilers or interpreters, yesterday’s craftspeople might have fleshed out programs on whiteboards or paper, only then to laboriously encode them onto structured cardstock, punch cards, which somehow had to make their way to a mainframe to await their turn to execute in an overnight batch job, the outcome of which might be to find that your program had some trivial error in it, the correction of which would take another day.

Such a cumbersome workflow already seemed amusingly quaint by the turn of the millennium, by which time multiple layers of improvements had accreted. Punch cards and mainframes gave way to terminals and PCs, compiled languages largely displaced assembly programming, interpreted languages provided faster feedback, and a growing corpus of libraries and tools published on a budding Internet encapsulated polished implementations of many common tasks. The cycle of dev, test, debug, and repeat collapsed from a day to mere seconds while the expressiveness of a single line of code exploded. The power that twenty-year-old me could wield by running some Perl on an Apache server hosted on a Unix box that could talk to a MySQL database would have blown the minds of engineers living through the seventies and eighties.

Progress in developer productivity, of course, did not halt there, despite the dot-com bubble popping around this time, an event that made my ancestors question why I was plowing headlong into a career in Software Engineering in lieu of something more respectable like, say, Medicine. The “trough of disillusionment” in this hype cycle certainly disrupted the trajectories of many, but those who stayed the course took part in an amazing acceleration that continues to this day.

As my skills blossomed, so, too, did an increasing number of previously disparate sub-disciplines come under the yoke of Software Engineering methodologies. Docker containers, cluster schedulers, software-defined networking, database migrations as code, Git, and Terraform not just enabled me to do the work of sysadmins, network admins, database admins, and procurement specialists, but rather to codify and version their workflows in a traceable and repeatable fashion. Add some UX and Security competency to the mix and one is truly full stack.

By the 2020s the amount of technical power I could wield unilaterally by stitching together the likes of AWS, GitHub, Terraform Cloud, Datadog, LaunchDarkly, Sentry, Okta, Google Workspace, and five or so programming languages was kind of ridiculous, and never mind the range of business-focused SaaS offerings that could automate tasks as eclectic as corporation formation, client invoicing, payroll processing, expense management, and financial accounting. To a large extent I could do anything but as had long been the case it proved burdensome to have to do everything. I was very flexible in what problems I could wrangle, but nonetheless my programming output still acted as a meaningful and vexing bottleneck on productivity.

To widen that chokepoint I have episodically and in various forms managed or otherwise wrangled teams of people in a fashion where I was often predominantly focused on creating platforms and tooling that provided leverage to people writing plugins or applications, sometimes for application development exercises I was leading and other times in a more loosely coordinated fashion where I was building common tooling for multiple application teams spread across an enterprise. I could in effect grow my bandwidth by adding additional engineers to the mix but always that came with geometrically exploding coordination complexity relative to team size as well as round-trip latency drag in the form of iterative design and code reviews that could spill across days with individuals and even weeks in team-of-teams scenarios.

Enter Large Language Models (LLMs)…

I jumped on ChatGPT shortly after it arrived on the scene and continually worked at dialing in how it could provide lift to my development workflows. The key parameters to tune seemed to be topic selection, leash length, and progress tolerance. The more mainstream and stabilized the topic the better it would do — asking about bog standard algorithms in Python, solutions to which had long ago converged on Stack Overflow, would make for easier going than, say, asking about areas of Terraform arcana still materially in flux as recently as a couple years earlier. The shorter the leash you gave it the less likely it would be to wander off into left field and start hallucinating — scope control was key. And sometimes for some tasks it would helplessly flail endlessly — best, dear human reader, to realize the futility of the request for assistance as soon as possible and get down to the task of doing it yourself before the sun sets on your ambitions and excessive spittle has accumulated on your monitor.

One of the things I immediately appreciated about ChatGPT was the way it could help me in scenarios that might summarize thus — “I kinda know what I want to build here, and I’ve built something vaguely similar previously, but I don’t have access to any of that historical source code, and the context here is just a little bit different both in application goals and tool chain”. With the right approach I could often coax it into emitting useful snippets and templates of code that I could quickly massage into a working module without having to slog through sprawling, fragmented, incomplete documentation. In time the larger ecosystem matured and I found myself spending less time in Emacs copying code out of a browser and more time in Cursor where I could scope a conversation to specific files or even code blocks and then make requests against that context that would result in change sets that I could either accept for automatic application or on which I might iteratively suggest additional refinements.

Whoah. Goodbye amnesia. Goodbye friction. Goodbye latency. Goodbye organizational complexity. Hello cyborg me.

I recently had the surreal thought that the preceding generation’s punch cards are, after a fashion, my generation’s technical co-workers in the present moment, at least to a degree, at least if you are a broadly educated generalist with depth in a few key specialty areas. Not so long ago “collaboration” and “code review” looked like asking another human to do a thing, waiting maybe a few days for them to figure out their first approach to it, then looking at their pull request in a web browser and laboriously adding line-by-line feedback, then maybe waiting a day or two for another iteration, and maybe even taking several such iterations to polish it up. Now I often jam with a virtual co-worker who, depending on which model their brain is running, will have a first cut of changes within seconds or maybe tens of seconds, and then we can rip through multiple such iterations in the span of a few minutes, marrying the best of human and machine, and ending up with code that is rigorously designed, automatically tested, aesthetically pleasing, and ready to ship to a public cloud that will elastically scale up and down according to my application’s needs. A micro-sprint can be completed and the revised code in the hands of users before a mug of coffee can reach my bladder.

Is the end nigh? I dunno. Maybe? I certainly worry about it. It is, however, quite difficult to reason about timelines. People have perpetually overestimated short-term progress as the result of underestimating implementation complexities while also underestimating long-term progress owing to inadequate appreciation of compounding effects. Maybe our ability to field additional data centers will choke on the availability of energy and/or rare earth minerals. Perhaps China will yeet on into Taiwan, TSMC will slap the self-destruct button, and the world will have to do without new GPUs for five or ten years. What about solar flares, asteroids, climate change, and other natural phenomena? Maybe the gloves will really come off with cyber warfare. Maybe a lot of things will conspire to make things take decades longer than the techno-optimists and techno-doomers alike would have you believe. Or maybe we’ll Leeroy Jenkins into an unprecedented arms race that completely abandons any pretext of concern about AI safety with superintelligences of all kinds controlled by all manner of puppet masters running amok in a hyper-connected and yet hyper-anonymous world. Gray swans everywhere — kaboom?

Some kind of middle path in the next five years seems most likely. No, probably co-workers won’t become obsolete, at least not until we have AGI, unlimited energy, unlimited GPUs, and far more efficient models. But “cyborg programmers” will continue to become ever more powerful and as the cost per unit of engineering output goes down we can probably expect the economy to adhere to Jevon’s Paradox which says that aggregate demand for it will increase as ever more previously impractical endeavors become feasible and thus launch. The outward appearance of programming will change but demand for it at all levels of sophistication will increase, from the systems in hyper-regulated environments where “liability outsourcing” is a key feature as they must scrupulously manage confidentiality, integrity, and availability requirements with tolerable unit economics while running at scale, to hyper-customized apps cranked out by laypeople with no-code tooling used in non-critical workflows by a handful of folks.

So, yes, there is very real tail risk that we utterly wipe out our species within a few decades. We should also gird ourselves for the near certainty that AI triggers massive disruption in the labor markets, capital markets, and geopolitical arenas. I can’t seem to find an appropriate analogue for the “Overton Window” to use here, so let’s make up something called the “Gibbs Window” — the range of actors who can be involved in some manner of systems building and the consequent kinds of systems that now can be built at the higher end and will be built at the lower end. This window won’t just slide but grow.

Earlier in my career I had some frustrating platform building experiences that left me with a “you can’t turn non-programmers into programmers” conclusion that in hindsight was insufficiently nuanced. The person who could happily write a web app in JavaScript for a startup circa 2010 might not have survived as an assembly programmer in the seventies developing space shuttle navigation code but each task was a sort of programming in a particular time and context and each person a programmer though they might not recognize each other as such from a distance. How structurally different is it to, say, gain a compiler when before you were crafting artisanal assembly code, as compared to adding generative AI to your toolkit when previously every line of code you wrote sprang character-by-character from your brain and fingers (or at least was copy-pasted from Stack Overflow). With every advancement of our developer tooling we grow the Gibbs Window and thereby create an ecosystem that is more inclusive of would-be participants and that consequently allows the creation of more and increasingly varied products and services.

At least that’s the part of my probability cloud that doesn’t sound like a total doomer. We are absolutely playing with fire, the risks are systemic and existential, and we really don’t have any idea how this is going to unfold. Maybe we will create a utopia of abundance and wisdom on earth while mining the Kuiper Belt and colonizing the stars. Maybe we will create the worst possible form of techno-feudalism and surveillance-capitalism. Maybe we will bomb ourselves back into the Stone Age and turn our planet into gray goo and/or paperclips. Anybody who confidently says they know which of these is our future is full of shit. There is only way to know — buckle up buttercup because we’re all going to play a planetary scale game of Fuck Around Find Out together.