For most of my career, the barrier of entry to a software job was, roughly, can this person write a for-loop, debug a small program, and not panic when the screen is red. It wasn't a high bar. It was a clear bar, and people crossed it every week by sitting in a bedroom with a tutorial and grinding for six months.
That bar is gone. There is a new bar. It is much, much higher, and almost nobody is talking about it honestly.
What the old bar actually tested
The for-loop bar wasn't really about the for-loop. It was a proxy for something else: can this person tolerate confusion, sit with a broken thing, and slowly work it out. The for-loop was just the cheapest available test for that disposition.
Most of the value of an entry-level job, for the junior, was repetition of small confusions until pattern recognition formed. You wrote a thousand small wrong programs and gradually became someone who could write a medium-sized right one. That apprenticeship took two to four years. It was boring. It worked.
What the new bar tests
The new bar isn't can you write a for-loop. The model writes the for-loop. The new bar is can you tell whether the for-loop the model wrote is the right for-loop.
That is a much harder thing to test for, and a much harder thing to teach. It requires:
- A model in your head of what should be true
- The judgment to notice when the output doesn't match that model
- The vocabulary to describe the mismatch
- The patience to fix it
A six-month bootcamp graduate, three years ago, could land an entry job and develop those four things on the company's time. The same graduate today gets to the interview, watches a senior engineer ask "but what happens if the input is empty?", and discovers they have no machinery for thinking about that question. The model would have handled it. They never built the muscle.
The old barrier was a wall you could climb with enough determination. The new barrier is a fog. You can't see how far you have to go, and the people on the other side can't see you coming.
The uncomfortable consequence
The honest consequence is that the easy way in is closing. Not because the industry is gatekeeping — most seniors I know desperately want to hire juniors — but because the work that used to be the way in has been swallowed by tooling.
Companies still post junior roles. They get five hundred applications. They hire one person. That person is, increasingly, someone who built the judgment-muscle through a side project, an internship at fifteen, a parent in the industry, or sheer obsession — not the bootcamp graduate the role was nominally written for.
What I tell people now
When someone asks me how to break in, I no longer say learn a stack and apply to junior roles. I say:
- Build the thing the AI can't yet build for you — the wrong-detection muscle.
- Ship something small and finished. Not a clone. Something with a user who isn't you.
- Be cheap to keep around in the early years. The juniors who survive are the ones who don't need to be senior in 18 months.
I don't know if this is the right advice. The honest answer is that I don't know what the right advice is, because the path I took no longer exists. The bar moved. We are all figuring out where it landed.
There is a longer version of this argument — about what happens to the seniors in a world where juniors don't get trained — that I am still working out. More on that one soon.