From autocomplete to delegated tasks
The first wave of coding AI focused on completing lines and answering questions. In 2026, mature coding agents operate in a loop: gather context, plan, read and edit files, call tools, validate results, and iterate. OpenAI describes Codex as an agent for writing, reviewing, and shipping code, while GitHub defines its agents as systems that independently execute work across the software lifecycle. [2][3][7]
The practical difference is substantial. Developers can stop steering every local edit, but they must be more precise about goals, boundaries, constraints, and what counts as done.
What a coding agent can actually do
Current agents can search repositories, read history and documentation, modify many files, run commands, tests, and linters, inspect failures, and prepare changes for review. GitHub Copilot cloud agent can work on a branch without immediately opening a pull request, then move into the normal review workflow. [7][10]
Claude Code exposes tool and permission controls, Codex operates across local and cloud surfaces, and Gemini CLI can run interactively, in scripts, and inside a sandbox for side-effecting tools. [2][6][13]
Four major agent workflows in 2026
| Agent | Primary surface | Work model | Control model |
|---|---|---|---|
| OpenAI Codex | ChatGPT, app, CLI, IDE, cloud | Local and parallel cloud work | Skills, environments, review |
| Claude Code | Terminal, SDK, MCP | Interactive and scripted | Permission modes, allowed/disallowed tools |
| GitHub Copilot cloud agent | GitHub, VS Code, Mobile, desktop app | Async branch/PR workflow | Repo policies, logs, review |
| Google Antigravity / Gemini CLI | Antigravity desktop, CLI, SDK | Parallel agents and automation | Sandbox, hooks, MCP, isolation |
The market is not one interface. Codex spans app, CLI, IDE, and cloud. Claude Code is terminal-first and scriptable. GitHub Copilot cloud agent lives inside issues, branches, and pull requests. Google Antigravity 2.0 emphasizes multi-agent orchestration, while Gemini CLI provides an open-source terminal agent. [2][6][7][8][12][13]
In practice, tool choice depends as much on execution environment, permissions, governance, and review flow as on the underlying model.
Tasks are getting longer and more parallel
OpenAI reports that in May 2026, 70.2% of its sampled individual Codex users made at least one request estimated to represent more than one hour of human work, and 25.6% made at least one estimated above eight hours. These are model-estimated thresholds from a random 0.1% sample, so they should be treated as directional rather than exact time measurements. [1]
The same report describes growth in parallel agent work. GitHub Copilot app and Google Antigravity are also designed around parallel sessions and independent workstreams. [1][8][12]
Humans increasingly decide what, agents decide how
Anthropic analyzed roughly 400,000 Claude Code sessions from October 2025 through April 2026. In a typical session, users made about 70% of planning decisions, while Claude made about 80% of execution decisions. A user prompt triggered around 10 agent actions on average. [4]
That is a useful description of the emerging division of labor: the developer selects objectives, architecture, and acceptance criteria, while the agent handles many local implementation decisions. Those execution decisions still require review.
Expertise still improves outcomes
In the same Anthropic study, sessions rated as more expert were more likely to succeed. Under its strict verified-success metric, novice-rated sessions reached about 15%, while intermediate-and-above sessions reached roughly 28 to 33%. The measure is transcript-based and uses signals such as tests, commits, and user confirmation, so it is not a direct measure of production quality. [4]
The practical lesson is that domain knowledge remains leverage. Someone who understands the business rules, edge cases, architecture, and verification strategy can steer an agent more effectively than someone who only knows how to phrase a prompt.
Productivity evidence is mixed and measurement matters
| Source | Sample | Key finding |
|---|---|---|
| Anthropic 2026 | ~400k Claude Code sessions | User ~70% of planning decisions, Claude ~80% of execution decisions |
| METR 2025 RCT | 16 developers, 246 tasks | 19% longer completion time with early-2025 AI tools |
| METR 2026 survey | 349 technical workers | Median self-reported 1.4 to 2x work-value change, with major caveats |
| OpenAI 2026 Codex | Random 0.1% sample of individual users | 70.2% had at least one task estimated above one hour of human work |
METR’s 2025 randomized study followed 16 experienced open-source developers across 246 real tasks in repositories they knew well. With early-2025 AI tools available, tasks took 19% longer on average, even though participants believed AI was making them faster. [14]
In 2026, METR said a larger follow-up experiment had become difficult to interpret because developers increasingly declined to work without AI, creating selection bias. A separate survey of 349 technical workers found a median self-reported 1.4 to 2x change in value of work, but METR explicitly gives reasons to be skeptical of the magnitude. [15][16]
Code review becomes a primary control point
When an agent can modify many files and prepare a complete pull request, review stops being a final formality and becomes a core control mechanism. GitHub builds agent workflows around diffs, pull requests, session logs, repository policies, and human review. [7][8][11]
Review therefore shifts from merely checking syntax toward validating assumptions, scope, API contracts, architecture, security, edge cases, and whether the change actually solves the intended problem.
Tests and CI become the agent’s contract
Agents can produce a large amount of plausible code quickly, but only explicit criteria can determine whether the change is correct. Unit, integration, and end-to-end tests, type checking, linting, and reproducible builds become more valuable in agentic workflows. Claude Code and GitHub agent workflows explicitly support running commands and tests during execution. [6][7][10]
A good agent task should define both the desired outcome and how to verify it. The more deterministic the verification, the less manual guessing is required at the end.
Security: more autonomy means more risk surface
A coding agent may run shell commands, read files, use network access, and modify source code. Permission modes, sandboxing, tool restrictions, secret protection, and audit logs therefore become foundational controls. Claude Code exposes permission modes and allow/deny tool lists, Gemini CLI supports container isolation, and GitHub exposes session logs within repository governance. [6][11][13]
Teams should apply least privilege. An agent asked to change UI code should not automatically receive production secrets, deployment rights, or destructive infrastructure permissions.
Repository context becomes infrastructure
Agent quality depends heavily on whether project conventions are explicit. Repository instructions, coding standards, architecture rules, project context files, Skills, and MCP integrations increasingly act as machine-readable operating procedures. Claude Code and Gemini CLI support project context and MCP, GitHub provides repository instructions and shared agent context, and Codex uses Skills for repeatable team processes. [2][6][9][13]
Documentation is therefore no longer only for people. An outdated README, ambiguous module boundaries, or missing test commands directly reduce agent reliability.
Multi-agent work changes the developer’s day
Codex, GitHub Copilot app, and Google Antigravity support parallel tasks. Instead of waiting for one sequential session, a developer can delegate tests, a refactor, documentation, and a bug fix to separate workstreams and review them later. [1][8][12]
The bottleneck then moves from typing code to prioritization, context, review, and integration. Launching too many agents without strong acceptance criteria can create more review work than useful output.
Which tasks are easiest to delegate in 2026
The strongest candidates are bounded and verifiable tasks: adding tests, local refactors, API migrations, reproducible bug fixes, dependency updates, documentation, repository analysis, and first-pass pull requests. OpenAI, Anthropic, GitHub, and Google all position their agents for this kind of multi-step work. [2][6][7][12][13]
Harder tasks remain those with hidden requirements, major product trade-offs, or high costs of being wrong. In those cases an agent can accelerate analysis, but decision ownership should stay with a human.
How to adopt coding agents without creating chaos
Start with a constrained scope: approved task types, explicit repository instructions, required tests, maximum permissions, and clear human approval points. DORA’s research frames AI as an amplifier of existing strengths and weaknesses, so a weak engineering system does not automatically become strong when an agent is added. [17]
Then measure the whole workflow, not prompt volume. Useful metrics include time from task start to accepted pull request, review time, number of iterations, CI failures, post-release regressions, agent cost, and the share of agent changes that require substantial rewriting.
- Define approved task categories.
- Maintain current repository instructions and verification commands.
- Require tests, linting, and a clean build.
- Apply least-privilege permissions.
- Require human review for high-impact changes.
- Keep agent logs and an audit trail.
- Measure time and cost per successfully verified task.
