Most engineering teams met AI through a copilot: suggestions in the editor, a chat panel that explains a stack trace, a quick refactor on a selected block. The developer stays in the driver’s seat and the model helps with the next few lines.
Coding agents work differently. You hand one an issue, and it reads the code, makes a plan, edits files, runs the tests, fixes what broke and opens a pull request. The developer is no longer driving. They are assigning, approving and reviewing.
That sounds like a difference of degree. In practice it changes where the bottlenecks are, what skills matter and how a team plans its week. This post walks through what changes, what stays the same and how to decide where each tool fits.
The short answer
| Copilot | Coding agent | |
|---|---|---|
| Unit of work | A line, a function, a question | An issue or task |
| Who drives | The developer, keystroke by keystroke | The agent, within limits you set |
| Where it runs | Your editor, on your branch | An isolated branch, worktree or sandbox |
| Feedback loop | Seconds: accept or reject a suggestion | Minutes to hours: approve a plan, review a pull request |
| Parallelism | One developer, one stream of work | Many runs at once |
| Output | Code in your working copy | A branch or pull request with tests |
| What you review | Each suggestion as it appears | The plan, then the finished diff |
Neither is better in general. They solve different problems, and most teams end up using both.
What a copilot does well
Copilots shine when the developer already knows what they want and the friction is in the typing: boilerplate, test scaffolding, unfamiliar API signatures, translating a regex into words. Because the human is reading every suggestion as it lands, mistakes are caught immediately and the cost of a bad suggestion is a keystroke.
They are also good thinking partners. Asking “why might this query be slow?” in context is faster than searching documentation. None of that requires the model to own anything.
The limit is that a copilot scales with attention. One developer can only steer one stream of work at a time, so the gains are real but bounded by how many hours people spend in the editor.
What changes with agents
When an agent owns the task, five things shift.
The unit of work becomes the issue
With a copilot, you plan the work and the model helps execute fragments of it. With an agent, the issue is the instruction. A vague ticket (“checkout is broken sometimes”) produces vague work. A clear one, with a reproduction, the expected behaviour and links to relevant code, produces something you can merge.
Teams that adopt agents usually find themselves writing better issues, and that discipline tends to help human contributors too.
The bottleneck moves to review
An agent can produce a pull request faster than a person can read one. If a team runs five agents in parallel, the constraint is no longer how fast code gets written. It is how fast people can evaluate it.
This is the most important change to plan for. It suggests a few practices:
- Approve plans before implementation, so you are not reviewing a diff built on a wrong approach.
- Keep agent changes small. One issue, one focused pull request.
- Let automated checks do the boring part: tests, linters, type checks and an agent reviewer that flags obvious problems before a human looks.
- Make review fast to act on: clear summaries, the plan next to the diff, one place to see everything waiting.
Specs matter more than prompts
With a copilot, prompting skill matters because you interact constantly. With an agent, what matters is the quality of the inputs it starts with: the issue, the acceptance criteria, the conventions it should follow, the commands that prove the change works.
Those inputs are reusable. A team can encode “how we write migrations” or “how we test API handlers” once, as a skill or a workflow step, and every run benefits.
Work happens in parallel
Agents do not need a dedicated editor window. Ten runs can be in flight while their owner is in a meeting. That changes planning: the question stops being “who has capacity for this?” and becomes “is this issue ready for an agent, and who will review it?”
Parallel work also needs isolation. Each run must have its own branch and workspace, and its own limits on time and spend, or runs interfere with each other.
Failures look different
A copilot fails visibly: a suggestion is wrong and you ignore it. An agent can fail quietly: it can misread an issue, solve the wrong problem convincingly or loop on a flaky test. That is why agent workflows need gates (conditions that must hold before work moves on) and limits (a run that exceeds its budget or time pauses and asks for help).
New jobs on the team
Agents do not remove roles, but they redistribute work. In teams that run agents seriously, three responsibilities show up, usually held by existing engineers rather than new hires:
- Issue authors make sure work is ready: clear scope, reproduction steps, acceptance criteria. Often this is the person who would have done the work.
- Reviewers own the quality bar. They approve plans, read diffs and decide what merges. This is where senior judgment goes furthest.
- Workflow owners maintain the process: which steps run, which checks gate them, which skills agents load, what the budgets are. Think of the person who owns CI configuration today.
What does not change
It is worth saying plainly what agents leave alone:
- Code review standards. A change written by an agent should meet the same bar as one written by a person. If anything, read it more carefully at first.
- Ownership. Someone on the team owns every merged change and its consequences. “The agent wrote it” is not an answer in an incident review.
- CI and tests. They become more important, not less, because they are how you verify work you did not watch being done.
- Security boundaries. Agents should get the least access that lets them do the job, and never production credentials by default.
Using both
The practical answer is not a choice. Copilots stay in the editor for the work developers want to do by hand: exploratory changes, tricky design, anything where thinking and typing are the same activity. Agents take well-specified tasks off the queue: bug fixes with a reproduction, upgrades, test coverage, small features behind flags.
A useful heuristic: if you could write the acceptance criteria in a few bullet points and a test would prove them, it is probably agent work. If you would need to try three approaches to know which one is right, keep it in the editor.
Questions to ask before adopting agents
Before pointing agents at your backlog, check that you can answer these:
- Which class of work will agents pick up first, and how will they find it?
- Who approves plans, and who reviews the resulting pull requests?
- Where do runs execute, and what can they access?
- What does a run cost at most, and what happens when it hits the limit?
- How will you know if it is working: merged pull requests, reverts, time to merge?
If any answer is “we’ll figure it out”, start smaller. Our guide to what an AI software factory is covers how to scope a first pilot, and the core concepts page in the Duun docs explains how factories, workflows and agents fit together.
Frequently asked questions
Can a copilot become an agent?
Many tools now offer both modes: inline help and a mode that takes a task and works on its own. The distinction that matters is not the product but the workflow around it, meaning isolation, gates, limits and review.
Are coding agents only useful for large teams?
No. Small teams often benefit sooner because they have more work than people. The same rules apply: start with well-specified work and review everything.
Will agents increase the number of pull requests we have to review?
Usually, yes. Plan for it. Approving plans first, keeping changes small and automating the mechanical checks keep review load manageable.
Do agents need different tests from humans?
They need the same tests, but more of them matter. An agent relies on your test suite to know whether it succeeded, so gaps in coverage become gaps in what an agent can safely do.
See it on your own issues
Duun runs coding agents as a team, with plan approvals, reviews and budgets built in. It is in early access: request access to try it on your backlog.