Copilot Pr Autopilot

GitHubOfficialFirst committed by yeelam-gordonDistributed by GitHub

Skill
Workflow
Software development
MIT
Low risk
Has scripts

From the author

Copilot left 14 review comments on your PR — half are nits. Hours of fix → reply → resolve → re-request, and each round lands MORE comments. This skill runs loop engineering: auto-triggers Copilot Code Review via GraphQL (no @copilot mention), triages every open thread (Copilot, humans, advanced-security) with a fix / decline / escalate rubric, dispatches parallel fix sub-agents that obey the repo build/test/lint conventions, commits per iteration, replies+resolves citing the pushed SHA, then re-triggers until HEAD is reviewed with zero threads awaiting the agent's reply (remaining open threads are explicit hand-offs to the human — escalated declines, design tradeoffs). You merge a clean PR; the bot runs it. Trigger phrases: "address copilot comments", "run a copilot review loop", "fix this PR", "iterate on copilot feedback". Repo-agnostic, gh CLI + PowerShell. Full autopilot needs repo Triage/Write; external PR authors get single-iteration mode plus manual re-trigger (UI 🔄 or substantive-commit push).

— the description by yeelam-gordon

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Copilot PR Autopilot is a workflow-based skill designed to handle the repetitive cycle of addressing Copilot code review comments. It automates the process of triggering reviews, triaging findings, applying fixes, running build and test commands, and verifying convergence. The skill operates in a loop, ensuring that every Copilot finding is either fixed, declined with rationale, or escalated to a human reviewer. It is designed to be repository-agnostic and relies on the GitHub CLI and PowerShell to manage PR states and interactions.

What it does

Automatically triggers Copilot Code Review on a pull request.
Triage open review threads from Copilot, humans, and security scanners.
Dispatches sub-agents to apply fixes while adhering to repository build and test conventions.
Manages the commit and push cycle for each iteration of fixes.
Replies to and resolves review threads based on the agent's disposition.
Verifies convergence to ensure all threads are addressed or appropriately escalated.

When to use it

When a PR is functionally complete and requires a final automated correctness pass.
When a previous Copilot review has left numerous open threads that need systematic triage.
When you want to automate the repetitive 'fix-reply-resolve' cycle of PR reviews.

Advantages

Reduces manual effort in resolving large volumes of nit-picky review comments.
Maintains a clean audit trail by creating one focused commit per iteration.
Ensures fixes are validated against repository-specific build and test commands.
Provides a structured escalation path for design tradeoffs or human-specific feedback.

Usage examples

“address copilot comments”: The agent initiates the review loop, triages existing Copilot findings, applies necessary fixes, and pushes commits until the PR is ready for review.
“run a copilot review loop”: The agent triggers a new Copilot review, waits for the results, and begins the iterative process of fixing and resolving threads.
“fix this PR”: The agent analyzes the current PR state, identifies open review threads, and executes the fix-and-verify workflow to address all actionable feedback.
“iterate on copilot feedback”: The agent performs a single iteration of the review loop, applying fixes for current Copilot comments and reporting on the status of remaining threads.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/github/copilot-pr-autopilot/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip copilot-pr-autopilot.zip -d .agents/skills

Documentation by yeelam-gordon

Copilot PR Autopilot

Drive any GitHub pull request through repeated rounds of Copilot code review until the agent has done its job — every Copilot finding has a reply from the agent (fix-acknowledgement, decline-with-rationale, or explicit escalate-to-user hand-off). Remaining open threads, if any, are deliberate hand-offs to the human merge owner — they're not loop failures. Repository-agnostic — works on any repo that has Copilot Code Review enabled, run from a machine with gh CLI installed and authenticated (see Prerequisites).

When to Use This Skill

The user asks to "request Copilot review" or "run a Copilot review loop" on a PR.
A PR is functionally complete and the user wants a final correctness pass via repeated automated review rounds.
A previous Copilot review on the PR has left open threads that need triage, fixing, replying, and resolving.

When NOT to Use This Skill

The PR is still under active design — wait until the structure is stable; otherwise findings churn round-over-round.
The user wants human reviewer feedback, not Copilot's.

