Changing Roles
How the engineer's job changes when agents do the typing. The role shifts from writing code to directing, reviewing, and owning outcomes -- which reshapes the skills that matter, how people are hired, how performance is judged, and what it even means to be a software engineer.
The first two themes describe what agents do and what they run on. This one is about the people. When the typing is largely automated, the scarce work moves to the ends -- deciding what to build and proving it works -- and the engineer's day reorganizes around direction, review, and judgment rather than authorship.
That shift ripples outward. It changes which skills are worth building, how newcomers should learn the craft, what hiring should screen for, and how individual performance is fairly measured once "lines of code" means nothing. The patterns here trace those consequences -- honestly, including where the change is real and where it is still being figured out.
Two roles share a buzzword and get conflated constantly. Agentic coding is using AI agents to build software -- any software. AI engineering is building AI into products -- LLM features, RAG, evals, agents-as-product. One is a way of working; the other is a domain of work.
PeopleAs agents do the typing, the engineer's job shifts from authoring code to directing it -- scoping work, choosing approaches, reviewing output, and steering several agents at once. The unit of work moves up a level: from writing functions to specifying intent and judging results.
PeopleIf orchestration is the macro shift, collaboration is the texture of the day -- how you actually work alongside an agent: delegating, pairing, supervising, reviewing in the loop. It runs along a spectrum from solo (you and your agent) to shared (a team on common context) to multiplayer (people and agents in one live session).
PeopleThe gap between code that exists in your codebase and code anyone actually understands. As agents generate faster than humans can read, understanding -- not typing -- becomes the bottleneck, and the debt compounds: each unreviewed change raises the cost of the next one.
PeopleAs writing code gets cheap, the scarce skill moves to deciding what to build. The AI product engineer owns the outcome, not just the implementation -- pairing engineering with product judgment, taste, and direct contact with the user problem.
PeopleHow do you learn to engineer when the agent writes the first draft? The craft doesn't disappear -- it inverts. Fundamentals like systems thinking, debugging, and judgment matter more, even as syntax matters less. The risk is skill atrophy: leaning on the agent so hard you never build the judgment to supervise it.
PeopleWhen anyone can produce plausible code with an agent, the coding screen stops predicting much. Hiring shifts toward what agents don't supply: judgment, systems thinking, debugging under uncertainty, communication, and the taste to tell good output from merely plausible output.
PeopleOnce an agent can emit thousands of lines on command, output metrics measure the wrong thing. Individual performance has to be re-anchored on outcomes and judgment -- problems solved, quality shipped, decisions made -- not the volume of code produced.