Turning stale issues into shipped code with Copilot's WRAP method

Backlogs tend to fill up with the work that's easy to postpone: dependency upgrades, extra test coverage, or adopting a new pattern across a codebase. GitHub's engineering team has spent more than a year using the GitHub Copilot coding agent internally, and from that experience they've distilled a practical workflow for turning those lingering issues into completed pull requests. The process is summed up as WRAP: Write effective issues, Refine your instructions, use Atomic tasks, and Pair with the coding agent.

Write effective issues

The first step is framing an issue so the agent can act on it without needing clarification. The guiding principle is to write as though the assignee is entirely new to the codebase. That means including the context a newcomer would need to succeed. When an issue can be read that way, it usually contains enough detail for the agent as well.

There are a few other things worth doing when drafting an issue for the agent:

  • Use a descriptive title that names the work location. The agent can be assigned many tasks at once, which means you may end up reviewing numerous pull requests. A title like Update auth middleware to async/await is easier to track in the agent panel than something vague like Migrate to async/await.
  • Include examples of the expected output. If you want a specific error-handling pattern or a particular code style, put an example in the issue. This kind of concrete reference does more than a paragraph of description to get the result you want.

Comparing two phrasings shows the difference. Instead of issuing a broad instruction like:

Update the entire repository to use async/await

An effective issue would be more targeted:

Update the authentication middleware to use the newer async/await pattern, as shown in the example below. Add unit tests for verification of this work, ensuring edge cases are considered.
>

async function exampleFunction() {

  let result = await promise;

  console.log(result); //”done!”

}

Refine your instructions

Custom instructions let you pre-load preferences so the agent's output matches your standards, whether those apply to one repository or an entire organization.

  • Repository custom instructions are the right home for anything that applies to all work in a single repository. For a Go application, for example, you might record preferred code conventions there. These instructions improve every Copilot interaction in that repo, not just the coding agent. Documentation for setting them up is available from GitHub.
  • Organization custom instructions work the same way but across every repository in an organization. Mandatory requirements, such as creating tests for all applications, fit here.
  • Custom agents are defined with a natural language text file and can be scoped to an enterprise, organization, or repository. Use them for recurring tasks that aren't relevant to every change, such as an Integration Agent that handles the standard steps for wiring a new product into a specific repository.

The repository-level file is a sensible first assignment for the coding agent itself: asking it to generate the initial custom instructions for its own repo is a task with clear scope and immediate payoff.

Atomic tasks

The coding agent performs best on small, self-contained assignments. For larger problems, the approach is to decompose them into independent chunks rather than assigning one massive issue. A request to rewrite 3 million lines of code from Java to Golang is generally too broad for the agent and painful to review. Splitting that same objective into module-level tasks creates work that can be validated individually:

  • Migrate the authentication module to Golang, ensuring all existing unit tests pass.
  • Convert the data validation utilities package to Golang while maintaining the same API interface.
  • Rewrite the user management controllers to Golang, preserving existing REST endpoints and responses.

Each piece becomes a separate pull request that's easier to test and review, and the overall transformation is staged rather than risky.

Pair with the coding agent

Getting the most out of the agent also depends on knowing the division of labor between human and model.

Some things remain firmly human strengths:

  • Understanding the "Why." People know the original intent behind an issue and can judge whether proposed changes actually solve the problem that prompted the work.
  • Navigating ambiguity. A human can work from a terse instruction, while the agent needs spelled-out expectations like which tests should exist and what telemetry should be added.
  • Cross-system thinking. When a change in one repo has implications for another system, you can't rely on the agent to notice. Mapping those side-effects is a human responsibility.

The agent, for its part, brings its own set of capabilities:

  • Tireless execution. Ten tasks can be assigned at once, and the agent will work through them.
  • Repetitive tasks. Consistency for mechanical changes—like updating naming conventions across dozens of files—is where humans have historically slipped or gotten bored.
  • Exploring possibilities. If you're weighing a couple of implementation strategies, you can assign one issue per approach and compare the pull requests the agent produces without dedicating much of your own development time.

Keeping these complementary roles in mind avoids friction when results don't match expectations. With the WRAP checklist, you already have what it takes to run coding agent against your own technical debt.