Prerequisites

gh CLI installed and authenticated against the target repository.
PowerShell on PATH — Windows PowerShell 5.1+ (powershell.exe) or PowerShell 7+ (pwsh). Both are tested.
Copilot Code Review is the primary use case (01-request-review.ps1 uses GraphQL requestReviewsByLogin to trigger Copilot). It is NOT a hard requirement — if 01-request-review.ps1 fails because Copilot isn't enabled on the repo / account, the agent can still drive existing review threads (human, advanced-security, etc.) to completion by running steps 3–8 once as a single iteration; just skip the trigger + wait. There is no auto-detect for "Copilot unavailable" — the agent makes that decision after the trigger fails (the script can't reliably tell "Copilot disabled" from "Copilot enabled but not yet triggered" from API state alone).

Permissions: who can run the full loop

The full multi-round autopilot (steps 1 → 9 → 1) needs Triage or Write permission on the target repo, because GitHub's only public API for adding the Copilot bot as a reviewer (requestReviewsByLogin) is gated on that permission. Verified against the public REST + GraphQL surface in this PR's commit history — there is no public-API path for bot reviewers without write permission.

You are…	What works
Repo collaborator with Triage / Write	Full loop: `01` triggers Copilot, `02` waits, `04`–`08` triage / fix / reply, loop back to `01`. Hands-off.
External PR author (no write permission)	`01` will throw a clear actionable error. Use `-SingleIteration` mode: address all current findings in one pass, then either click the UI 🔄 next to Copilot, or push a substantive commit (the `synchronize` event auto-triggers Copilot on most repos). Then re-run `02` to verify.

In single-iteration mode the loop's convergence boolean is Converged: true iff OpenThreadsAwaitingReply == 0 (the agent's side is done). The maintainer-side re-trigger then drives any additional rounds.

Every script dot-sources scripts/_lib.ps1 which runs Assert-GhReady on load: if gh is missing OR gh auth status fails, the script halts before any work with a single actionable error message naming the install command and gh auth login. The agent should surface that message to the user verbatim and stop the loop — do not retry or work around it.

Step-by-Step Workflow

The loop: steps 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9, then back to step 1 if Converged: false. Repeat the 1→9 round until step 9 returns Converged: true; only then run step 10 once and call task_complete. At every 10th round, the parent runs the round-cap recap gate before looping back — recap all prior rounds and stop if the loop has drifted out of the PR's original scope.

Each round runs steps 1–9; step 10 is a one-time cleanup after convergence. The parent agent coordinates; every sub-agent step runs in a fresh context with a bounded budget. Cross-cutting protocol (time-boxing, extension, single-iteration fallback): orchestration.md.

Request review (parent) — see 01-request-review.md
Wait for review (sub-agent, 20-min cap) — see 02-wait.md
List + categorize open threads (sub-agent, 5 min) — see 03-list-threads.md
Triage (sub-agent, 5 min per ≤5 threads) — see 04-triage.md
Fix (sub-agents, parallel max 5, 5 min each) — see 05-fix.md
Build + test per repo conventions (sub-agent, 10 min) — see 06-build-test.md
Commit + push (parent) — see 07-commit-push.md
Reply (always) + resolve (conditional) (sub-agent drafts, parent posts) — see 08-reply-resolve.md
Convergence verify (sub-agent, 3 min) — see 09-convergence.md
- Converged: false → loop back to step 1 for another round (re-trigger, wait, list, triage, fix, push, reply, re-check). Each round addresses Copilot's findings on the previous round's HEAD; the loop terminates as soon as Copilot has nothing new to say AND every open thread has a reply from the agent.
- Converged: true → exit the loop, run step 10 once, call task_complete with the proof.
- Every 10th round (10, 20, 30…) → run the round-cap recap gate before looping back. Recap ALL prior rounds against the PR's original scope and pick a verdict: CONTINUE, REVERT-AND-SHIP (drop drifted commits, ship the in-scope ones), or HAND-OFF (escalate to the user). This is the circuit breaker that stops a runaway bot-review loop.
Cleanup outdated (parent, post-convergence, once) — see 10-cleanup.md

