The Computer Science Degree Just Expired

A freshman starting computer science this fall is being trained for a job that no longer exists at the level they’re being trained for it.

That sentence is going to make some professors angry. It’s also going to make some parents quietly nervous about the tuition check they just wrote. Both reactions are appropriate. The CS curriculum at most universities in 2026 is still optimized to produce a 2015 software engineer. The skills students master in their first two years are exactly the skills agents now do faster, cheaper, and often better than humans. The skills the Senior Agentic Engineer actually needs are taught in almost no undergraduate program systematically.

This is a curriculum problem. It’s also, more importantly, a teaching problem. Because the dead skills aren’t only dead. They’re also still load-bearing for how humans learn the discipline that survived.

That paradox is the whole post.

Three Skills That Died as Jobs and Live as Teaching Tools

Coding-as-typing is dead. Anyone running production agentic workflows in 2026 already knows this. I haven’t written production code in months and I ship more software than I ever did.

Line-by-line code review is dead too. When I review pull requests, I direct an AI reviewer with my standards, my known failure patterns, and my architectural concerns. The reviewer reads. I read what the reviewer flags. The bottleneck moved up another layer.

Syntax recall is dead. The senior developer who could write Go from memory and the one who needs to look it up are now equally productive, because both are directing an agent that knows Go cold.

All three of those are settled. The harder claim is what comes next.

The reason a Senior Agentic Engineer can direct an AI reviewer effectively is decades of synaptic wiring around what good code looks like, what bad code feels like, what a code smell smells like. They can read a review well because they spent years reading code. They can specify what they want the agent to build because they spent years building it themselves and watching their own designs fail.

The freshman in 2026 doesn’t have that wiring yet. If they never type, never read code line by line, never memorize a piece of syntax long enough to internalize why it works, they don’t develop the substrate that makes the senior version of the role possible. They get stuck at the layer of “the AI said it was fine, so it’s fine.” That’s the reverse-centaur trap, applied to verification, before the engineer is even out of school.

Three skills that are dead as terminal professional capabilities are still alive as the foundational wiring that makes the new role possible. You learn to type so you can eventually stop typing. You learn to read code so you can eventually direct an AI reviewer effectively. You memorize syntax so you can recognize when an agent is using it wrong.

The CS curriculum problem is that universities are still treating these as terminal skills instead of foundational ones. They train students to be 2015 software engineers and stop. Graduation arrives and the graduate has mastered exactly the work that has been commodified.

What the New Role Actually Requires

The Senior Agentic Engineer post laid out the verbs of the new job: decide, decompose, specify, delegate, supervise, verify, integrate, deliver. Almost none of them are taught in CS programs as core competencies.

Specification. Writing a description of what should be built precisely enough that an agent can execute it and a human can verify it. Currently taught nowhere. Software engineering courses sometimes touch requirements gathering, usually as a single lecture rather than a craft skill practiced over a semester.

Decomposition. Taking a messy business problem and cutting it into pieces that fit the current shape of agentic work. Adjacent to architecture courses, which exist but tend to be senior-level and abstract.

Verification. Reading code and reviews critically, knowing which constraint is load-bearing and which is decorative. Currently taught informally through PR review on the job. Should be a core skill from day one.

Taste. Knowing what good looks like. Knowing when “it works” isn’t enough because the architecture has a future cost the agent didn’t price in. Currently taught through apprenticeship over years on the job. Universities have no answer for this. The closest analog is design school critique culture, which CS programs have never imported.

Problem framing. Knowing what’s worth building, which is upstream of all the above. This is where computer science meets the humanities, and most CS programs have actively gutted the humanities side over the last twenty years. The programs that retained a strong liberal arts requirement are about to look prophetic.

Agent supervision. The actual mechanics of running a fleet of agents productively. Currently taught by no one. Industry self-teaches in real time on production systems.

Accountability under uncertainty. The Senior Agentic Engineer’s job ends with a human signing off on the work. That signature carries legal, professional, and moral weight. Almost no CS program teaches anything about the accountability layer of professional practice. Medicine and law and engineering in the licensed sense all do. CS pretends it’s value-neutral and ships students into an industry where the value-laden decisions are now the entire job.

The good news is none of these are unteachable. They’re just untaught.

A Four-Year Program for the Agentic Era

If I were redesigning a CS degree from scratch in 2026, the rough shape:

