GitHub officially made Copilot’s agent mode generally available this week, and the developer community is buzzing. After months in preview, the feature that lets Copilot autonomously plan, write, and iterate on multi-step coding tasks is now available to all Copilot subscribers. Having spent considerable time with the preview, I have some thoughts on where this fits in a professional workflow — and where it doesn’t.
From Autocomplete to Autonomous Agent#
The evolution of Copilot has been fascinating to watch. What started as a fancy autocomplete tool in 2021 has steadily grown into something far more ambitious. Agent mode represents a fundamental shift: instead of suggesting the next line of code, Copilot can now take a high-level instruction — “add authentication to this API endpoint” or “refactor this module to use the repository pattern” — and autonomously determine which files to edit, what changes to make, run terminal commands, and iterate based on errors.
Under the hood, agent mode leverages the latest foundation models from OpenAI and Anthropic, combined with GitHub’s deep understanding of repository context. It reads your project structure, understands your coding conventions, and attempts to produce changes that feel like they belong in your codebase. The key word there is “attempts.”
What Actually Works Well#
I’ve been using agent mode in preview across several projects, and there are genuine bright spots. For boilerplate-heavy tasks — setting up new API routes, creating test scaffolding, adding standard CRUD operations — it’s remarkably effective. What used to take me 30 minutes of tedious copy-paste-modify work now takes about 5 minutes of reviewing and tweaking agent output.
The terminal integration is particularly impressive. When agent mode writes code that doesn’t compile or fails tests, it reads the error output and iterates. I’ve watched it fix its own type errors, install missing dependencies, and correct import paths across multiple files. This self-correcting loop is what separates agent mode from the earlier inline suggestions.
Where it also shines is in codebases with strong conventions. If you have consistent patterns — say, every service follows the same interface, every API endpoint has the same middleware chain — agent mode picks up on these patterns and replicates them faithfully. It’s essentially learned your team’s style guide from context.
Where It Falls Short#
Let’s be honest about the limitations. Agent mode struggles with architectural decisions. Ask it to “design a notification system” and you’ll get something that works but might not be the right abstraction for your specific constraints. It doesn’t understand your team’s roadmap, your scale requirements, or the political dynamics of your organization that influence technical choices.
I’ve also noticed it can be confidently wrong in subtle ways. It’ll produce code that passes tests but introduces a race condition, or it’ll use an API pattern that’s technically correct but performs poorly at scale. These are exactly the kinds of bugs that are hardest to catch in review because the code looks right.
The token window, while large, still limits how much of a large codebase the agent can reason about simultaneously. In monorepos with hundreds of packages, it sometimes makes changes that conflict with distant parts of the codebase it hasn’t loaded into context.
The Changing Role of Code Review#
What concerns me most isn’t the quality of the generated code — that will improve. It’s the impact on code review culture. When a developer writes code by hand, the review process is a conversation between two humans who both understand the intent and constraints. When an agent writes the code, the reviewer is essentially auditing machine output, which requires a different and arguably more demanding skillset.
I’ve already seen junior developers on my team approve agent-generated PRs with a cursory glance because “Copilot wrote it, so it’s probably fine.” This is dangerous. We need to be more rigorous in reviewing AI-generated code, not less, precisely because the failure modes are different from human-written code.
Teams adopting agent mode should invest in better automated testing, stronger linting rules, and clear guidelines about which types of tasks are appropriate for agent mode versus human authorship. Complex business logic, security-critical paths, and novel architectural work should still be human-driven.
My Take#
After thirty years of writing software, I’ve seen plenty of tools that promised to change everything. Most delivered incremental improvements. Copilot agent mode is genuinely useful — it’s the first AI coding tool where I regularly think “that saved me real time” rather than “that was a neat demo.”
But it’s a power tool, not a replacement for engineering judgment. The developers who will thrive with agent mode are the ones who can clearly articulate what they want, critically evaluate the output, and know when to take the wheel back. The ones who treat it as a magic box that produces correct code will ship bugs they don’t understand.
GitHub has built something impressive here. The GA release is polished, the VS Code integration is seamless, and the pricing at the existing Copilot tier is reasonable. Just remember: the most important skill in this new world isn’t prompting — it’s knowing when the machine’s answer isn’t good enough.
This is part of my ongoing AI in Development series, tracking how AI tools are reshaping software engineering practices.