Learning to Build Without a Ladder

I never got the junior job.

Not for lack of trying. I spent well over a year applying, building, learning, and applying again. For long stretches I could not get past the first filter, let alone into a room with an engineer. And I am not unusual. I am one of a very large group of people who entered software and security over the past five years or so and found that the door marked "start here" had quietly been taken off its hinges.

We are often described as self-taught, as if that were a personality trait or a lifestyle choice. For most of us it was not a choice. It was the only path left standing once the others were dismantled.

The ladder that used to exist

The traditional way you became a good engineer looked roughly like this:

learn, get a junior role, make mistakes under supervision, become competent, become mid-level, eventually become senior.

Every rung mattered, and the early ones mattered most, because that is where you were allowed to be wrong cheaply. Someone experienced sat near you and said "not there, we tried that two years ago, here is what happened." That sentence is worth more than any tutorial ever written.

What replaced it, for a lot of people, is this:

learn, apply, rejected, apply, rejected, apply, rejected, somehow already be experienced.

And then the same industry turns around and says it needs experienced developers. Where, exactly, are they supposed to come from? You cannot eliminate the junior opportunities and then complain that there is a shortage of seniors. Those seniors had to be made somewhere. The industry has been eating its seed corn and acting surprised at the harvest.

The uncomfortable part is that no single company is behaving irrationally. Each one reasonably asks why it should train someone for two years when it can hire a person who already knows the system, especially when hundreds of thousands of experienced developers have been laid off and are already on the market. Individually rational, collectively ruinous. The full cost does not show up on a quarterly report. It shows up years later, when the people who could have become the next generation of seniors were never given the chance to start.

What I did instead

If the apprenticeship was gone, I had to build my own. So I went where the door was still open: open source.

Open source has always been one of the few places where you can say "I do not have a job yet, but I want to become good," and actually be taken up on it. You find a project. You read the code until it stops being frightening. You fix something small. You submit it. Someone reviews it and tells you, plainly, what is wrong. You improve. You come back for something harder. That loop is an apprenticeship. It is the apprenticeship, just without the salary or the org chart.

Here is what that looked like for me, concretely.

I contributed a fix to GitLab core that was reviewed, merged by a maintainer, and shipped to production in a release. Small in scope, but it was real code in a system that millions of people depend on, held to the standard of people who maintain that system for a living.

I built the Pyxel Config Lab, a tool for building and validating configuration for the European Space Agency's Pyxel detector-simulation framework. It was credited by ESA in an official release announcement. I did not have a job at ESA. I had a problem I understood and the willingness to solve it in the open.

I started contributing to OpenSPP, an open-source social protection platform, because reliability and validation are what I care about most and because that work touches systems that actually matter to people's lives. My first contribution there was, characteristically, about validation: making sure a record could not accept an impossible value and quietly produce nonsense downstream.

I began working into OpenTelemetry, because the instinct that made me care about clean configuration and honest error messages is the same instinct that makes me care about whether a distributed system, or an AI system, can tell you the truth about what it is doing.

Alongside that I built accessibility tooling as browser extensions, and I write. A lot. The writing is not a side project; it is how I think, and it is how a person with no institutional letterhead makes their work legible to strangers.

None of this was assigned to me. Nobody onboarded me. I assembled the apprenticeship out of whatever was reachable, and the reachable thing was the open commons.

What you can learn from home

Here is the part I want to be honest about, because I think the "just teach yourself" crowd gets it badly wrong in the other direction.

Information is everywhere now. You can learn languages, databases, distributed systems, compilers, networking, and architecture from your bedroom. What you cannot fully learn there is what it feels like to be responsible for a system that has been running for six years, with dozens of developers, three generations of architectural decisions layered on top of each other, real customers depending on it, and someone telling you not to touch a particular corner because the last person who did caused an outage.

