Copilot Agents Turn Issues into Tested PRs with Ease

In software development, the excitement often lies in bringing ideas to life—not in chasing strings or rebuilding boilerplate. Yet, many developers find themselves stuck in the prep work: refactoring, rewriting tests, and managing routine tasks before any actual features ship. To tackle these repetitive hurdles, one developer turned to GitHub Copilot’s agentic workflows during a live coding session. The goal was to test whether these tools could handle a localization request across a complex, two-repository project. By the end, what began as a vague issue became a fully tested pull request—all while engaging live viewers.

Automating the Tedious with Copilot Agents

The session focused on a multilingual localization task across a dual-platform application. The project spanned two separate repositories: one for a Next.js web app, the other for a SwiftUI iOS application. The environments were set up using GitHub Codespaces and Xcode 16. The localization request started as a brief issue—just a couple of paragraphs asking for support for English, French, and Spanish.

Instead of diving into each file manually, the developer used GitHub Copilot’s newer features. This included a coding agent, a custom planning chat mode inside VS Code, and the remote GitHub MCP server to streamline development. The result: a near-seamless path from idea to pull request.

From Idea to Issue: Letting Copilot Lead

To kick things off, the developer used the immersive Copilot Chat view in VS Code. In the “Ask Copilot” input box, they described the localization task. Copilot transformed that simple prompt into a well-scoped GitHub Issue. The output wasn’t just a title—it included clear acceptance criteria and a proposed action plan. Once confirmed, the issue was assigned to Copilot, triggering a background session.

During this session, the coding agent created a branch, analyzed the codebase, and followed custom setup instructions. If a copilot-setup-steps.yml file existed, it initialized the environment accordingly. The agent then proposed code changes and opened a draft PR—ready for human review.

Reviewing the Output with Developer Oversight

Once Copilot created the PR, the usual developer responsibilities remained. The session emphasized that reviewing AI-generated code still requires diligence. The reviewer examined both the pull request summary and the file changes. Importantly, they reviewed the agent session log to understand Copilot’s logic and code strategy.

After an initial test, some hard-coded English strings were still present, especially in areas like the flight booking and check reservation pages. A comment flagged this: “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?”

This triggered a new session where Copilot resumed work based on the feedback. It demonstrated how developers can remain in control, using AI as a powerful assistant—not a replacement.

Custom Chat Modes Enhance Workflow Consistency

One of the highlights of the stream was the demonstration of custom chat modes in VS Code 1.101. These allow teams to define reusable workflows with tailored tools and instructions. In this case, the developer extended the existing “Plan” chat mode to include the create_issue tool and extra guidance.

To set it up, they opened the command palette in VS Code and selected “Configure Chat Modes.” They chose to save the new .chatmode.md file in the workspace folder, allowing others to use it too. Inside the file, they specified tools, structured the expected output, and embedded team preferences.

Once saved and pulled locally, teammates could access the same mode from the chat dropdown—ensuring consistent behavior across the team.

GitHub MCP Server Goes Remote

Managing local setups can be time-consuming, especially when dealing with containers and dependencies. The live session demonstrated how to offload this task using GitHub’s remote MCP server. This eliminated the need to run MCP locally, reducing configuration friction.

With OAuth 2.0 replacing Personal Access Tokens for authentication, the remote MCP setup was not only simpler but also more secure. To activate it, developers had to update their MCP configuration file in VS Code, following GitHub’s documented process.

Localization on Mobile: Copilot in Xcode

Though the stream focused mainly on the web portion, the developer briefly showed a prior agent session in Xcode. With a similar prompt for localization, Copilot applied changes to the iOS SwiftUI project. The changes were visible in the main navigation bar of the app running in the simulator. While not explored in depth, it served as evidence that the agentic workflow could extend across platforms.

Real-World Development Still Needs Human Judgment

However, despite all the automation, the developer stressed a very important fact; such tools do not substitute people. It is a shift in developer control: reviewing PR, fixing an edge-case bug, or improving prompts still have a developer sitting in the driver seat. Copilot only speeds up the process.

Copilot agents, chat modes and remote MCP servers are not nymphs. They shorten the cycle between planning and doing, creating less friction and allowing developers to work on more value-add work. During this broadcast session, they transformed an undefined localization job into production code within the same session.

Smarter Workflows, Faster Results

The Rubber Duck Thursdays stream proved that agentic features of Copilot can involve software development tremendously. The system automated a series of tasks about parsing ambiguous requests to GitHub issues, creating tested pull requests, and performed several stages typically consisting of manual work. The use of custom chat modes provided a consistency across a team and remote MCP servers eliminated local configuration burdens.

Still, each step demanded human review, verification, and feedback. Copilot didn’t eliminate the developer’s role—it amplified it. With tools like these, developers can finally get back to what they signed up for: shipping great ideas, not chasing down hard-coded strings.

FAQs

What is GitHub Copilot’s coding agent, and how does it work?

GitHub Copilot’s coding agent automates developer tasks by turning GitHub Issues into pull requests. It creates branches, analyzes the codebase, follows custom instructions, and generates tested code changes—all while developers focus on higher-level decisions.

Can GitHub Copilot handle localization tasks across multiple platforms?

Yes, Copilot can assist with localization across different platforms. In the demo, it helped localize a Next.js web app and contributed to a SwiftUI iOS app, showing flexibility across tech stacks.

What are custom chat modes in VS Code, and why are they useful?

Custom chat modes in VS Code allow developers to define reusable workflows with specific tools and instructions. These modes help teams maintain consistent practices and streamline routine tasks.

What is the GitHub Remote MCP server, and how does it improve development?

The GitHub Remote MCP server offloads development tools from local machines, reducing setup overhead. It uses OAuth 2.0 for authentication and integrates directly with Copilot in VS Code.

Do developers still need to review Copilot-generated code?

Yes, all Copilot-generated pull requests should be carefully reviewed by developers. While Copilot automates many steps, human oversight ensures accuracy, code quality, and proper implementation.