The Developer's Hierarchy of Needs Is Being Eaten From the Bottom

You ship your first real feature as a junior and …. it took you three weeks. You wired up the API calls by hand, you fought the build until it went green, you wrote the tests, you fixed the thing you broke writing the tests. And when it finally worked, you felt something. Not relief. Pride. You had earned a little piece of the craft.

The machine does all of that part now. In thirty seconds. And the honest ones among us are quietly grieving about it.

Here is the argument, written down.

AI is eating the bottom of the developer’s pyramid. And when the base of a competence hierarchy collapses, it takes the sense of safety, belonging and esteem that was built on top of it down with it.

Let me explain what I mean.

A quick disclaimer, because someone will say it anyway

I am about to use Maslow’s hierarchy of needs as a lens. Before anyone reaches for the comment box: Yes. I know Maslow never actually drew a pyramid. I know the needs were never meant to be a strict ladder where you finish one tier before the next one switches on. People chase several needs at once, and lower ones only need to be partly satisfied before higher ones start pulling.

None of that is a new objection. Manfred Rätzmann made the same point back in 2015 when he projected Maslow onto software quality over at InfoQ. I am not treating the pyramid as a law. I am using it as a lens. A deliberately simple one. The simplicity is the point, because it makes the thing I actually want to show you impossible to miss.

We all on the same page? Good!

The pyramid we actually climbed

Think about how you became a developer. Not the version on your CV, the real one.

At the very bottom you learned syntax. Semicolons in the right place, brackets that matched, the incantation that made the compiler stop yelling. Then boilerplate. The glue, the wiring, the ceremony you typed a thousand times until your fingers knew it.

Above that, you learned to make it run. Debugging. Reading a stack trace without crying. The dark art of figuring out why it worked on your machine and nowhere else.

Higher still, the craft. Tests. Refactoring without fear. Clean code you were a little bit proud of. This is the tier Scott Hanselman mapped all the way back in 2012, source control at the base, automated tests and fearless refactoring near the top. For a lot of us that was the summit of being “good.”

And above that, the rare air. Design. Architecture. Judgment about what to build. And right at the top, taste. Knowing what was worth building at all.

Here is the part that matters. For a whole generation of us, our identity lived in the lower and middle tiers. You earned your seat by being fast and clean at the plumbing. “He’s a strong engineer” meant he could make the machine do the thing. That was the badge.

Now watch the bottom dissolve

Go tier by tier, from the floor up, and watch what the agents are doing.

Syntax and boilerplate? Gone. Commodity. Nobody is impressed that you can wire up a REST client anymore, because a model does it while you are still reading the ticket.

“Does it compile, does it run”? The agent iterates to green on its own. It writes the thing, runs it, reads its own error, fixes it, runs it again. The loop that used to be your afternoon is now a progress bar.

First-draft tests, scaffolding, glue code? Increasingly the machine’s job too. Not perfectly. Not always well. But well enough that the floor of the pyramid is no longer where a human proves their worth.

And here is where I want to turn something upside down.

In 2017 Monica Rogati drew the most famous version of this metaphor in our industry, the AI Hierarchy of Needs. In her pyramid, AI sat at the top. The shiny self-actualization you earned only after you had done the unglamorous work at the base, the data collection, the pipelines, the cleaning. AI was the reward for climbing.

Flip it.

For the working developer in 2026, AI is not the summit anymore. It is the foundation. It is the plumbing. The thing Rogati put at the peak has slid all the way down to the base and become the floor we stand on. The summit and the base have swapped places.

That alone would just be a neat observation. A tidy little reframe. But the inversion is not the part that should worry you.

The part nobody says out loud

When the base of your competence pyramid collapses, it does not just free you up. It knocks the footings out from under your psychological pyramid, the one that was quietly resting on top of it the whole time.

Think about what those lower tiers were actually giving you, beyond the code.

Safety. “I know how to do my job.” That feeling wobbles when the definition of the job changes under your feet every quarter.

Belonging. “I am one of the people who can do this.” That one erodes fast when anyone with a prompt and a credit card can do this.

Esteem. “I am good at the craft.” Hard to hold onto when the craft just became the cheap part.

This is the mechanism behind the anxiety every honest senior engineer is feeling right now and mostly not admitting. It is not that they are afraid of being replaced, not exactly. It is that the specific thing they were proud of, the thing that made them them, got commoditized while they were watching.

James Strong wrote a lovely piece for Contino a few years back called the Developer’s Hierarchy of Needs. Pay, tools, team, recognition, purpose. It is a good map of what a developer needs to thrive. But it was drawn for a world that stood still. It never imagined the floor itself moving. This is what his pyramid looks like once you set it in motion and let AI pull the bottom tiers out.

That quiet grief? It is real. It is not weakness. It is the floor moving.

Where do the needs go?

They do not disappear. They climb.

Here is the hopeful, uncomfortable part. What we used to call self-actualization, the rare air at the top, becomes the new baseline. It is the entry ticket now, not the reward you earn at the end.

Taste. Judgment. Knowing what is worth building and, just as important, what is not. Holding the whole system in your head when the agent can only see the file in front of it. And the big one, verification. Being the person who can look at a confident, plausible, fully-formed answer from a machine and tell whether it is actually correct, actually safe, actually maintainable. That skill used to be a nice-to-have on top of writing the code. Now it is the job. I wrote about one slice of this in Ownership Debt, the gap between generating code and actually owning it.

The new esteem comes from orchestration and discernment, not keystrokes. This is a drum I keep banging, your coding assistant is not you, and it has never been truer than now.

I am not going to pretend this migration is comfortable or that everyone makes it, because not everybody will. Some people loved the plumbing. They were brilliant at the plumbing. Telling them the plumbing is now the cheap part is not a growth-mindset pep talk, it is a genuine loss, and we should treat it like one.

And there is a hole in the floor I refuse to paper over. We used to grow juniors by letting them climb through the lower tiers. Grind the syntax, fight the build, earn the craft, slowly develop taste. If the machine now owns the bottom three rungs, how does a junior climb to the taste at the top? You do not get judgment by skipping the ten thousand hours that build it. The industry has not built that new ladder yet. Right now we are mostly pretending the problem will solve itself.

It won’t.

A claim you can hold me to

I do not want to leave you with a vibe. Vibes are not falsifiable. Here is a bet you can check in three years.

By 2029, “I can code” stops being a thing anyone says to earn respect, the same as “I can type” stopped being a skill you listed. The respect, and the salary, migrate to the people who can decide what to build and verify that what was built is right. Prompt fluency will be table stakes and worth nothing on its own, the same way knowing the syntax is worth nothing on its own today. And the hardest, best-paid problem in the field will be the junior pipeline, because the companies that figure out how to grow taste without the old apprenticeship will own the next decade.

If I am wrong, come find me and tell me. I would rather be corrected than comfortable.

Back to the junior who shipped in three weeks

That pride you felt, earning a piece of the craft one hard-won build at a time? The machine took the three weeks and turned them into thirty seconds. That is real, and the grief is earned.

But look again at the pyramid. It did not shrink. It moved. The floor you were standing on became a ceiling, and the ceiling is the new floor. The work that is left is harder, more human, and frankly more interesting than the plumbing ever was. The job was never really the typing.

It was always the judgment. We just finally got forced to admit it.

I would be very interested to hear your thoughts or comments, so please feel free to ping me on Twitter or LinkedIn.

If you lead a team, I would especially love to hear how you are growing juniors now that the bottom rungs are gone. Because I do not think any of us have cracked it yet.