That knowledge is situational. It is institutional memory. It is the difference between knowing what a database index is and having migrated a live database with users on it at an hour you would rather forget. No course, no book, and no chat assistant can hand you that. You have to live it, inside a real organization, with real consequences. Which is precisely the thing the closed door denies us.

So I am not claiming the self-taught path is equivalent. I am claiming it is what was left, that many of us became genuinely capable through it, and that the fact we survived the missing ladder does not prove the ladder was unnecessary. It proves how resourceful people get when a system fails them.

AI is an accelerant, and the direction is a choice

I work AI-assisted. I do not type every line unaided from a blank file, and I am not embarrassed by that. I remain accountable for every design decision and can explain any of them. For someone learning without a senior at the next desk, an AI collaborator is genuinely powerful: it will explain an unfamiliar architecture, propose alternatives, surface edge cases, write tests that expose your own assumptions, and shorten the hours you would otherwise spend stuck. That is real mentorship-shaped help, available to people the labor market gave nothing to.

But the tool is neutral, and the institutions using it are not. Picture two companies with the identical AI.

Company A says: apprentices use this, seniors review their work and teach them why things are wrong. AI becomes an accelerator for apprenticeship. You can fast-track a motivated beginner into a productive engineer faster and more cheaply than before, and they want to be there, so the company wins too.

Company B says: the AI writes most of the code, so we do not need juniors, give us a handful of seniors. AI becomes an accelerator for headcount reduction, and the learning layer is deleted.

Same technology, opposite outcomes. Company B looks better this quarter. Company B is also quietly ensuring there are no seniors to hire in five years.

There is a bitter twist here for people like me. The same industry that shut the door increasingly rejects the way self-taught engineers actually work. I have been ruled out of roles for using AI in an assessment, judged by a process that bans the exact tool the situation forced me to master, while the label "vibe coder" gets thrown at anyone who works this way. You cannot remove the apprenticeship, hand people a tool to survive without it, and then penalize them for having learned to use it.

The flood is fine. Judgment is the skill.

People worry about the flood: too many apps, too many libraries, too many books, too much of everything now that the barrier to creation has dropped. I do not share the worry. Lowering the barrier to making things is good. If someone who could never program before builds a small game for their friends, wonderful. Not every act of creation has to be economically optimized, any more than every painting has to sell.

The real line is not between AI-generated and hand-written, and it is not between accessible and gatekept. It is between creation connected to understanding and creation disconnected from it, in the places where correctness actually matters. Accessibility is wonderful. Learning is necessary. Blind delegation is dangerous. "Ban the tool" answers none of that. The skill that matters now is judgment: can the person understand, test, and improve what the tool produced. That is the thing we should be teaching, and it is exactly the thing you build by doing real work under review, which is exactly the thing being taken away.

Engineering is not a business subplot

Business constraints are real. Cost, deadlines, regulation, and risk shape engineering, and an engineer who pretends otherwise builds beautiful things nobody can afford. But there is a healthy boundary, and it has been crossed repeatedly. Business should set the constraints and the goals. Engineering should decide how those goals can be met safely and realistically. When leadership starts dictating technical reality instead, that this will take two weeks, that tests are optional, that the generated code is fine as-is, that another senior is an unnecessary expense, that the mentorship layer can go, you get exactly the collapse we are living through. A society can outsource the production of goods. It cannot indefinitely outsource the production of expertise.

The generation that learned to build without a ladder

That is not a happy ending, and I will not pretend it is one. The ladder mattered. Removing it hurt real people and is storing up a shortage the industry will feel for years. But it is also true that the commons is still open, that the work is still real, and that a reviewer on an open-source project will still tell you the truth about your code, which is more than most job applications ever will.

I am building my own path now as an independent engineer, and I try to pass the ladder back down where I can, including teaching basic digital skills to people who have even less access than I did. Not because the system worked, but because it did not, and someone has to keep the door propped open.

The question I would put to the industry is simple, and it is not "will AI replace programmers." It is this: who is going to produce tomorrow's experienced engineers, if today's companies keep removing every opportunity to become one?