The New Job of Product Leaders in the Coding Agent Era

AI-assisted software development—aka Vibe Coding—has been mainstream for at least a year. It started with auto-completion models, moved to agentic IDEs/IDE plugins like Cursor and Cline, then transitioned to terminal-based agents like Claude Code, OpenCode, and Codex. Through each iteration, developers moved further from typing code toward steering and observing AI writing it. Yet despite this constant evolution, something significant happened in Nov/Dec '25:

Andrej Karpathy: "Given the latest lift in LLM coding capability, like many others I rapidly went from about 80% manual+autocomplete coding and 20% agents in November to 80% agent coding and 20% edits+touchups in December." (26 January 2026)

Ryan Dahl (Creator of Node.js and cofounder of Deno): "The era of humans writing code is over. Disturbing for those of us who identify as SWEs, but no less true. That's not to say SWEs don't have work to do, but writing syntax directly is not it." (19 January 2026)

Armin Ronacher (Creator of Flask): "Where I used to spend most of my time in Cursor, I now mostly use Claude Code, almost entirely hands-off. […] If you would have told me even just six months ago that I'd prefer being an engineering lead to a virtual programmer intern over hitting the keys myself, I would not have believed it." (22 December 2025)

What Has Changed? #

The latest generation of models—GPT 5.2 Codex and Claude 4.5 Opus—achieved something beyond benchmark improvements: sustained coherence over long tasks. When an agent works through complex work, each step builds on the previous one. An early mistake compounds through every subsequent action. Even small improvements in per-step accuracy translate into dramatically longer, more reliable work sessions11In a recent paper, Sinha et al. showed that common short-task benchmarks hide huge long-horizon execution capabilities that emerge when small gains in per-step accuracy compound over many steps..

Meanwhile, the industry converged on a surprisingly simple formula for agent tooling: file system access, a terminal, and a small set of generic tools for search, reading, editing, and managed task lists. Standards like AGENT.md files and Agent Skills emerged to bootstrap context and define reusable capabilities. Instead of elaborate specialized interfaces, agents now navigate codebases the way developers do.

The winning patterns for using these agents effectively boil down to three principles: planning with decision lineage (clear goals, incremental milestones, explicit decisions that accumulate), iterative verification (build-fail-learn loops with fast feedback), and project-as-memory (state persists in artifacts so agents can reinitialize fresh but stay current).

Here's the change that matters most: a well-written spec is now more than half the work. When you describe a feature precisely—with clear requirements, edge cases, and verifiable acceptance criteria—implementation can be triggered almost immediately. But it isn't just about writing more detailed specs. It's about recognizing that the boundary between specifying and building has dissolved. Documentation of every product decision in a machine readable format is now the interface through which you communicate with the development process.

Engineering Managers: Adapt or Watch Your Team Fall Behind #

Here's the uncomfortable truth for EMs: teams that don't adopt coding agents will simply be too slow. When competitors ship in days what used to take weeks, refusing to adopt isn't a conservative choice—it's a decision to lose.

Make adoption non-negotiable, but continuous. Push your developers to use these tools consistently. What doesn't work today often fails because prerequisites aren't met. Missing tests? Unclear architecture? Outdated documentation? These are exactly what you should be coaching your team to fix. The agents expose your technical debt with brutal clarity.

Invest in agent readiness. When agents fail, teams blame the model. Usually the real problem is the codebase itself. Missing pre-commit hooks mean the agent waits ten minutes for CI feedback instead of five seconds. Undocumented environment variables mean the agent guesses, fails, and guesses again. Build processes requiring tribal knowledge from Slack threads mean the agent has no idea how to verify its own work. These environment problems compound—a codebase with poor feedback loops will defeat any agent you throw at it. Audit your repositories for fast local tests, clear documentation, consistent style enforcement, and explicit development setup instructions. Teams that systematically improve their codebase's agent readiness will pull ahead of teams that don't.

Coach the new core skills explicitly. The work of developers is shifting toward two activities: specifying what needs to be built (in enough detail that an agent can execute) and reviewing what the agent produces. This doesn't diminish engineering expertise—only experienced developers can catch the subtle issues that matter in production. But the day-to-day looks different, and your team needs help making the transition.

Product Managers: Get Closer to Engineering or Get Bypassed #

Here's the uncomfortable truth for PMs: when development velocity accelerates this dramatically, product managers who don't adapt will simply be routed around. If engineers can go from idea to working code in hours instead of weeks, they won't wait for specs that arrive too late or in formats that require translation.

The good news? This same shift represents an opportunity to get closer to the product than ever before.

Write specs that dev teams can feed into the dev pipeline directly. Everything important needs to be written down in forms agents can consume: strategy documents linking to requirements, ADRs explaining what was decided and rejected, user stories with testable acceptance criteria. This creates the project-as-memory and planning with decision lineage that lets agents succeed on complex features.

Learn the new engineering reality. Build a POC yourself—not to become an engineer, but to internalize the new workflow. Understand what makes a spec "agent-ready." Know how to feed the engineering pipeline effectively. The PMs who understand agent-driven development will have far more influence than those who remain abstracted from it.

Use AI to keep pace. Development velocity has accelerated; your work needs to accelerate too. Use AI to speed up research, competitor analysis, and spec drafting. Keep the pipeline filled. But keep strategic thinking—what to build and why—human.

What to Do Now #

Coding agents have crossed a threshold—smarter models, standardized infrastructure, and proven best practices now enable sustained, complex work.

Engineering Managers:

Make agent adoption non-negotiable—what fails today often just needs better prerequisites
Audit your codebase for agent readiness—fast tests, clear docs, explicit setup instructions
Coach specification and review as the new core developer skills

Product Managers:

Write specs with verifiable acceptance criteria—they can now trigger implementation directly
Build something yourself using agents to internalize the workflow
Accelerate your own work with AI to keep the pipeline filled