Intro

GitHub quietly turned the humble Issue into a launch button. With Assign to Copilot, you can hand a ticket to an autonomous coding agent that spins up a clean environment, reads your repo context, drafts a branch, opens a PR, runs your checks, and then waits for your review like a polite junior dev who actually likes chores. The flow is still GitHub-native commits, PR, discussion. Just with a new teammate taking the first swing. (GitHub Docs)

tl;dr: If you can describe a task clearly in an Issue, Copilot can usually turn it into a draft PR you can steer to done. Think “small features, bug fixes, tests, docs.” Not “quarterly architecture rewrite.” (The GitHub Blog)

What It Is (and how it behaves)

The coding agent is different from IDE chat or “agent mode.” Instead of editing files on your machine, it works in the background on GitHub. You assign an Issue (or start a task from the new Agents panel), and Copilot creates a copilot/* branch from your default branch, pushes commits as it works, and opens a draft PR for you to review. When you leave PR comments, “rename this prop,” “add tests for the edge case,” it spins a fresh session to apply changes and pushes another commit. The whole trail is visible in session logs linked from the PR, so you can see what it tried and why. (GitHub Docs)

The agent runs in a GitHub Actions powered sandbox. It can build, test, and lint. Whatever your repo already enforces in CI. You stay in the driver’s seat the whole time: Copilot can’t approve or merge its own PRs, and it only pushes to branches that begin with copilot/. Your branch protections, required checks, and CODEOWNERS still rule. (GitHub Docs)

Where it actually helps

In practice, Copilot is great at the work we chronically under-prioritize. Tightening test coverage, filing down lint cliffs, stitching in small UX improvements, writing first drafts of docs, or implementing tidy incremental features that follow existing patterns. If your repo has clear instructions (how to build, how to test, where to put things), it plays ball immediately. And now that GitHub’s Agents panel lets you kick off or monitor tasks from any page on GitHub (or from Mobile and VS Code), it’s easier to sprinkle these hand-offs into your day without losing focus. (The GitHub Blog)

One tiny but important behavior note: when you assign the Issue, Copilot sees the title, description, and any comments that exist at that moment. If requirements change later, don’t keep talking to the Issue, move the conversation to the PR so the agent will act on it. That small habit shift prevents “why didn’t it listen?” moments. (GitHub Docs)

Guardrails you should know about

Security and control are very intentionally conservative here. The agent works inside a restricted environment with a firewall, it has read-only access to your repo until it creates that copilot/* branch, and it only responds to people who have write access to the repository. You’ll also see governance footprints you’d expect in an enterprise setting. PRs from Copilot arrive as drafts, workflows won’t run until a human with write access approves them, and the person who asked Copilot to create the PR can’t be the one who approves it. It’s deliberately built to play nice with rulesets and audits, not bypass them. (GitHub Docs)

Costs, plans, and the “premium request” model

Two knobs matter for budgeting: plan and premium requests. The feature is available on Copilot Pro, Pro+, Business, and Enterprise. Paid plans include a monthly allowance of premium requests and the coding agent consumes one premium request per session. Each time you start a run (or trigger a new revision cycle from PR feedback), that’s one session. If you blow past the included allowance and you’ve enabled paid usage, overage is \$0.04 per premium request. You can cap spend with budgets so it never surprises finance. (GitHub Docs)

If you’ve been away from Copilot for a minute, note the 2025 shift: premium-request billing is now live (counters reset monthly at 00:00 UTC), and different models can apply multipliers in chat, but the coding agent itself is a flat “1 request per session.” (GitHub Docs)

Limits and rough edges (so you don’t find them the hard way)

It’s scoped to a single repo and opens one PR per task. It starts from your default branch, not an arbitrary feature branch you’re already working on. So treat it like an auxiliary teammate, not a merge-conflict machine. It doesn’t use self-hosted runners, and it won’t operate across multiple repos in one run (though you can extend context via MCP if you really need to). None of these are deal-breakers, but they do push you toward small, crisp tickets and a CI that tells the truth. (GitHub Docs)

The Glitched Goblet take

The magic here isn’t that Copilot writes code. (we’ve had that all year.) It’s that GitHub now owns the “turn Issue -> PR” loop with guardrails your org already understands. Treat it like a well-behaved junior. Feed it tight scope, let CI be the hard boundary, and keep feedback in the PR. You’ll ship more of the “ought to do” work without torching your attention span and you’ll still have time to chase the spicy tickets that need a human brain.