The Job Didn't Change. The Work Did.

My title says Staff Engineer. My actual job is directing a fleet of AI agents — decomposing problems, designing handoffs, verifying output, catching drift. The code still ships. I just don't write most of it anymore. The strange part is that this isn't isolated. The titles just haven't moved.

What Staff Engineer Used to Mean

Before 2024, the title ladder was clear. Junior engineers wrote code under supervision. Senior engineers wrote code without it. Staff engineers set technical direction — they decided what to build and how, reviewed the critical work, and held the architectural standard across a team. Principals did that across multiple teams. Everything output was code: yours or someone you mentored.

The measurement of seniority was depth and scope. How complex were the systems you could reason about? How wide was your influence? But the unit of output stayed constant: code, written by a human.

That assumption is starting to crack.

What the Work Actually Looks Like Now

Most mornings I don't open an IDE. I open task queues.

The day looks more like this: break down a problem into agent-shaped subtasks. Write the prompts and constraints that define each subtask well enough that an agent can execute it without going sideways. Review the outputs. Catch where the agent drifted from the requirement. Design the verification gate that catches that drift automatically next time. Decide which outputs need a second agent pass and which are good enough to ship.

The judgment calls are technical and hard. They require understanding what agents are good at and where they fail — and that failure surface is subtle. Agents are confident in their errors. They don't flag uncertainty the way a junior engineer might. The correction loop is invisible unless you instrument it. Building the harness that makes the loop visible and recoverable is real systems work.

But it's not coding in the traditional sense. It's closer to technical direction combined with quality architecture. The output I produce most days is orchestrated outcomes, not files.

The Title Gap

Here's the problem: compensation and job descriptions haven't caught up.

If you look at what titles mean today versus three years ago, a few patterns are visible:

Titles that held their meaning: Engineering Manager, Principal Engineer, VP Engineering. The scope changed slightly with AI tooling but the fundamental definition — people management, cross-org technical influence, organizational function — stayed stable.

Titles that inflated: "AI Engineer" started as a precise term (someone who builds AI-powered products, distinct from ML researchers who train models). It became a catch-all fast. On job boards today it ranges from "knows how to call the OpenAI API" to "designs multi-agent production systems." The precision degraded with adoption.

Titles that vanished: Prompt Engineer. Dead as a standalone role. The skills got absorbed into every engineering job description. Same trajectory as "webmaster" in the mid-2000s.

The gap: There is no established title for the person who primarily directs agents, designs the orchestration layer, sets quality standards for agent output, and builds the eval harnesses that catch failures. It's a genuine role — I live it — but the title hasn't stabilized. "Agentic Systems Lead," "AI Orchestration Architect," "Agent Director" all exist in scattered job postings. None have reached critical mass.

Why Titles Lag

The pattern is consistent across technology shifts. When a new capability arrives, the people who use it earliest don't get new titles — they get their old titles appended with "+" until the industry figures out what the role is.

"Systems Engineer" became "DevOps Engineer" became "SRE" over the better part of a decade. The work was distinct from the start. The title took time to settle. The same lag is happening now.

Where This Is Going

In the next year or two, I expect to see job postings for "Agentic Systems Architect" and "AI Engineering Lead" that describe this function precisely. The compensation benchmarks will follow once the title stabilizes — they always do.

What Seniority Means Now

The old definition was depth of code plus scope of influence. The new one is forming around something different: the quality of judgment you bring to directing systems you don't directly control.

That's harder to measure than code quality. There's no linter for decomposition. No test suite for whether you've designed the right verification gate. The feedback loop is slower, and the errors compound in ways that don't show up immediately. An agent that's been running in the wrong direction for three days has done three days of damage by the time you catch it.

This is why the role feels harder than the title implies, and why the jump from "engineer who codes" to "engineer who directs agents" isn't automatic. The technical depth still matters — you can't design a good verification gate for code you don't understand. But the leverage point has shifted. What separates a good agent-directed engineer from a mediocre one isn't raw output, it's the quality of the judgment calls that shape what the agents do.

That's a different skill than writing good code. It's also a harder one to prove.

I started this post saying my title says Staff Engineer and my actual job is directing a fleet of agents. That gap is real, and I don't expect it to close soon. But it's interesting work — building systems that can do more than any one engineer alone, where the quality of what comes out reflects the quality of what you put in.

The job didn't change. The work did.

Navigating this shift — as an engineer figuring out how to position yourself, or as a team writing job descriptions that actually reflect what senior engineers do now? I'm curious what you're seeing. Get in touch.