The job market is sending a signal. In March 2025, Fortune reported that jobs classified as "computer programmer" had fallen to their lowest level since 1980, while "software developer" jobs barely moved. In early 2026, 69.3% of software job postings on Indeed were for senior roles, and only 4.5% were entry level, the lowest share of any field.
None of that proves AI is the cause. Job categories are blunt instruments, postings aren't hires, and Indeed itself points to interest rates, remote work and the post-pandemic hangover as part of the story. But it's consistent with what I see every day: the typing job is shrinking, and the deciding job is holding.
The skills that matter now aren't new. They're the skills that have long separated senior engineers from everyone else. The difference is that they used to be what you grew into after years of writing code. Now they're the job from day one.
What matters now
Systems thinking. Agents are excellent at building the pieces. Someone still has to decide what the pieces are: where the boundaries go, how the parts talk to each other, what happens at ten times the load, what breaks when one part fails. That's architecture, and it's yours.
Product sense. Knowing what's worth building, and noticing when you're about to build the wrong thing, is the highest-leverage skill there is now. An agent will build exactly what you ask for, beautifully, even when it's the wrong thing.
Letting the agent find a better way. This one surprises people, and it's the one I see seasoned engineers struggle with most.
You have patterns that worked for your entire career. That doesn't make them the best way. It makes them your way. When you push an agent down your path explicitly, you get your pattern, written faster. When you give it the goal and a way to measure success and let it experiment, it often finds approaches you'd never have tried. Not because you're wrong and it's right, but because its lens on how to solve a problem is wider than yours.
My stack-benchmark project is built on exactly that. One spec, nine backend stacks, and the agents optimized every one of them through iteration and timing: load test, profile, change one thing, measure again, keep what moved the numbers. They found things I'd have been proud to find myself. In one case, a lock hidden inside a database library was slowing every request, and fixing it took one stack from about 3,250 simulated users to more than 6,000. I didn't tell them where to look. I told them what fast meant and let them work.
That's the skill: define the target, build the measurement, and get out of the way.
Letting the agent explore doesn't mean letting go of the guardrails, though. The architecture, the security rules and the operating limits are yours, and they're part of the target. An approach that's faster but leaks data isn't a better way.
The rest of the toolkit
Those three get the headlines. The rest of the job leans on skills that have long been part of senior engineering and matter more now:
| Skill | Why it matters more now |
|---|---|
| Verification and test design | Agents write the tests, but you decide what "working" means |
| Security and failure analysis | Someone has to ask how it breaks and who could break it |
| Observability and incident response | Code you didn't type still pages you at 2 a.m. |
| Domain expertise | Agents can't learn your business from the code |
| Communication and specification | Plans and requirements are now the main way work gets done |
| Cost and operational judgment | Fast and cheap to build doesn't mean cheap to run |
What to let go of
Some of what made you good is now just weight.
- Syntax mastery as status. Knowing a language inside out was a mark of seniority. It isn't the scarce skill anymore.
- Framework loyalty. Being "the React person" or "the Rails person" matters a lot less when agents can write any stack. If you're not the one typing the code, pick the stack for what it does, not for what you're comfortable writing. Rust is miserable to write by hand. I don't care anymore, because I'm not writing it.
- Pride in lines of code. What you typed was never the point. What you shipped, and whether it worked, was.
- Hand-tuning everything. Describe the target, measure it, and let the agents iterate. You'll get further, and you'll get there faster.
Letting go of syntax isn't letting go of technical depth. You still need to understand systems well enough to challenge a design, diagnose a failure, and notice when an agent's output doesn't add up. The scarce skill moved from recall to comprehension.
None of this means your experience is worthless. It means its value moved from your hands to your judgment.
If you're just starting out
The bottom rung of the ladder is the one disappearing fastest. And the truth is, I don't know exactly what to tell a junior engineer. Nobody does yet. Anyone who gives you a confident career plan for this is guessing.
What I do know is what I'd do in your shoes: get to work.
Don't wait for a company to teach you this. Start building applications now. Look at the problems in your own life and solve them with software. Use your own agentic workflow to do it, and master that system for your own use cases. Plan, requirements, implementation, docs. Run it again and again until it's repeatable, until you can take any new problem through it and get working, tested software out the other end.
That's the skill nobody can take from you. And when the opportunity comes, a job, a project, a team that needs someone who already knows how this works, you won't be learning on the job. You'll be the one who's ready.
If you're already in the job
Mid-level and senior engineers have the biggest advantage right now, if they use it.
- Become the domain expert. Your institutional knowledge, why the system is the way it is, is the most valuable thing you have. It's what agents can't figure out from the code, and it's what every plan and every set of technical docs depends on.
- Lead agents like a team. Delegation, clear specs, review against the requirements, holding the line on quality. If you've ever been a tech lead, you already have most of these skills. If you haven't, this is the time to learn them.
- Move toward the business. Get closer to customers, product, and outcomes. That's where the decisions are made, and decisions are the job now.
- Start now. The runway is shorter than it looks. The engineers who make the switch early will shape how their teams work. The ones who wait will be handed a process someone else designed.
Where to practice
Every one of these skills gets better the same way: by building something, start to finish, with the process.
You don't need permission or a work project for that. Look at the small, annoying problems in your own life. That's where the last part of this series goes: Just Start Building.