The first time a coding agent opens three pull requests before lunch, a certain kind of engineering manager learns something uncomfortable: the hard part was never getting code written. The hard part was deciding what counted as done, who was allowed to touch what, how context moved through the system, and how bad ideas were caught before they shipped. Agents do not remove that work. They drag it into the light.
The Convergence
The tools have now converged on the same basic promise. Codex can work locally or in isolated cloud sandboxes, run multiple agents in parallel with worktrees, automate GitHub reviews, and accept work through an SDK or Slack. Claude Code can read and edit code, run commands, connect to outside tools through MCP, and drop directly into CI. Devin layers sessions, knowledge, playbooks, review, and autofix on top of the same operating model. None of these systems are autocomplete anymore. They are junior teammates with shell access.
Once you see that, the management problem becomes legible. Human teams absorb context through habit, gossip, and osmosis. Agents do not. They need written memory, scoped instructions, and predictable defaults. Codex has `AGENTS.md`, where teams tell the agent how to navigate the repo and which checks to run. Claude Code has hierarchical `CLAUDE.md` memory files plus project and enterprise settings. Devin has Knowledge and Playbooks, with triggers, repo pinning, and reusable procedures for repeated work. These are not minor configuration details. They are the new onboarding packets, the new runbooks, and the new org chart. Teams that refuse to write things down are not "moving fast." They are choosing to rediscover the same mistake every Tuesday.
Context as the Managerial Primitive
That is why managing agents is mostly context design. The managerial primitive is no longer headcount. It is context window. The question is not "How smart is the model?" The question is "What does it know, when does it know it, and what are we willing to let it do with that knowledge?" Good agent systems answer that with layers: project instructions, user preferences, tool permissions, environment boundaries, and validation rules. Bad agent systems answer it with a demo.
Guardrails
Guardrails are where the fantasy usually dies. A team that hands an agent broad repo access, ambiguous instructions, and production-flavored authority is not being bold. It is outsourcing judgment. The best systems default to constrained power. Claude Code is read-only by default and asks before edits or bash execution. Its settings let teams explicitly allow, ask, or deny tool use, including hiding sensitive files entirely. Its hooks can intercept a tool call before it runs, rewrite the input, deny it, or escalate it. Codex's CLI formalizes the same idea with approval modes that range from suggestion to autonomous editing, and its cloud work happens in isolated sandboxes you review before merging. The existence of these controls is not a UX flourish. It is the job description.
Division of Labor, Not Swarms
This is also why "multi-agent swarm" talk is usually backwards. Most teams do not need a parliament of synthetic geniuses. They need division of labor. A writer. A reviewer. A fixer. Claude Code's subagents are useful precisely because each runs in its own context with its own tools and permissions. Codex exposes multi-agent collaboration, but OpenAI's own recommendation is boringly practical: give well-scoped tasks to multiple agents in parallel. Devin's own internal write-up tells the same story in operational language: scope the work, start the session, review the PR, let the bots flag issues, let the autofix loop clean up the mechanical defects, and keep the human focused on the hard calls. That is not swarm intelligence. That is management.
The Bottleneck Moves
The most important shift is where the bottleneck moves. For years, software teams pretended the scarce resource was typing. It was never typing. It was understanding. Cognition says this directly: as coding agents proliferate, code review—not code generation—becomes the bottleneck. Devin Review exists to organize diffs, surface likely bugs, and let humans ask better questions of a PR. OpenAI says Codex can automatically review GitHub pull requests, and reports that internally almost all engineers now use it, with automatic review catching critical issues before they reach production. Anthropic's GitHub Actions pitch lands in the same place: bring the agent into the workflow, but keep standards, secrets, permissions, timeouts, and turn counts explicit. The future senior engineer does not disappear. The future senior engineer reads fewer rote diffs and spends more time on architecture, product judgment, and the weird cases where the model is wrong in a new and expensive way.
Cost is Latency in Disguise
Then there is cost, which is really latency wearing an accounting costume. Anthropic says Claude Code averages about $6 per developer per day, with most daily usage under $12, and notes that cost rises with codebase size, complexity, and automation volume. OpenAI makes the same point more generally: bigger repos, longer-running tasks, and longer sessions that hold more context consume more usage. The lesson is old-fashioned management. Budget the work. Use cheaper and faster paths for exploration. Reserve long autonomous runs for bounded tasks. Cap turns in automation. Push verbose subtasks—tests, log spelunking, documentation fetches—into separate subagents or sessions so the main thread does not drown in its own exhaust. You do not save money by hoping. You save money by designing the workflow.
Evaluation
Evaluation is where adults part company with the demo crowd. You do not manage agents by asking whether they felt productive. You manage them by deciding what evidence counts. Reliable tests. Regression harnesses. Reproducible environments. Review logs. Explicit postconditions. Codex's own documentation says agents perform best when given configured environments, reliable testing setups, and clear documentation. Devin's guidance is even blunter: do not tell the agent "make sure it works"; specify the validation requirements. And the public benchmark story is already fraying. In February 2026, OpenAI said SWE-bench Verified is increasingly contaminated, no longer reflects meaningful frontier progress, and should give way to SWE-bench Pro. That should kill a lot of lazy thinking. A benchmark screenshot is not a software process. It is marketing with nicer charts.
Learning from Failure
Failures, when they come, should be treated as operational material, not personal betrayal. The agent followed the wrong convention perfectly. It satisfied the linter and missed the business rule. It inferred a pattern that was accidental, not architectural. Fine. Pull the transcript. Inspect the logs. Identify the missing context, overbroad permission, or weak success condition. Turn the lesson into `AGENTS.md`, `CLAUDE.md`, Knowledge, or a Playbook. Devin's Advanced Mode is explicitly built to analyze past sessions, extract patterns, and turn successful runs into reusable playbooks. Claude Code's hook system is built to intercept risky actions before they execute. Mature teams do not respond to agent failures with superstition. They respond by improving the scaffold.
The Old Lesson
This is the part that echoes the old management lesson best: people are messy, and systems built by people are messier. Michael Lopp's _Managing Humans_ became durable because it refused to pretend management was a clean science; it treated the real work as translation, context, trust, routines, and the slow crushing of entropy. The same move works here. Agents do not create a post-management world. They create a world where management becomes more technical, more explicit, and less forgiving. _Managing Humans_ was always "biting and humorous" because the chaos was the point; Lopp himself said the biggest theme was simple: people are messy. Replace "people" with "agents plus the humans who deploy them," and the thesis survives intact.
So the useful version of the future is not that every engineer gets a swarm. It is that every team gets a better operating system for work: explicit context, bounded autonomy, fast review, hard validation, and humans spending judgment where judgment still matters. The manager's task has not disappeared. It has become more operational. More architectural. More like running a factory where the machines can draft their own work orders but still need locks on the dangerous doors.
Which is good.
Because software was never just about writing code. It was about building systems that survive contact with reality. Agents are no different. They just fail faster.