Close Menu

    From idea to PR: A guide to GitHub Copilot’s agentic workflows

    I got into software to ship ideas, not to chase down hard-coded strings after a late-breaking feature request. Unfortunately, many of our day-to-day tasks as developers involve branches working on boilerplate code, refactoring, and the “pre-work” to get to the fun stuff: shipping new features.

    So I turned to Copilot’s agentic workflows to help speed along some of that grunt work. In my latest Rubber Duck Thursdays live stream, I put that theory to the test in a project where I wanted to localize an application that used:

    • Tech stack: a Next.js web app and a matching SwiftUI iOS app living in two separate GitHub repos.
    • Environment: spun up rapidly in Codespaces (on-demand dev environment) and Xcode 16 for the mobile portion.
    • Task: an issue built from a couple of paragraphs to “Add English, French, and Spanish localization.”
    • Copilot tools: coding agent (to turn that issue into a PR), a custom planning chat mode (to try out the new preview capabilities in VS Code), and the new remote GitHub MCP server (so we can avoid managing those dependencies in our dev environment).

    By the end of my stream, that idea became a GitHub issue, which turned into a fully tested, review-ready PR while I fielded chat questions, and learned about the preview custom chat mode features in VS Code.

    Let’s dive in.

    Why I use agentic workflows

    Even seasoned developers and teams still burn hours on jobs like:

    • Turning vague requests into well-scoped issues
    • Hunting down every file in a cross-cutting refactor
    • Writing the same unit-test scaffolding again and again

    Copilot’s ability to create issues, along with its coding agent, custom chat modes in VS Code, and the new remote MCP backend fold those chores into one tight loop—issue to PR—while you stay firmly in the driver’s seat. You still review, tweak, and decide when to merge, but you skip the drudgery.

    Key capabilities covered in this livestream 

    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 to achieve a similar outcome

    1. A GitHub repo you can push to
    2. A Copilot subscription with coding agent enabled. (Did you know it’s now available for all paid tiers of GitHub Copilot including Copilot Business and Copilot Pro?)
    3. VS Code 1.101+ with the latest Copilot extension.
    4. Either: GitHub Remote MCP server (update your MCP configuration), or a local GitHub MCP server.

    Walk-through: localizing a Next.js app

    Here’s the exact flow I demoed on the most recent Rubber Duck Thursdays stream.

    1. Capture the request as a GitHub Issue

    Go to the immersive view of Copilot Chat. At the bottom of the page, in the “Ask Copilot” box, describe what you want. For example, below is the prompt that I used. 

    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.

    Copilot drafts that into an issue, which includes a title, acceptance criteria, and a loose action plan. From there, you can assign that issue to Copilot, and let it cook in the background. 

    2. Let the coding agent turn the issue into a PR

    Shortly after assignment, the coding agent:

    1. Creates a branch
    2. Starts a new session. If you have a copilot-setup-steps.yml configured, then a development environment will be configured before Copilot gets to work.
    3. Reviews the task at hand, explores the current state of the codebase, and forms a plan to complete the task.
    4. If you have any custom instructions configured, then the coding agent will also use those as context. For example, we specify that npm run lint and npm run test should pass before committing.
    5. Once complete, it opens a draft PR for your review.

    While that runs, you can keep coding, use it as an opportunity to learn (like we learned about custom chat modes) or grab a coffee.

    3. Review the PR like you normally would

    Whether it’s a colleague, collaborator, or Copilot writing the code, you still need a reviewer. So it’s important to make sure you look the code over carefully, just like you would any other pull request.

    1. Start by reviewing the body of the pull request, which Copilot will have helpfully kept up to date.
    2. Then, review the code changes in the files changed tab, understanding what has changed and why. I also like to take a look at the coding agent session to understand the approach Copilot took to solving the problem.
    3. Once you are comfortable, you may want to try the code out manually in a GitHub Codespace. Or, you may want to run any existing CI checks through your GitHub Actions workflows. But again, make sure you have carefully reviewed the code before executing it.
    4. All being well, you will have green check marks being returned from your CI. 

    However, there’s always a possibility that you encounter failures, or spot some changes in your manual testing. For example, I spotted some hard-coded strings that the agent hadn’t addressed. Once again, we approach this just like we would any other pull request. We can post our feedback in a comment. For example, here’s the comment I used:

    That’s a great start. However, there are a lot of pages which are hardcoded in English still. For example, the flight search/bookings page, the check reservation page. Can you implement the localization on those pages, please?

    Copilot will react to the comment once again, and get to work in another session. 

    Level up your workflows with custom chat modes

    If you’re using VS Code as your daily driver with GitHub Copilot, then you’re probably used to the ask, edit and agent chat modes. But in the VS Code 1.101 release, the team has added custom chat modes in preview. This allows you to package instructions and relevant tools for easier use. For example, I built upon the VS Code team’s “Plan” chat mode example:

    1. Open the command palette in Visual Studio Code
    2. Type Configure Chat Modes
    3. Select Create new custom chat mode file. You’ll be asked to save it either in the workspace (to allow collaborating with others), or in the local user data folder (for your use). We opted for the workspace option.
    4. Enter the name. This is the name that will appear in the chat mode selection box, so pay attention to any capitalization.
    5. You should see a new file has been created with the extension .chatmode.md. This is where you can configure the instructions, and the available tools for your new custom chat mode.

    Below is the example that we used in the livestream, slightly modified from the VS Code team’s docs example. We’ve added the create_issue tool to the list of allowed tools, adjusted our expectations of what’s included in the issue and added an instruction about creating the issue with the `create_issue` tool once revisions are complete and approved by the user.

    ---

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.

    When the file is available in your teammate’s local repositories (so they’ve pulled the changes locally), VS Code surfaces the mode in the chat dropdown, allowing you to configure chat modes that are consistent and convenient across your team.

    Remote MCP: removing the local setup

    You may be used to running MCP locally through npm packages or as docker containers. However, remote MCP servers allow you to reduce the management overhead of running these tools locally. There may be other benefits too. For example, the remote GitHub MCP Servers allows you to authenticate using OAuth 2.0 instead of Personal Access Tokens.

    To use the GitHub Remote MCP Server in VS Code, you’ll need to update the MCP configuration. You can find the instructions on how to do that in the GitHub MCP Server repository.

    💡 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!

    Going mobile: Copilot agent mode in Xcode

    While we didn’t show it in depth, I quickly walked through one of my previous agent mode sessions in Xcode. It showed how I gave a similar prompt to Copilot, asking to add internationalization to the app, which we were able to see in the main navigation bar of the app running in the simulator.

    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

    Try it yourself

    Next steps

    Agentic workflows within GitHub Copilot aren’t magic; they’re tools. When a single click can help reduce technical debt (or knock out any other repetitive task you dread), why not let Copilot handle the boilerplate while you tackle the more challenging, fun, and creative problems?

    The post From idea to PR: A guide to GitHub Copilot’s agentic workflows appeared first on The GitHub Blog.

    Source: Read More 

    Related Posts

    Leave A Reply

    For security, use of Google's reCAPTCHA service is required which is subject to the Google Privacy Policy and Terms of Use.