Seniority Alone Won't Get You Hired Anymore

When a developer tells me they have fifteen years of experience, I ask about their AI experience and what they’ve built with agents. The answer I keep getting is some version of “I’ve used the free version, but I run out of tokens so I can’t do much.”

Then comes the part that surprises me more. They expect their next employer to cover the gap, with a course, a ramp-up period, some paid time to figure it out. That’s not how it works anymore. Employers expect engineers to use AI from day one.

I get where that comes from. For twenty years companies did pay to move you from one framework to the next. This time they aren’t waiting, and seniority alone won’t get you hired anymore.

The years on your résumé mean something different now

Years of experience used to stand for two things, speed and judgment. You could build it fast, and you knew what to build. Employers paid for both.

Agents took over the speed. Writing the code is now the fast part of the week, and it was never the whole job anyway.

That leaves judgment. You know what to build and what to cut, how the pieces fit, and what falls over at 1,000 users. An agent has none of that unless someone hands it over, and the person who can hand it over is the one with fifteen years behind them.

So the experience is worth more than it was. An experienced developer who’s all in on AI is a 100x developer. Simple as that.

The same fifteen years without AI gets you a résumé that reads like 2022.

Senior developer AI experience is the first thing employers ask about

The founders I talk to are building smaller teams, and they’ve stopped trying to convert the people who won’t adopt AI. They would hire one developer who already works this way before they’d train five who don’t.

That’s why the “who pays for my training” question goes nowhere, and why running out of free tokens is an excuse. A Claude subscription is $20 a month, less than what you pay for dinner on a night out, and it will get you further right now than anything else you can buy with that money.

$20 or $100 a month is not tuition money. It’s the difference between staying unemployed and making six or seven figures.

The training itself is a few months of using the tools on something real. An employer looking at two senior candidates picks the one who already put in those months.

The job is architect now

Nobody expects you to hand-code anymore, which is the hard pill, because the typing is the part a lot of us fell in love with.

The job you’re being hired for is the one above it. You decide what gets built, break it into pieces an agent can finish, set the constraints, and check what comes back. I wrote about that role in The AI Orchestrator, and the 5 levels of agentic engineering are a decent map of how far along you are.

You still keep an eye on the code. The agent has no gut feeling and no idea what your business needs this quarter, and I’ve seen green tests sit on top of the wrong feature. Catching that is what the fifteen years are for.

What the shift looks like day to day

The developers who are stuck aren’t short on talent. They’re holding on to a picture of how software should be made, and I held most of that picture too. This is how I work now.

Describe the work, then review what comes back. I say what I want, the agent writes it, and I read the result. My hands are on the keyboard less than they’ve been in my whole career, and I’m responsible for more of what ships.

Own the testing. I believe in end-to-end tests more than unit tests, because a suite can be green while the feature is wrong. I also still go through it by hand before it ships. That check is part of the job now, and it stopped being QA’s problem.

Set a time box and skip the estimate. When the build goes from weeks to hours, estimating it stops telling you anything. I pick how long I’m willing to spend and cut the scope to fit.

Write a short spec you can check. A goal and a list of outcomes that a test or a person can confirm. That list is what the agent builds against, and it’s what I hold the result up to.

Design in real code. I ask for three or four rough versions of a screen, built for real, then pick one and throw the rest away. That takes less time than waiting for one finished mockup used to.

The old way of doing each of these made sense when writing code was slow and expensive. Writing code is neither now, and the habits built around that cost are the ones to drop first.

If you’re the one hiring

The years still tell you something about judgment. They tell you nothing about whether a developer can put that judgment to work through agents.

So ask them to show you. Have them walk you through the last thing they built with agents, including how they checked the result. A developer who works this way every day can’t stop talking about it, and one who doesn’t will tell you about a course they plan to take.

If you have fifteen years, you already own the half that takes fifteen years to get. The other half takes a few months, and nobody is going to start it for you.