AutoGineer
Generated banner for Copilot Pr Autopilot
Generated logo for Copilot Pr Autopilot

Copilot Pr Autopilot

GitHubOfficialFirst committed by yeelam-gordonDistributed by GitHub

  • Skill
  • Workflow
  • Software development
  • MIT
  • Low risk
  • Has scripts
Download ZIP

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

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/github/copilot-pr-autopilot/download

  2. 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 / WriteFull 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.

  1. Request review (parent) — see 01-request-review.md

  2. Wait for review (sub-agent, 20-min cap) — see 02-wait.md

  3. List + categorize open threads (sub-agent, 5 min) — see 03-list-threads.md

  4. Triage (sub-agent, 5 min per ≤5 threads) — see 04-triage.md

  5. Fix (sub-agents, parallel max 5, 5 min each) — see 05-fix.md

  6. Build + test per repo conventions (sub-agent, 10 min) — see 06-build-test.md

  7. Commit + push (parent) — see 07-commit-push.md

  8. Reply (always) + resolve (conditional) (sub-agent drafts, parent posts) — see 08-reply-resolve.md

  9. 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.

  10. 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

IssueSolution
Script throws prerequisite missing — gh CLI is not on PATHInstall 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 authenticatedRun gh auth login. STOP the loop until the user completes auth.
Trigger fails or no copilot_work_started event landsPush 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 minQuiet-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 listExpected: 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 findingSee 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

Files

references/09-convergence.md

Step 9: Convergence verify

Sub-agent type: explore; budget: 3 min.

Inputs

  • PrNumber.

  • The pushed HeadOid from step 7 (for the independent sanity check).

  • Whether the loop is in normal mode or single-iteration mode (decided at step 1).

Return contract

{ converged, head_oid, latest_review_commit_oid, submitted_at,
  open_thread_count, open_threads_awaiting_reply, escalated_threads }

converged is the single source-of-truth boolean — Converged: true returned by 02-check-review-status.ps1.

Procedure

Run the status check, passing -SingleIteration iff the loop took the fallback at step 1:

pwsh ./scripts/02-check-review-status.ps1 -PrNumber <n>
# single-iteration variant:
pwsh ./scripts/02-check-review-status.ps1 -PrNumber <n> -SingleIteration

Then run an independent HEAD-vs-LatestCopilotReview.commitOid sanity check — the parent's recorded HeadOid from step 7 should match HEAD and (in normal mode) match the latest review's commitOid.

Decision: loop back or exit

After the status check, the parent agent must branch on converged:

if converged == true:
    run step 10 once (cleanup outdated)
    call task_complete with proof (HeadOid, LatestCopilotReview.commitOid, submittedAt)
    DONE — exit the loop
else:
    # non-converged = a fresh Copilot finding OR an unresolved human thread.
    # round = count of Copilot review submissions in the PR's history,
    #         read deterministically from the API (NOT a mental tally):
    #             pwsh ./scripts/09-review-round.ps1 -PrNumber <n>   -> {Round, RecapDue}
    if RecapDue == true:                        # Round is 10, 20, 30, ...
        RUN THE RECAP GATE (see "Round cap & recap gate" below) BEFORE looping:
            recap ALL prior rounds, then pick CONTINUE / REVERT-AND-SHIP / HAND-OFF.
            CONTINUE        -> fall through and start another round
            REVERT-AND-SHIP -> drop drifted commits, ship the in-scope result, exit
            HAND-OFF        -> escalate to the user with the recap, exit
    GO BACK TO STEP 1 — start another round
    (re-trigger via 01-request-review.ps1, wait via 02-wait,
     list via 03-list-threads, triage, fix, push, reply+resolve,
     re-check via this step)

A non-converged result is never terminal on its own — each round addresses the open review feedback on the previous round's HEAD, whether that's a Copilot finding or a human review comment (this skill handles both). The loop terminates only when there are no new review comments from either source AND every open thread — Copilot or human — has a reply from the agent (a thread the agent escalated to the user counts as replied; it stays open in OpenThreadCount as an explicit hand-off, not as loop work). But "never terminal" must not be read as "infinite": a bot-review loop has no guaranteed fixed point and can drift into over-engineering or oscillation. No script enforces a cap or stops the loop — capping is a reasoning decision the parent owns at the round-cap recap gate below. What is scripted is the round count itself (09-review-round.ps1), so the gate's trigger is deterministic rather than a fallible mental tally (and oscillation — the same finding re-raised across rounds — is broken earlier per 04-triage.md).

-SingleIteration mode is the one exception: by definition, it runs one round only (the trigger path is unavailable), and the converged result is taken as terminal whichever way it goes.

Convergence semantics

