Press enter or click to view image in full size
The senior full stack engineer as an agent orchestrator
A friend of mine — a senior full stack engineer — reached out recently for advice. She’s looking for work and wanted to know: what’s actually valuable now? How should she position herself in a market that seems to be shifting under everyone’s feet?
It’s a fair question. If you’re a senior engineer watching coding agents get better by the month, it’s natural to wonder where you fit. Here’s what I told her.
When code becomes cheap, intent becomes valuable
The framing I keep coming back to is this: when generating code becomes cheap, the most valuable engineers are the ones who can synthesise user and customer problems into clear intent — and then, with the right guardrails around quality, architecture and design, get great output from agents.
You’re essentially acting as tech lead and PM for coding agents who do the heavy lifting.
The best senior full stack engineers always sat at the intersection of product, design and tech. That was always the superpower — the ability to hold the whole problem in your head, from user need to system design to shipped feature. Now it matters doubly so, because with agents, a single engineer with that full breadth can deliver almost the output of a full team.
So the biggest shift isn’t technical. It’s mindset. The engineering is here to serve the product, the user experience, and the customer problem. That was always true, but now there’s less busywork to hide behind.
Get good at working with agents
This is the new craft, and it’s developing fast.
Go beyond plan mode with Spec Driven Development. If you’re using agents in plan mode — where the agent proposes a plan before executing — that’s a good start, but it’s not enough. Frameworks like GitHub’s Spec-Kit and GSD (GetShitDone) take it further by essentially recreating the agile lifecycle with agents at the centre. You write specs and acceptance criteria up front. You take the hat of PM, tech lead and designer at different stages. You review output against those criteria and iterate. The human insight — the why, the edge cases, the taste — comes from you. The volume comes from the agent. This walkthrough is a solid introduction to what this looks like in practice.
Context engineering. This one is underrated. Learn to manage agent context deliberately — use skills files, use commands, pull in relevant context only when it’s needed. Dump too much in and you get context rot/poisoning: the agent drowns in irrelevant information and loses track of what actually matters. Think of it like briefing a contractor — give them what they need to do the job well, not a copy of your entire company wiki.
The tried and true — arguably more valuable than ever
Here’s the thing that I don’t think gets said enough: the fundamentals haven’t stopped mattering. If anything, they matter more.
Good taste in architecture and code design. Agents get it right 95% of the time. But that remaining 5% is where the subtle, complex, expensive bugs live — the ones that cascade, the ones that only surface under load, the ones that make you rethink a design decision three months in. Without strong engineering judgment, you won’t even notice the 5%. You’ll ship it, and you’ll pay for it later.
Quality engineering practices. Here’s the analogy I keep using: think of agents as very fast but very naive junior devs. They’re enthusiastic. They’re prolific. They don’t always know what they don’t know. This is the point where the quality practices in a codebase really start paying off — just like they would if you suddenly had a herd of juniors doing the coding. Fast locally runnable CI. Linting. Typing. A reliable automated test suite that lets you validate agent output quickly and confidently.
The guardrails you set are what separate shipping fast from shipping broken.
The leverage is real
I told my friend that this isn’t a market that’s getting worse for senior engineers — it’s a market that’s getting worse for engineers who only wrote code. If you can hold the full picture — product thinking, design sensibility, engineering judgment — and layer on the emerging skill of agent orchestration, you’re not being replaced. You’re being multiplied.
The engineers who thrive in this next chapter won’t be the ones who write the most code. They’ll be the ones who know what code should be written, and why.