Build what's next on GitHub, the place for anyone from anywhere to build anything.
Join us October 28-29 in San Francisco or online for GitHub Universe, our flagship developer event uniting people, agents, and the world's code.
Have you tried the new coding agent in GitHub Copilot? Here’s how developers are using it to work more efficiently.
You’ve used GitHub Copilot to help you write code in your IDE. Now, imagine assigning Copilot an issue, just like you would a teammate—and getting a fully tested pull request in return.
That’s the power of the new coding agent in GitHub Copilot. Built directly into GitHub, this agent starts working as soon as you assign it a GitHub Issue or prompt it in VS Code. Keeping you firmly in the pilot’s seat, the coding agent builds pull requests based on the issues you assign it.
This isn’t just autocomplete. It’s a new class of software engineering agents that work asynchronously to help you move faster, clean up tech debt, and focus on the work that really matters. Let’s explore how this coding agent works and how it can help you find new ways of working faster. ✨
Oh, and if you’re a visual learner we have you covered. 👇
This new coding agent, which is our first asynchronous software engineering agent, is built on GitHub Actions and works like a teammate. You assign it an issue, let it do the work, and then review its outputs before changing or accepting them. It also incorporates context from related issues or PR discussions and can follow custom repository instructions that your team has already set.
You assign Copilot an issue and it plans the work, opens a pull request, writes the code, runs the tests, and then asks for your review. If you leave feedback, it’ll revise the PR and keep going until you approve.
The process isn’t instant—it takes a little time to compute and run. But it’s already helping developers work faster and more efficiently.
Agent mode is a synchronous collaborator that pairs with you as you work: It works inside your IDE of choice, whether VS Code or JetBrains, Eclipse, and Xcode, as a real-time collaborator that iterates on code, runs tests, and fixes its own mistakes in real time.
Coding agent is an asynchronous collaborator and works on your behalf like a teammate: It is an SWE agent that runs inside GitHub Actions, picks up issues you assign, explores the repo for context, writes code, passes tests, and opens a pull request for your review.
BTW: Both use Copilot premium requests, and coding agent uses GitHub Actions minutes, so plan and budget accordingly with your teams.
According to Brittany Ellich, Senior Software Engineer at GitHub, traditional advice for devs has been to do one thing at a time, and do it well. But with the new coding agent, GitHub can now help you do more things well, like:
By assigning these low- to medium-complexity tasks to the coding agent, you may finally have the bandwidth to focus on higher-level problem solving and design, tackle that tech debt that’s been piling up, learn new skills, and more.
Even though Copilot is doing the work, you’re in control the entire time: You decide what to assign, what to approve, and what should be changed.
Copilot can also build issues with the preview of Copilot’s Create Issue flow. This new feature enables you to build multiple issues quickly by drawing on the full context of your prompt and project.
This is where you’ll be most involved—and this step is crucial for success. Think of writing the issue like briefing a team member: The more context you give, the better the results (like any other prompt).
Make sure to include:
Once you’ve written the issue, it’s time to assign it to Copilot—just like you would a teammate. You can do this via github.com, the GitHub Mobile app, or through the GitHub CLI.
Copilot works best with well-scoped tasks, but it can handle larger ones. It just might take a little bit longer. You don’t have to assign only one issue; you can batch-assign multiple issues, which is great for tasks like increasing test coverage or updating documentation.
Here are a few tips and tricks that we’ve found helpful:
Once you assign Copilot an issue, it will add an 👀 emoji reaction. Then it will kick off an agent session using GitHub Actions, which powers the integrated, secure, and fully customizable environment the coding agent is built on.
This environment is where Copilot can explore and analyze your codebase, run tests, and make changes. The coding agent will simultaneously open both a branch and a pull request, which will evolve as Copilot works.
Copilot will read your issue and break it down into a checklist of tasks, then update the pull request with this checklist. As it completes each task, Copilot checks it off and pushes commits to the branch. You can watch the session live, view the session logs later, or refresh the PR to see how Copilot is reasoning through the task. These are updated regularly for increased visibility, so you can easily spot problems if they arise.
This is where the magic happens. Once you see the “Copilot started work” event in the pull request timeline, you’ll know the wheels are turning. Here’s what happens next:
You can see the work happening in real time, and if you notice that something looks off, you can step in at any point to make sure things are going in the right direction before Copilot passes it back to you.
This is another stage where you’ll need to be involved. Once Copilot finishes the work, it will tag you for review. You can either:
Copilot will automatically request reviewers based on the rules you’ve set in your repo. And if needed, you can go through multiple review cycles until you get your desired outcome—just like with a human teammate.
Once the pull request is approved:
🚨One important thing to note: The person who created the issue can’t be the final approver. You’ll need a peer, manager, or designated reviewer to give the green light. This promotes collaboration and ensures unreviewed or unsafe code doesn’t get merged.
And you’re done! ✅
Like any other tool (or teammate), Copilot’s coding agent might need a little prodding to deliver exactly the output you want. Remember, the biggest factor to success starts with how you write the issue (Copilot can also help you write those faster).
Here are a few tips on how to get the most out of Copilot:
AI and LLMs are improving at a rapid pace. “The models we’re using today are the worst ones we’ll ever use—because they’re only getting better,” says Ellich. And coding agents are already proving useful in real workflows.
Try using the coding agent on a sample repo. See what it can do. And start building your own agentic workflows. Happy coding!
Visit the Docs to get started with the coding agent in GitHub Copilot.