02-check-review-status.ps1 implements a PR-state guard plus three Converged branches (see the Converged = if (...) block near the end of that script for the canonical source):

  • PR State guard (overrides everything) — if State != 'OPEN' (CLOSED / MERGED), Converged: false regardless of all other flags. The agent cannot push to a non-OPEN PR; surface the state change to the user and abort the loop rather than calling task_complete.

  • Normal (Copilot-driven) mode — a Copilot review exists OR CopilotPending: true: Converged: true iff ReviewAtHead && NoNewComments && OpenThreadsAwaitingReply == 0.

  • Single-iteration mode (-SingleIteration passed because the loop took the fallback at step 1): Converged: true iff OpenThreadsAwaitingReply == 0. The stale-review checks can never advance without a new Copilot review, so they're omitted.

  • No Copilot review ever observed AND not pending (brand-new PRs with zero findings, or PRs where the trigger silently failed and the script wasn't called with -SingleIteration): Converged: true iff OpenThreadsAwaitingReply == 0. Do NOT trust this as "loop done" before step 1 has fired — it just means there's no human-thread work pending. The parent agent MUST run 01-request-review.ps1 first (per step 1) and re-check; treating brand-new-PR convergence as terminal will short-circuit the entire loop.

OpenThreadCount MAY be > 0 when escalated-to-user threads stay open — that's an explicit human hand-off, not a loop failure. Return the list of escalated thread_ids so the parent can include them in the convergence proof.

Round cap & recap gate (circuit breaker)

No script enforces a max-rounds cap or stops the loop — a hard number can't tell a productive round from a drifting one. Instead the parent agent runs a recap gate as reasoning: default STOP at every 10th round (10, 20, 30, …) before looping back to step 1, recap all prior rounds, and decide whether the loop is still serving the PR's original scope.

What is scripted is the count, so the gate's trigger is deterministic instead of a fallible mental tally. A round is one execution of step 1 — one Copilot-review trigger at the top of the loop — which produces exactly one Copilot review submission. 09-review-round.ps1 counts those submissions straight from the PR's API history and reports whether the cadence is hit:

pwsh ./scripts/09-review-round.ps1 -PrNumber <n>
# {"PrNumber":<n>,...,"Round":20,"RecapInterval":10,"RecapDue":true}

Run it at the top of the non-converged branch and gate on RecapDue. Because the count is derived from history, not remembered, it can't drift even across a 100+ round run — the exact failure this gate exists to catch. The cap counts review rounds (Copilot review submissions), not sub-agent calls, tool calls, or individual fix edits — so a round that triages five threads still counts as one. The cadence is the -RecapInterval knob (default 10). The script reports the trigger only; it never decides the verdict.

This exists because an unbounded bot-review loop is the failure mode this skill was built to survive: a real run drifted for 156 rounds — later rounds "fixing" things the PR never set out to change, eventually reverting their own earlier fixes. The gate catches that class of drift early, every 10 rounds, instead of once at the end.

What the recap reviews (ALL prior rounds, not just the last 10)

  1. Original PR scope — the issue/PR title and the diff at the PR's base. This is the yardstick; everything else is measured against it.

  2. Per-round ledger — for each round so far: the Copilot finding, the disposition (fixed / declined / escalated), and the resulting change (files + intent in one line).

  3. Drift signals across the whole history:

    • Out-of-scope — a change that doesn't trace back to the original issue/PR goal (new feature, adjacent refactor, polish the PR never promised).

    • Over-engineering — defensive layers, abstractions, or config added solely to satisfy bot nits, not the PR's actual goal.

    • Wrong-direction — a fix that later rounds had to undo, work around, or re-fix (self-revert / oscillation across rounds).

    • Belongs-in-separate-PR — a legitimate improvement that is nonetheless unrelated to this PR's stated change.

    • Scope/complexity growth — diff size or file count climbing while the original goal was met rounds ago.

Verdicts
VerdictWhenAction
CONTINUEEvery round so far traces to the original PR scope; no drift signals; Copilot is still surfacing in-scope findings.Loop back to step 1 for the next 10-round block.
REVERT-AND-SHIPOne or more rounds drifted (over-engineering / wrong-direction / oscillation) but the in-scope fixes are sound.git revert (or drop) only the drifted commits, keep the in-scope ones, run step 6 build/test, then ship the clean result. Record which rounds were reverted in the convergence proof.
HAND-OFFDrift is entangled with in-scope work, the right fix is a redesign, or the change belongs in a separate PR.Stop the loop, reply on the relevant threads, and escalate to the user with the recap and a recommendation (separate PR / redesign). Do not keep looping.

The trigger is scripted but the verdict is agent reasoning — deliberately. 09-review-round.ps1 makes the count deterministic (so the gate can't be missed), but which verdict to pick stays a judgment call: no number can tell a productive round from a drifting one. The recap is cheap (read the per-round commits + the PR base diff); the cost of skipping it is another runaway loop.

  • Trust 02-check-review-status.ps1's Converged flag, not your own re-derivation. The script enforces all three conditions (normal mode) or the simplified condition (single-iteration) and is the canonical source.

  • Don't call task_complete until converged == true. Print the proof (HeadOid, LatestCopilotReview.commitOid, submittedAt, OpenThreadsAwaitingReply: 0, list of escalated threads if OpenThreadCount > 0) in the completion message.

  • -SingleIteration is sticky to the fallback decision. If step 1 took the fallback, every step 9 in this loop uses -SingleIteration; don't flip it mid-loop.

  • PR State != OPEN aborts the loop. If State is CLOSED or MERGED, Converged is forced false by the script's state guard. The parent agent cannot push to a non-OPEN PR — surface the state change to the user and stop the loop rather than retrying or calling task_complete.

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
GitHub avatar of yeelam-gordonyeelam-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
Contributors
yeelam-gordon

AutoGineer is not affiliated with or endorsed by yeelam-gordon or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download copilot-pr-autopilot.zip