Convergence is computed by scripts/02-check-review-status.ps1 as a single Converged: true boolean. Do not call task_complete until it returns true; print the proof (HeadOid, LatestCopilotReview.commitOid, submittedAt) in the completion message.

Gotchas

The bundled scripts enforce the hard correctness invariants (trigger landing via copilot_work_started event id, Converged requiring HEAD-match + zero-awaiting + at-HEAD review, single-iteration fallback semantics, PR-state guard). Trust them — don't re-derive. The notes below cover decisions the scripts can't make for you:

Reply to every open thread; resolve only when the loop owns the disposition. For fix and decline threads, reply + resolve. For escalate-to-user threads, reply with the analysis but leave the thread OPEN (08-reply-and-resolve.ps1 -NoResolve) so the human merge owner can act on it. See 08-reply-resolve.md.
Copilot threads are loop-owned; human / advanced-security / other-bot threads default to escalate-to-user. Auto-resolving a human review thread can hide unaddressed concerns. See 04-triage.md for the rubric.
One focused commit per round, not one per PR. Bundling rounds destroys the audit trail of which finding drove which change and breaks git bisect. See 07-commit-push.md.
Build/test/lint with the repo's own commands (per its CONTRIBUTING / AGENTS / README / package.json / Makefile) before pushing a fix. Discovery procedure: 06-build-test.md.
Push back with written rationale when a Copilot finding would over-engineer the design for a hypothetical edge case. Auto-accepting every suggestion erodes the design — see the decline path in 04-triage.md.
Scripting traps (gh api graphql -F type-coercion, git stash push -m positional parsing, the three GraphQL traps for the reviewer mutation) are documented in references/api-quirks.md. Read before modifying any script.

Troubleshooting

