From Issue to Pull Request: Copilot’s Agentic Workflows in Practice
Shipping a feature shouldn’t require burning hours on boilerplate refactors or chasing down hard-coded strings. That’s the theory behind GitHub Copilot’s agentic workflows: you capture an idea, assign it, and the tooling handles the grunt work while you stay in control of review and merging.
We tested that loop by localizing an application across a Next.js web app and a SwiftUI iOS app in separate GitHub repos. The environment included Codespaces, Xcode 16, an issue asking to “Add English, French, and Spanish localization,” and three Copilot tools: the coding agent (issue-to-PR), a custom planning chat mode in VS Code (preview), and the new remote GitHub MCP server.
Why Go Agentic?
Developers still lose hours to vague requests, cross-cutting refactors, and repetitive test scaffolding. Agentic workflows fold those into a single loop—issue to PR—while you review, tweak, and decide when to merge.
| Capability | What it does | Why it matters | How to enable and use it |
|---|---|---|---|
| Coding agent | Turns any GitHub Issue you assign to Copilot into a PR, and works on that task asynchronously. | Allows you to offload the boilerplate work while you focus on reviews and edge case logic. | Learn how to enable Copilot coding agent. |
| Create issues with Copilot | Converts a natural-language prompt into a well-structured Issue with title, body, acceptance criteria, and file hints. | Saves PM/eng refining and sets team members, or Copilot coding agent, up with the context they need to work effectively. | Navigate to github.com/copilot and write a prompt to create an issue. Learn more about using Copilot to create issues. |
| Custom chat modes (in preview in VS Code) | Lets you script repeatable AI workflows (e.g., Planning, Refactor, Test-Writer) that appear alongside the default Ask / Edit / Agent chat modes. | Allows you to package instructions and relevant tools for easier use, helping your team follow similar conventions. | Add a .chatmode.md file to your repo; available in preview in VS Code release 1.101. Learn more about custom chat modes in VS Code. |
| Remote GitHub MCP Server | Allows AI tools to access live GitHub context and tools, like issues, pull requests and code files. With the remote GitHub MCP server, you don’t need to install it locally, and can even authenticate with OAuth 2.0. | Provides a smooth experience to accessing the GitHub MCP server, reducing the management overhead of a local server. | Update your MCP configuration with the example shown in the remote GitHub MCP Server documentation. |
| Copilot agent mode | Copilot agent mode is a real‑time collaborator that sits in your editor, works with you, and edits files based on your needs. Unlike the coding agent, Copilot agent mode works synchronously with you. | Think of agent mode as the senior dev pair programming with you. It has access to several tools (like reading/writing code, running commands in the terminal, executing tools on MCP servers), and works alongside you. | Copilot agent mode is available in several IDEs including VS Code, Visual Studio, JetBrains (public preview), Eclipse (public preview) and Xcode (public preview). |
What You Need
- A GitHub repo you can push to.
- A Copilot subscription with the coding agent enabled. It’s available for all paid tiers, including Copilot Business and Copilot Pro (public preview).
- VS Code 1.101+ with the latest Copilot extension.
- Either the GitHub Remote MCP server (update your MCP configuration) or a local GitHub MCP server.
Walkthrough: Localizing a Next.js App
1. Capture the Request as a GitHub Issue
In the immersive view of Copilot Chat, describe the task in the “Ask Copilot” box. For example:
Create a GitHub Issue that brings i11n capability to the application. We must support English, French and Spanish.
The user must be able to change their language in their profile page. When they change the language, it must apply immediately across the site.
Please include an overview/problem statement in the issue, a set of acceptance criteria, and pointers on which files need updating/creating.The result is a drafted issue with a title, acceptance criteria, and a loose action plan. Assign it to Copilot, and the process runs in the background.
2. Let the Coding Agent Build the PR
Once assigned, the coding agent creates a branch, optionally configures a development environment if you have copilot-setup-steps.yml, reviews the codebase, forms a plan, and—if configured—respects any custom instructions (e.g., requiring npm run lint and npm run test to pass). The result is a draft PR ready for review.
3. Review the PR Normally
Code from Copilot still needs a human reviewer. The workflow is familiar:
- Inspect the PR body, which Copilot keeps updated.
- Review changes in the “Files changed” tab.
- Optionally, run manual tests in a Codespace or trigger GitHub Actions CI checks.
- Expect green checks, but be ready for failures or missed spots.
In our test, some pages remained hard-coded in English. Rather than fix manually, we left feedback in a PR comment: “That’s a great start. However, there are a lot of pages which are hardcoded in English still... Can you implement the localization on those pages, please?” Copilot responded by launching another session to address the feedback.
Extending Chat Modes for Consistency
VS Code 1.101 introduces custom chat modes in preview, letting you bundle instructions and tools. To set one up:
- Open the command palette and type Configure Chat Modes.
- Select Create new custom chat mode file. Save it in the workspace to share with your team, or in your local user data folder.
- Name the mode—this is what appears in the chat dropdown.
- Edit the generated
.chatmode.mdfile to configure instructions and allowed tools.
---
description: Generate an implementation plan for new features or refactoring existing code.
tools: ['codebase', 'fetch', 'findTestFiles', 'githubRepo', 'search', 'usages', 'github', 'create_issue']
---
# Planning mode instructions
You are in planning mode. Your task is to generate an implementation plan for a new feature or for refactoring existing code.
Don't make any code edits, just generate a plan.
The plan consists of a Markdown document that describes the implementation plan, including the following sections:
* Overview: A brief description of the feature or refactoring task.
* Requirements: A list of requirements for the feature or refactoring task.
* Implementation Steps: A detailed list of steps to implement the feature or refactoring task.
* Testing: A list of tests that need to be implemented to verify the feature or refactoring task.
Once the plan is complete, ask the user if they would like to create a GitHub issue for this implementation plan. If they respond affirmatively, proceed to create the issue using the `create_issue` tool.The example above builds on the VS Code team’s “Plan” mode, adding the create_issue tool and instructing Copilot to use it once revisions are complete. When teammates pull the file, VS Code surfaces the mode for consistent use across the team.
The Remote MCP Advantage
Running MCP servers locally via npm packages or Docker adds management overhead. Remote MCP servers, like the GitHub Remote MCP Server, cut that burden and can also authenticate via OAuth 2.0 instead of Personal Access Tokens. To enable it in VS Code, update your MCP configuration.
| 💡 Note: Did you know that the GitHub MCP Server is open source? Take a look through the codebase or raise an issue. Who knows? Maybe you’ll even end up becoming a contributor! |
Extending to Mobile: Copilot in Xcode
The same pattern applies to mobile development. In an Xcode session, Copilot’s agent mode turned a similar localization prompt into working code, viewable in the simulator’s main navigation bar.
We need to implement internationalization in the app. Please make the following changes:
1. The user can select from suported languages (English, Spanish, French) from a dropdown in their profile.
2. The main tab view should support internationalization. No other parts of the app should be changed for now.
3. When the user changes the language, it should update the rendered text instantly.Dos and Don’ts
| ✅ Do | ❌ Don’t |
|---|---|
| Keep issues tightly scoped | Ask the agent to “re-architect the app” |
| Provide acceptance criteria | Assume the agent knows your intent |
| Carefully review the changes made | Execute code or merge a PR without a review |
| Iterate with Copilot. How often do you get something right on the first shot? | Expect perfection first time |
Getting Started
Agentic workflows aren’t magic—they’re tools. By offloading the boilerplate, you can focus on the more interesting, challenging parts of development. To get started:
- Enable the Copilot coding agent and assign background work.
- Configure custom chat modes in VS Code 1.101 or later.
- Set up the Remote GitHub MCP server to reduce local tooling.
- Explore Copilot agent mode across VS Code, Visual Studio, JetBrains, Eclipse, and Xcode (all in public preview).
