Software engineers aren’t going to disappear. To the contrary: the skillsets they possess are about to become more valuable than they are today. That might sound counterintuitive if you’ve read the news circulating over the last 12 months. Computer science degrees - the most popular college major, after a decade of massive growth - are starting to decline. The Bureau of Labor Statistics projects employment for computer programmers to shrink over the next decade.1 And tech CEOs keep claiming that software engineering is the field most ripe to be fully overtaken by AI.
This may all sound a bit dire, but it’s actually just history repeating itself. We’ve been here before. Let’s take a walk down memory lane, all the way back to 1972 - the year Hewlett-Packard introduced the HP-35, the world’s first scientific pocket calculator.
What the calculator actually killed #
Prior to the HP-35, there was only one reliable way to do complex mathematical operations like logarithms, exponents, and trigonometry: the slide rule.
The HP-35 was expensive by any standard - $395 in 1972, roughly $3,000 in today’s dollars2 - but it fundamentally changed the capability set for countless engineers. Work that used to eat a significant portion of their day could now be done with a few button presses. The reaction followed a familiar script, too: calculators had already been changing the behavior of students and workers, and teachers were none too happy, convinced that students would never learn math. Looking back, we can see that isn’t what happened. We still use math. We also use calculators.
It was like moving from the horse to the car when we moved from slide rules to calculators.
— an engineering alumnus, in the University of Minnesota’s Slip Sliding Away
The way we applied math changed. The discipline didn’t die #
Computing numbers efficiently is a problem as old as commerce and engineering. Roman merchants and Chinese scholars built the abacus and the suanpan to handle exactly this. Math has been an ever-present force since the beginning of civilization - and so have the tools we invent to make it faster.
The slide rule unlocked a new, more powerful kind of mathematics, and the calculator supplanted it in turn. But that didn’t mean math or mathematicians - or, more importantly, the countless professions that rely on applied mathematics - went away. Cheap computation didn’t shrink math. It grew it. The ability to compute easily unlocked an entire set of work that was previously impossible: an engineer who could once afford to check a design calculation twice could now iterate on it twenty times, and analysis that used to be carefully rationed became routine homework.
| Slide-rule era | Calculator era | |
|---|---|---|
| Precision | 2-3 significant digits, by hand | 10 digits, every time |
| A day’s work | Grinding through the arithmetic | Deciding what to compute |
| Iteration | One or two passes, checked twice | As many as you can think of |
Cheap computation didn’t shrink math. It grew it.
AI is the calculator. Computer science is the math #
AI - and I’m talking about LLM-driven agents specifically - is an incredibly powerful tool that software engineers can deploy in their daily work. Agents let engineers define the tasks to be accomplished and automate significant portions of the execution. This capability will undoubtedly unlock an entire new set of products, services, and businesses - all of which require the critical domain knowledge that is taught in a computer science curriculum.
Here’s the nuance that gets lost. People tend to focus on the one-shot prompt that produces something that “works.” And it does work, for the specific case they asked about. But when you actually read the code, you realize there was no thought given to extensibility, edge cases go unhandled, and in some cases the functionality is just plain broken. The output is only as good as the conversation that produced it, and having that conversation well means speaking the language of the domain: being able to articulate the problem, name the trade-offs, and recognize a wrong answer when it’s handed to you.
This isn’t unique to software. A lawyer friend of mine uses AI regularly: it’s quite good at routine summarization, but it usually can’t produce a nuanced argument for a novel case. Great for routinized problems with concrete answers, not great for the specialized work. A doctor friend reviews the work of other doctors who use an AI program for clinical questions. He sees their question and the AI’s response, and the AI answers the question accurately - but the question itself was framed wrong. A correct answer to the wrong question is a confidently wrong answer, and it takes an expert reviewer to catch it. The framing is what matters.
These are all the same fundamental issue. Framing the problem and speaking in the domain’s language is the actual key - and for software, that language is computer science: data structures, invariants, abstraction, domain modeling. The calculator made arithmetic free, and suddenly knowing what to compute was the whole job. Agents are making code cheap, and knowing what to build - and whether what got built is right - is becoming the whole job.
The part everyone gets wrong #
There’s an obvious objection: the slide rule comparison is too kind. The calculator could only ever do the arithmetic - AI can seemingly do the whole job. If an agent writes 100% of the code, why learn any of this at all?
When you think about the tools that came before - even something as simple as a pencil - it’s easy to understand that the skill of the operator has a direct impact on the quality of the output. Hand me a set of colored pencils and ask me to draw a landscape, and I guarantee there are millions of artists who would take that same toolset and produce a significantly better result.
The part that isn’t as easy to grok is that the same applies to digital work. Photoshop was first released in 1990 and fundamentally changed the way graphic designers and artists create. Does that mean you can give anyone Photoshop and they’ll produce the same quality of work? Obviously not, but it’s also not binary. Some of the tools it gives you are truly magical - like the magic wand, which selects objects using color, edge detection, and other complex techniques. That genuinely levels the playing field and hands less sophisticated users a superpower. It still doesn’t change the fact that you need to know how to use the tools effectively to get the most complex work done.
AI blurs the line because it’s such a powerful tool that it hands you good-looking content - text, code, images, video, sound, music - almost for free. But it doesn’t replace the value of the operator (yet). It’s the evolution of the magic wand tool, applied to so many fields at once that it’s hard to judge exactly where its superpowers stop being good enough. And that’s precisely why the fundamentals-holder gets more out of the same model than the fundamentals-skipper: they can read what came back, so they know where that line is.
What I’d tell someone starting today #
I have friends who ask me what disciplines their kids should study and what the future looks like for software engineers, and I routinely tell them the same thing: it isn’t going away, but it’s going to change dramatically. All of the valuable concepts a computer science program teaches - language theory, data structures, logic, domain modeling, abstraction, extensibility - are worth more now that LLMs can generate tremendous amounts of code, not less. We are at the very beginning of learning how to apply what AI makes possible, and we’ll need more engineers for that, not fewer. And sure, the future is unknowable. I once dismissed wireless power as a fantasy with no practical application, and today I wirelessly charge my phone in my car. Maybe we do reach a point where AI can truly do all the work humans do; I still expect there will be a role for us in that paradigm, but it’s hard to say exactly what it will be.
If anything, all this talk of AI being the death of software engineering has refocused the discipline on the people who were already predisposed to love the work. My suspicion is that the decline concentrates among people who picked the degree because it looked like a safe career rather than because the work pulled at them. That’s no knock - a stable paycheck is a perfectly good reason to learn a trade. But when the safety gets uncertain, the people who stay are the ones who would be doing this anyway. I’ve been coding since I was a child - not because I thought it would get me a good job, but because the passion is internal to me. I’m confident there are kids right now who share it, and I would never steer them away from a degree in computer science. There is more opportunity now than ever before to build something amazing that changes the world. Pursue your dreams.
Footnotes
- The distinction matters here: “computer programmers” is a narrow occupational category that has been shrinking for years, while “software developers” - the category most people actually mean - is projected to grow substantially over the same period. The doom headlines rarely quote the second half. Anthropic’s research on AI’s labor-market impacts paints a similarly nuanced picture. Back to text
- Hewlett-Packard introduced the HP-35 on February 1, 1972, priced at $395 - roughly $3,000 in today’s dollars. Within five years the slide rule was finished: by October 1977, The New York Times was writing its obituary, “Slide Rule Going the Way of Abacus as Pocket Calculator Moves In.” Back to text