Issue	Solution
Script throws `prerequisite missing — gh CLI is not on PATH`	Install `gh` (`winget install GitHub.cli` on Windows; `brew install gh` on macOS; package manager on Linux; or download from https://cli.github.com). Then `gh auth login`. Surface the message to the user and STOP the loop — do not retry.
Script throws `prerequisite missing — gh CLI is not authenticated`	Run `gh auth login`. STOP the loop until the user completes auth.
Trigger fails or no `copilot_work_started` event lands	Push a substantive (non-whitespace) commit — auto-assign on `synchronize` is the most reliable trigger. Persistent failure indicates Copilot Code Review may not be enabled on the repo / account (check repo Settings → Code & automation → Copilot, or account-level Copilot Pro/Pro+).
No new review after waiting ~10 min	Quiet-period after recent dismissal or trivial-diff suppression. Push a substantive commit and retry. Do not blindly re-run `01-request-review.ps1` — it reports `InFlight` while Copilot is still a requested reviewer.
Outdated-but-unresolved threads in the open list	Expected: unresolved state is the source of truth. Reply + resolve them like any other open thread. `10-cleanup-outdated.ps1` is only a final safety net.
Unsure whether to fix or decline a finding	See references/04-triage.md.
Need a reply phrasing for "fixed", "declined", or "drift"	See the templates under templates/ — reply-fix.md, reply-decline.md, reply-drift.md, reply-partial.md.

References

references/orchestration.md — cross-cutting loop control: time-boxing & extension protocol, sub-agent delegation map, single-iteration fallback, and loop-wide notes.
Per-step contracts (one NN-*.md per step): references/01-request-review.md (parent), references/02-wait.md, references/03-list-threads.md, references/04-triage.md (includes the fix-vs-decline rubric), references/05-fix.md, references/06-build-test.md, references/07-commit-push.md (parent), references/08-reply-resolve.md, references/09-convergence.md (includes the round-cap recap gate), references/10-cleanup.md (parent).
references/api-quirks.md — verified GitHub API behavior, dead-ends, and the GraphQL traps for the reviewer mutation.
Templates (one per reply type): templates/reply-fix.md — accepted-fix pattern; templates/reply-decline.md — declined-with-rationale pattern; templates/reply-drift.md — PR-description / comment / test-plan drift acknowledgement; templates/reply-partial.md — partial fix with deferred follow-up. Cross-cutting reply guidance and anti-patterns live in references/08-reply-resolve.md.
scripts/_lib.ps1 — shared helpers (Invoke-Gh, Invoke-GhGraphQL, Resolve-RepoCoords); dot-sourced by every script.
scripts/01-request-review.ps1 — trigger Copilot review and verify pickup via the copilot_work_started event.
scripts/02-check-review-status.ps1 — single-shot snapshot of the PR's Copilot review state; emits Converged: true only when all three conditions hold.
scripts/03-list-open-threads.ps1 — every unresolved PR review thread from all reviewers (Copilot, humans, github-advanced-security, etc.).
scripts/08-reply-and-resolve.ps1 — post a reply and resolve in one call.
scripts/10-cleanup-outdated.ps1 — safety net for outdated Copilot threads.

Files

ATTRIBUTION.mdAdded by AutoGineer883 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md13.6 KiB
references/01-request-review.md1.4 KiB
references/02-wait.md1.7 KiB
references/03-list-threads.md1.7 KiB
references/04-triage.md8.0 KiB
references/05-fix.md2.4 KiB
references/06-build-test.md2.1 KiB
references/07-commit-push.md712 B
references/08-reply-resolve.md3.8 KiB
references/09-convergence.md10.5 KiB
references/10-cleanup.md707 B
references/api-quirks.md8.4 KiB
references/orchestration.md6.1 KiB
scripts/01-request-review.ps1Script13.2 KiB
scripts/02-check-review-status.ps1Script17.4 KiB
scripts/03-list-open-threads.ps1Script4.0 KiB
scripts/08-reply-and-resolve.ps1Script3.3 KiB
scripts/09-review-round.ps1Script5.5 KiB
scripts/10-cleanup-outdated.ps1Script17.7 KiB
scripts/_lib.ps1Script15.5 KiB
templates/reply-decline.md871 B
templates/reply-drift.md317 B
templates/reply-fix.md839 B
templates/reply-partial.md376 B

scripts/09-review-round.ps1

<#
.SYNOPSIS
    Deterministically count a PR's Copilot review rounds and flag whether
    the periodic recap gate is due this round. Single-shot, read-only.

.DESCRIPTION
    ONE job: compute the round number N for a PR from observable history —
    the count of review submissions authored by the Copilot Code Review
    bot — and report whether the recap circuit-breaker is due.

    Each top-of-loop trigger (01-request-review.ps1) produces exactly one
    Copilot review submission, so the count of those submissions IS the
    round number. It is read from the GitHub API on every call, so it
    never depends on agent working memory or any on-disk state file. The
    original failure mode this skill was built to survive — an agent
    losing track of the count across a long run, drifting for 156 rounds —
    cannot happen when the count is derived, not remembered.

    This script does NOT decide anything. It does not stop the loop, does
    not enforce a cap, and does not pick a verdict. It reports two facts;
    the parent agent still owns the recap reasoning and the
    CONTINUE / REVERT-AND-SHIP / HAND-OFF verdict (see
    ../references/09-convergence.md). "No script decides the cap" stays
    true — this script only makes the *trigger* (Nth round) deterministic
    instead of a fallible mental tally.

    Output JSON fields:
      - PrNumber, Owner, Repo
      - Round         : count of Copilot Code Review submissions on the PR.
                        Full pagination — every Copilot submission, NOT the
                        most-recent-100 window 02-check-review-status.ps1
                        uses to find the latest review. The count must stay
                        correct on exactly the long loops the gate exists
                        to catch (a 100-review window would silently
                        undercount past round 100).
      - RecapInterval : the recap cadence (default 10; override with
                        -RecapInterval).
      - RecapDue      : true iff Round > 0 AND Round % RecapInterval == 0 —
                        i.e. this is a 10th / 20th / 30th ... round and the
                        parent should RUN THE RECAP GATE before looping back
                        to step 1.

    Parsing the JSON (any PowerShell version, 5.1 + 7.x):

        $snap     = pwsh -NoProfile -File 09-review-round.ps1 -PrNumber <n>
        $round    = if ($snap -match '"Round":(\d+)')    { [int]$Matches[1] } else { 0 }
        $recapDue = ($snap -match '"RecapDue":true')

.PARAMETER PrNumber
    The pull request number. The only required parameter.

.PARAMETER Owner
    Repository owner. OPTIONAL — auto-resolved from `gh repo view`.

.PARAMETER Repo
    Repository name. OPTIONAL — auto-resolved from `gh repo view`.

.PARAMETER RecapInterval
    Recap cadence in rounds. Default 10 (stop at 10, 20, 30, ...). Must be
    a positive integer. Exposed as a single named knob so the cadence
    isn't a magic number duplicated in prose, and so the gate boundary is
    testable on a real PR without fabricating review history.

.EXAMPLE
    pwsh ./scripts/09-review-round.ps1 -PrNumber 1944

    # {"PrNumber":1944,"Owner":"github","Repo":"awesome-copilot","Round":154,"RecapInterval":10,"RecapDue":false}

.EXAMPLE
    pwsh ./scripts/09-review-round.ps1 -PrNumber 1944 -RecapInterval 7

    # 154 % 7 == 0 -> {"...","Round":154,"RecapInterval":7,"RecapDue":true}
#>
[CmdletBinding()]
param(
    [Parameter(Mandatory = $true)]
    [int]$PrNumber,

    [string]$Owner,
    [string]$Repo,

    [ValidateRange(1, [int]::MaxValue)]
    [int]$RecapInterval = 10
)

$ErrorActionPreference = 'Stop'
. "$PSScriptRoot/_lib.ps1"

$coords = Resolve-RepoCoords -Owner $Owner -Repo $Repo
$Owner = $coords.Owner
$Repo  = $coords.Repo

# Walk ALL reviews (full pagination). 02-check-review-status.ps1 only needs
# the most-recent-100 window to find the LATEST Copilot review; the round
# COUNT must include EVERY Copilot submission, because the gate exists
# precisely for long loops where the count can exceed 100. Counting is
# order-independent, so forward pagination is sufficient.
$qReviews = @'
query($o:String!,$r:String!,$n:Int!,$after:String){
  repository(owner:$o,name:$r){
    pullRequest(number:$n){
      reviews(first:100, after:$after){
        pageInfo{endCursor hasNextPage}
        nodes{author{login}}
      }
    }
  }
}
'@

$after = $null
$round = 0
do {
    $ghArgs = @('-f', "query=$qReviews", '-f', "o=$Owner", '-f', "r=$Repo", '-F', "n=$PrNumber")
    if ($after) { $ghArgs = $ghArgs + @('-f', "after=$after") }
    $resp = Invoke-GhGraphQL -GhArgs $ghArgs -Context "reviews count for $Owner/$Repo PR #$PrNumber"
    $pagePr = $resp.data.repository.pullRequest
    if (-not $pagePr) { throw "PR #$PrNumber not found in $Owner/$Repo (reviews page)." }
    $round += @($pagePr.reviews.nodes | Where-Object {
        $_.author -and $_.author.login -and $_.author.login -match $CopilotReviewerLoginRegex
    }).Count
    $after = $pagePr.reviews.pageInfo.endCursor
} while ($pagePr.reviews.pageInfo.hasNextPage)

# Gate TRIGGER only — not the verdict. RecapDue says "this is an Nth round,
# run the recap"; the parent agent reads the recap and picks
# CONTINUE / REVERT-AND-SHIP / HAND-OFF (09-convergence.md).
$recapDue = ($round -gt 0) -and (($round % $RecapInterval) -eq 0)

$result = [ordered]@{
    PrNumber      = $PrNumber
    Owner         = $Owner
    Repo          = $Repo
    Round         = $round
    RecapInterval = $RecapInterval
    RecapDue      = $recapDue
}
$result | ConvertTo-Json -Depth 3 -Compress

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

What our scanner noticed· Low risk

Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by

yeelam-gordon

Publisher

GitHub (Official)

Distributed by

GitHub

Source

github/awesome-copilot · skills/copilot-pr-autopilot · commit 797337f

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

Contributors