← All notes

Redefine the Senior First

AI is narrowing the way into software engineering, but I don't think the junior role is going away. I think it's going to change, and that depends on something we haven't figured out yet.

I keep hearing the same question: if AI can do in minutes the work we used to give a junior developer, what happens to juniors?

My short answer is that the junior developer as we knew it is going to change. They won’t work on the same things and, above all, they won’t need to learn the same things. But there’s a problem before we get there: we can’t define what a junior should know until we’re clear on what a senior does. And right now, that changes almost every month.

What the numbers say

The way in is getting narrower. In August, the Stanford Digital Economy Lab updated its Canaries in the Coal Mine? study using payroll data covering millions of US workers. It found that employment for 22- to 25-year-olds in AI-exposed occupations is 19% below where it would be if it had kept pace with less-exposed peers. They aren’t being laid off; they’re being hired less.

Indeed Hiring Lab sees it from another angle: software development postings are growing again, but 71% of that increase came from senior roles.

It’s also fair to say not everyone blames AI. LinkedIn’s researchers, in their January report, attribute the slowdown mostly to interest rates and economic uncertainty. The real answer is probably a mix of both.

The junior depends on how we define the senior

Juniors have always learned by watching how someone more experienced works. You pick up the team’s standards, how to review code, how to break a problem down. The path from junior to senior was more or less known.

Today that path isn’t clear, because the senior’s job is changing while we do it. The way I work with agents now isn’t the same as six months ago, and it probably won’t be the same six months from now. First we need to settle what being a senior means in the AI era, and until then it will be hard to design a path for people who are just starting.

That’s why I think we’ll see junior positions again, just maybe not in the immediate future.

We now train agents, not people

There’s something I notice in my day-to-day work that I find revealing. A big part of a team’s energy used to go into teaching new people how things are done: the conventions, the architecture, the “we don’t do that here, and here’s why.”

Now that same energy goes into teaching agents. We write Skills, rules, and MCP servers so the AI works a certain way. The knowledge that used to pass from a senior to a junior is now being documented for a machine.

I completely understand why companies make that call. From the business side, it’s hard to compete with something that solves in minutes what used to take a person days. But that’s exactly what’s still being defined: what a new person brings that an agent doesn’t.

This has happened before

Developers today don’t need to write assembly or manage memory by hand to be productive. The same goes for COBOL or Fortran: they still live on in some systems, but they’re no longer the focus of the profession. High-level languages gave us a layer of abstraction that let us build more, faster.

Companies understood it that way too. They don’t hire someone to write assembly when a C++, Java, or Python developer gets them better results in less time. Low-level knowledge didn’t stop being valuable; it stopped being the way in.

I think AI is the next layer of abstraction. New ways of delivering software will appear that make results easier and better, as is already happening. A deep understanding of how code works will always be an advantage, but the starting point is going to be different.

AI as backup for your weak spots

When I started, it was normal to be very good in one area and weaker in others. Some people were great at building layouts, others at logic, frontend, backend, or databases. Filling those gaps took years.

Today AI is useful for exactly that: strengthening the areas where we’re weak. Someone strong in frontend can step into a database with much more confidence, because they have something to ask, to review with, and to learn from in the moment. For someone just starting out, that’s a huge advantage that didn’t exist before.

The bar has always been rising

If you’re looking for your first job as a developer, I won’t tell you it’s easy. But I do want to give you some perspective: the bar has always been rising.

There was a time when a bit of HTML and Bootstrap was enough. Then they asked for jQuery. Then React. Then TypeScript, Next.js, testing, and knowing how to deploy to the cloud. Today, on top of all that, you’re expected to know how to work with agents and, above all, how to properly review what they produce. Every generation of developers felt that getting in was harder than it was for the one before, and every one of them found a way.

And it can be done. In 2024 and 2025, years that were no longer the best for developers, I watched someone from a team I happened to lead prove a huge amount in a single year and land a job where their salary went up 200%. It wasn’t luck: they studied a lot and committed to understanding the real challenges of a platform with a complex codebase, not just closing tickets. The opportunities didn’t disappear; they got more demanding.

My advice is simple:

  • Don’t get discouraged, and keep learning. The tool of the moment will change; the habit of learning won’t.
  • Learn to review AI’s work. I think this will be one of the most important skills for a junior: knowing whether what an agent generated is right, why, and what you’d change.
  • Use AI to cover your gaps, not to avoid understanding. Make sure you can explain everything you ship.

Why I’m optimistic

My point of view may be optimistic, but I truly believe it: just as AI is limiting some jobs, it’s also going to make software grow enormously.

When something becomes cheaper to produce, we usually don’t produce the same amount with fewer people; we produce a lot more. Custom software used to be expensive and slow, so only companies that could pay for it had it. Now small businesses, teams that never had developers, and people with an idea will have software within reach. We’ll see more and more complete, more functional software in places where there was nothing before.

On top of that, software has an advantage almost no other industry has: it doesn’t depend on a raw material. A factory can’t produce twice as much without twice the steel, chips, or oil. Code doesn’t have that limit. It needs compute to be built and to run, yes, but once it’s written it can be copied, distributed, and improved at almost no cost. So when making it gets cheaper, nothing holds it back: software will grow faster and more easily than anything that depends on physical resources.

That bigger market is going to need people. Not to do what a junior did in 2020, but for something we’re still defining. And once we seniors figure out what our new job is, we’ll know how to train the people coming up behind us.