Agents don't make the roles disappear; they change them. The easy assumption is that engineering and product blur into one role where everybody prompts. In my experience every role is still needed, but what each one does changes, and so does how people learn the craft.
Impact on engineers
The agent writes the code now, so an engineer's value is no longer in writing it. It is in designing software that holds up, under load, at an acceptable cost and secure, and in building the machine that lets agents build without them. Engineers who only write features, even with an agent, keep the team as fast as they can type. And the experience that lets someone judge an agent's work is being used up. I can challenge an agent's explanation of a failure because I spent years diagnosing things myself. Juniors won't build that experience by typing, so they have to learn another way.
- Hire engineers for how they design software, not for how they write code. The agent writes the code, so how fast someone writes it tells you little. Hire for whether someone designs software that holds up. A good engineer knows the impact of, for example:
- two parts of the code that update the same tables in a different order, and deadlock each other under load;
- choosing between an HNSW and an IVFFlat index on a vector database, and what each costs in memory, build time and accuracy;
- caching information that is invalidated too often;
- a retry mechanism that executes the operation twice;
- caching information in memory for performance, and then running into cost issues on a real production server;
- a queue that delivers a message twice, to a consumer that can't cope with that;
- a core that talks directly to one specific provider instead of to an interface it owns;
- components without a proper separation of concerns, so you can't test them on their own.
None of this shows in how fast someone types code or how keen they are on AI. It is a different person to look for, and a different interview.
- Have engineers work on the harness too, not only on features. An engineer who only builds features, even with an agent, is unlikely to speed up their own work or the team's. Make sure engineers also work on the machine: the skills, the checks, the tests and the reports that let agents build features without them. Every improvement there speeds up every change after it. More in Managing your harness.
- Hire junior engineers, and have them make the design while a senior challenges it. If nobody hires juniors, there are no seniors in ten years. Juniors used to learn the problems in the list above by writing code and making the mistakes themselves. Agents now write that code faster and better, so juniors won't build up that experience by typing. So stop having a junior write the code and a senior review it. Have the junior make the design, and have the senior challenge it. The junior explains each choice, the senior asks whether they considered A, B or C, and that is how the junior learns.
Impact on product people
If an engineer with agents builds ten times as much, the product person has to supply ten times as many decisions. That doesn't mean you stop thinking ahead: you still need to know where the product is heading six months from now. But a backlog groomed weeks ahead is half wrong by the time it is built, and the agents finish faster than the next planning meeting comes around. So product has to decide at the pace the building now happens, which means much more just in time. Product people also take over the scoping, and build some changes themselves.
- Keep the direction for the coming months, but scope each change just in time. Know where the product is going, so the team doesn't build in the wrong direction. Leave the detail of each change until just before it is built: that is when you know the most, and the agents are ready to build it. A detailed backlog weeks ahead is work you will mostly redo.
- Let product people do the scoping. A product person who describes a change and waits for an engineer to scope it adds a handover nobody needs. Give product people the scoping skill and let them run it themselves; an engineer joins for the technical design only when the change needs one. In Cockpit, scoping and the engineering plan are separate skills, each run by the person who owns it, so product can stop after scoping. The rule is in CLAUDE.md.
- Let product people make a change themselves when it needs no design, and run it through the same checks as any engineer's. The risk is that they change the design without knowing it. So let the engineering plan decide whether a change needs a design; when it doesn't, a product person can build it, through the same checks as every other change. A check that bends for one person's title was never really a check. Cockpit's
/engineering-plan only opens a design round when it can name one of these reasons, such as a new place where data lives, a new external integration, or a cost that grows with accounts or time.
Between people
Most of this page is about what changes. One thing doesn't: a team is still people, and some problems only show up when they talk to each other.
- Keep a regular conversation between people, because no tool shows you when someone is stuck. Nothing that reads pull requests, review comments or tickets can see whether someone is stuck on a skill gap, whether two people are quietly duplicating effort, or whether the team trusts how decisions get made. None of that shows up in a diff. No skill or automated review replaces that conversation; it still has to happen between people.