Year one. Foundational logic, computational thinking, basic syntax in one language taught well enough that students can read code fluently. Core mathematics. Heavy reading-and-writing requirement that includes both code reading and prose specification writing. Critical thinking, argumentation, and ethics. Students do write code by hand on small problems this year, the way medical students still dissect cadavers even though they’ll use imaging in practice. The typing builds the synaptic wiring. The wiring is the point.

Year two. Systems thinking. Data structures and algorithms still matter, taught with the focus on understanding tradeoffs rather than implementation memorization. Architecture and decomposition introduced as a hands-on craft. First exposure to running and supervising agents on small projects. Students transition from “I write all the code” to “I direct an agent and verify the output,” with the verification layer practiced explicitly.

Year three. Specialization tracks. Heavy emphasis on verification, code review at scale, and debugging. A semester-long “read and improve a real codebase” course where students inherit messy production code and have to make it better. Liberal arts integration with serious courses in business, ethics, philosophy, or domain-specific fields. The student is now operating substantially as a junior agentic engineer.

Year four. Capstone projects where students lead agent fleets on substantive problems for real clients or open-source projects. Apprenticeship under senior practitioners who critique their work the way a design school critiques a portfolio. Defense of a portfolio that demonstrates not what they typed but what they specified, decomposed, supervised, and shipped.

Two skills run through all four years like spines: writing precise specifications and developing taste through critique. Those replace “writing code from scratch” as the foundational competencies of the discipline.

That’s a redesign, well beyond the boundaries of typical curriculum reform. Most universities aren’t going to do it.

The Transition Decade Belongs to the Outsiders

The flip side of universities being slow is that bootcamps, apprenticeships, and self-directed paths can move faster. Someone in 2026 with the right autodidactic instincts can train themselves to be a Senior Agentic Engineer in eighteen months without setting foot in a CS program. The skills are public. The tools are accessible. The feedback loop with agents is fast and cheap.

This has happened before. Coding bootcamps in the 2010s outperformed CS programs for producing employable junior developers because they optimized for the actual job. The same pattern is going to repeat at the agentic layer. The bootcamps and apprenticeship programs of the next wave are going to teach specification, decomposition, verification, and agent supervision while the CS programs are still teaching freshman Java.

The credential will lag the capability by five to ten years. Students who go to the right unconventional programs in 2026 through 2028 will have careers. Students who go to CS programs that don’t redesign themselves will graduate and discover they trained for a job that no longer exists at the level they trained for it.

For parents reading this and thinking about a kid heading to college: ask the program what they teach about specification. Ask what they teach about agent supervision. Ask whether students do capstone work directing agents or capstone work writing code from scratch. The answers will tell you whether the program has noticed what changed.

The Personal Note

I started coding at twelve on a Commodore 64. I have something close to ninety thousand hours of typing behind me. The synaptic wiring that lets me direct agents productively was built by years of writing code that didn’t work, fixing it, writing more, watching it fail in production, fixing it again. I can read a review well because I spent decades reading code. I can specify well because I spent decades building from specifications other people wrote, including bad ones.

That wiring is the asset. The typing was the path that built it. The path is no longer the destination, but it’s still the path that gets you there. Pretending otherwise produces graduates who can’t direct agents because they never developed the substrate that makes direction possible.

The honest answer for the next generation is that the foundational years still require building the substrate, even if the professional years won’t require deploying it the same way. That’s the teaching paradox at the heart of this transition. It’s the thing the CS curriculum has to figure out, and the thing most current curricula are getting wrong by either ignoring AI entirely or by skipping the foundational wiring in a rush to teach the agentic surface.

The Bigger Question

There’s a footnote to all of this that’s actually a bigger post.

If AI is becoming a teaching mechanism, capable of personalized instruction at infinite patience and zero marginal cost, the question worth asking isn’t only “what should universities teach?” It’s “do we even need universities the way they currently exist?”

The four-year residential institution provides several things at once: credentialing, forced exposure to ideas, cohort effects, apprenticeship, signaling, and actual teaching. AI demolishes the last one and possibly transforms the apprenticeship layer. The other functions are harder to disrupt but they’re also harder to justify at current tuition rates if the teaching is happening somewhere else for free.

That’s the post I’m working on next. The redesign in this piece assumes universities still exist. The next one questions the assumption.

For now, if you’re a student, a parent, or an administrator: the redesign is the practical move. The deeper question is the one that decides whether the redesign matters at all.

First published April 29, 2026 on 42 Insights.