Self-review is the wrong agent milestone

GitHub's latest Copilot coding agent updates are easy to read as "the agent is getting smarter."

I think that misses the better story. The useful part is not that the agent can review itself. The useful part is that GitHub is moving verification earlier, before the human opens the pull request and inherits the cleanup.

In February, GitHub said Copilot coding agent can now pick models per task, run Copilot code review on its own changes before opening a PR, run security checks inside the agent workflow, define custom agents under .github/agents/, and hand work between cloud sessions and the local CLI. The Copilot CLI changelog also describes plan mode, autopilot mode, built-in specialized agents, /diff, /review, undo/rewind, repository memory, and hooks.

That is a lot of surface area. The product risk is obvious: teams may start treating an agent-polished PR as a reviewed PR.

Please do not.

Self-review is a pre-filter

GitHub's coding agent post says the agent now runs Copilot code review on its own changes before it requests human review. It can catch awkward implementation choices and iterate before the PR lands in your queue.

That is useful. I want the obvious string-concatenation weirdness gone before I spend attention on the diff.

But self-review is still a pre-filter. It is closer to lint than approval. The same system that produced the patch is now checking the patch with adjacent assumptions. That can reduce noise, but it cannot own the product decision. It cannot know whether the issue was scoped correctly, whether the migration should exist at all, or whether the user experience got worse in a way the tests do not express.

The healthy framing is simple: agent review should make human review smaller, not optional.

Security checks are the bigger deal

The security scanning detail matters more than the self-review headline.

GitHub says Copilot coding agent now runs code scanning, secret scanning, and dependency vulnerability checks inside its workflow before the PR opens. That changes the shape of the handoff. Instead of a human reviewer discovering a leaked token-shaped string or a vulnerable dependency after the agent is "done," the session log can show that the check ran while the agent was still working.

That is where agent UX gets serious. The user should not have to infer safety from confident prose. They should see the checks, their results, and the exact point where the agent responded to a failure.

This matches the rule I keep coming back to in my own workflows: verify outcome state, not the agent's description of it. A good agent interface should make that almost boring.

Custom agents are really process files

The .github/agents/ feature is the most interesting product decision in the update.

A normal prompt is temporary. A custom agent file is process made durable. GitHub's example is a performance optimizer that benchmarks first, changes one thing, benchmarks again, and returns with a measured result. That is much better than telling a generic coding agent to "improve performance" and hoping it remembers to measure.

This is where teams should spend their time. Not on cute agent personas. On boring process boundaries.

A migration agent should know where schemas live, how to write idempotent migrations, and which tests prove legacy data still loads. A dependency agent should know which updates are allowed, which major versions require review, and what audit output counts as a blocker. A content agent should know that a live URL matters more than a committed draft.

The agent is less magical when you write it that way. It is also more useful.

The PR is still the accountability boundary

GitHub's practical Copilot CLI guide makes the same point in a softer way: start with intent, inspect what runs, iterate at the point of failure, move into the editor when precision matters, and land the work as a pull request.

That last part is not ceremony. It is the accountability boundary.

Agents can produce branches, logs, diffs, reviews, scans, and summaries. The PR is where those artifacts become inspectable by people and machines that did not share the agent's context. If the PR cannot explain what changed, what ran, what failed, and what remains uncertain, the agent did not finish the job. It just stopped typing.

So yes, self-review is progress. Model pickers are progress. Cloud-to-local handoff is progress.

The milestone I care about is duller: an agent PR that arrives with enough evidence that a human can spend judgment on the hard part instead of cleaning up the obvious mess.