The Developer Pipeline Is Breaking

So at this point, I think we’re all pretty aware of the impact of llms on software development. Suffice it to say that software engineering as it once was is over. No more large developmment teams. Getting a degree in computer science is no longer an easy button to a great job for a large number of graduates. I remember telling some of the engineers on my team “my job is to unblock you and be a force multiplier. I’m here to answer your questions, so don’t hesitate to bug me”. But why waste hours on that when I can just tell claude code a few bullet points and clean up the final details?

Coding as craftsmanship

Frankly, I’m a bit sad. I like writing code! Very few things scratch that unique itch. In the good old days, perfection (or close to it) was key. The logic you wrote had to be infallible. The computer does exactly what you tell it to. If you overlooked an edge case, guess what, it’s gonna pop up. I’m uniquely attuned to this because my background is in embedded development in C. One mistake, one dangling pointer … BAM hardfault exception! But at the end of the day, that was YOUR fault, not the machine’s. But oh boy. When you got it right? When that damn LED finally started blinking … euphoria.

But I can already see the writing on the wall. The machine is better at getting the details right. It won’t make as many mistakes and we’re probably better off using it. At least at first…

An LLM will never be the GOAT

Although it’s pretty clear that coding agents are at least as good if not better than the median developer, I haven’t seen them execute on the level of a senior/principal. And before you say “well it’s only a matter of time…”, remember this:

• llms essentially aggregate and average all the code ever written.
• have you looked at most of the code ever written? Its not … good.

If there is a bell curve of code quality, lets say that AI is on the upper end. There’s still a tail of excellent developers that exceed an llm’s capability. Maybe not in speed, but defintiely in quality. And there’s no way around this. An llm only knows “what have I seen the most?” and by defintion, the best developers do things differently than most.

Who watches the watchmen?

With that aside, let’s say it plainly: a capable AI coding agent can do most of what a junior developer does. Scaffold a feature. Write a CRUD endpoint. Debug a parsing error. Wire up a form. Not perfectly — but adequately, quickly, and without a salary.

So … goodbye junior devs? I think the answer unfortunately is “for the most part, yes”. The economics here are too hard to ignore. Faster, cheaper, and of at least average quality is a hard thing to argue against. But obviously there’s a gap here: in a world that doesn’t need a junior dev, how does one become a senior dev?

The learning problem

One thing I think that has been missing from the conversation around llm’s in general is what they allow us to shortcut. I think we can all agree that we need people to learn new skills. Developing knowledge and intution about a subject is something an llm is incapable of. We need skilled humans to make decisions and supervise these ai systems, and asking an llm what to do does not build the necessary cirtical thinking skills. To be clear, the advent of web search engines started the downslide of critical thinking but llm powered chat bots amplify the problem by orders of magnitude.

So how do we learn? Turns out we have some pretty good research on this now. Humans learn by doing. The two are inextricably linked. You can’t become a senior anything without first making a ton of mistakes. So if we want more senior developers, we need to first let them be junior developers

So what do?

This isn’t a new problem. Other skilled trades solved it a long time ago.

Electricians don’t let just anyone wire a building because they watched some YouTube videos and seem reasonably capable. Plumbers don’t hire people off the street because they’re “fast learners.” These trades have formal apprenticeship programs — often unionized — that deliberately structure the transition from novice to journeyman to master. You do the work under supervision. You demonstrate competence at each stage. You earn certification. You don’t skip steps.

The result? Trades that have existed for a century are still producing highly skilled practitioners, despite technology changing what those practitioners do. The structure of the pipeline is resilient because it was intentionally designed.

Software has never had this. We relied on an informal pipeline — entry-level jobs, large teams, patient senior devs, accumulated PRs — to grow talent organically. That worked when the entry-level job existed as a natural byproduct of building software. AI is disrupting that assumption. The informal pipeline is collapsing, and we don’t have anything to replace it.

This means a few concrete things:

Learning is valuable A senior developer is just a junior developer that had space to learn. We have to recognize that the learning part is important. A junior developer has to solve real problems with real constraints — and sometimes, that means solving them without the agent first. Not as punishment, but as practice. The apprentice plumber doesn’t use power tools on day one. They learn to feel the work. There’s no shortcut for that accumulation of intuition.

Certification needs to mean something. Not another coding bootcamp certificate or a LinkedIn badge. A rigorous, standardized measure of what a developer can do at each level of maturity — one that’s recognized across employers and protects workers from being evaluated purely on output metrics that AI can now game. This is uncomfortable territory for an industry that’s always prided itself on meritocracy-via-GitHub, but the discomfort is worth sitting with.

Unionization - Obviously this is a huge shift, but to perserve the craft, I think it’s necessary. Unions exist in part because skilled work has value that deserves protection, and because without structure, the incentive to extract labor at the lowest possible cost wins out over the incentive to develop craft. Software is not exempt from that dynamic. If anything, the pressure is about to intensify as AI compresses what “good enough” looks like at the entry level.

We don’t need as many developers - This is a tough pill to swallow. If we’re going to invest time and money into developing people to work with automated tools, we probably need less developers. Farming automation means less farmers and this is no different.

The trades figured this out. It’s time software did too.