New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

PR Takeover

by nexu-io in nexu-io/looper

A skill your agent uses when asked to take over, adopt, or babysit a GitHub pull request until it merges — read review feedback, fix it, resolve threads, dismiss unreasonable change requests, and…

MITAuto-check passedDevelopment

Install PR Takeover

skills CLI
$ npx skills add nexu-io/looper --skill pr-takeover -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install nexu-io/looper pr-takeover --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/nexu-io/looper.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/pr-takeover .claude/skills/pr-takeover && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
pr-takeover
GitHub stars
133
Token cost
~2.3k tokens
SKILL.md length
872 words
Files
2 (incl. references)
Skills in repo
2
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when asked to take over, adopt, or babysit a GitHub pull request until it merges — read review feedback, fix it, resolve threads, dismiss unreasonable change requests, and…

  • Asked to take over
  • SKILL.md covers Step 0 — Choose the mode…, Prerequisites, Mode B — Background (Looper… and Mode A — Live (this session), plus 3 more sections
  • Calls gh and git
  • Babysit a GitHub pull request until it merges — read review feedback

What it does

PR Takeover is an agent skill from nexu-io/looper. Use when asked to take over, adopt, or babysit a GitHub pull request until it merges — read review feedback, fix it, resolve threads, dismiss unreasonable change requests, and merge once approved and green. Picks between driving the PR live in this session or handing it to the Looper daemon for unattended background runs, confirming with the user when unclear. Triggers on "take over this PR", "接管这个 PR", "持续修复 review 直到合并", or a Looper takeover bot comment. Works in any coding agent (Claude Code, Codex, opencode…

Its SKILL.md is about 2.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/github-commands.md`).

It sits in Development, covering Pull requests. It works with Git and GitHub. The repository describes itself as: 🔁 Run AI coding agents as an autonomous dev team across all your GitHub repos — plan, review, fix, and ship, on a loop. The licence is MIT.

When your agent uses it

  • Asked to take over
  • Babysit a GitHub pull request until it merges — read review feedback
  • Resolve threads
  • Dismiss unreasonable change requests

Example prompts

  • “take over this PR”
  • “接管这个 PR”
  • “持续修复 review 直到合并”
  • “/pr-takeover”

What it can do on your machine

Read from SKILL.md and the folder at commit 6abd8ff. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • gh
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use gh and git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

PR Takeover loads about 2.3k tokens when it runs, and up to ~3.5k if it reads all its reference files. Until then it costs about 139 tokens; SKILL.md has 872 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~139
When it runs · the whole SKILL.md, loaded when a task matches
~2.3k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~3.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from nexu-io/looper at commit 6abd8ff, republished under its MIT licence (© nexu-io). 872 words, ~2,254 tokens.

Download SKILL.mdSave it as .claude/skills/pr-takeover/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
pr-takeover
description
Use when asked to take over, adopt, or babysit a GitHub pull request until it merges — read review feedback, fix it, resolve threads, dismiss unreasonable change requests, and merge once approved and green. Picks between driving the PR live in this session or handing it to the Looper daemon for unattended background runs, confirming with the user when unclear. Triggers on "take over this PR", "接管这个 PR", "持续修复 review 直到合并", or a Looper takeover bot comment. Works in any coding agent (Claude Code, Codex, opencode, Gemini, …) using gh + git.

PR Takeover

Drive one pull request to merge: continuously read the live review state, fix what reviewers ask for, reply to and resolve threads, dismiss change requests you can justify as wrong, and merge once the PR is approved and all required checks pass — looping until it lands.

There are two ways to run this. Pick one in Step 0, then execute it.

ModeWho runs the agentLifetimeNeeds
A · Live (default)you, in this sessionuntil your session endsgh + git only
B · Backgroundthe Looper daemonsurvives you leaving; runs for daysLooper installed

Step 0 — Choose the mode (confirm with the user only if unclear)

  1. If the user already signalled a preference, honor it:
    • "in the background", "while I'm away", "even after I close this", "set and forget" → Mode B.
    • "watch it", "do it now", "in here" → Mode A.
  2. Otherwise default to Mode A (zero install, uses your already-authenticated session). Mention in one line that Mode B exists for unattended runs, and switch only if they ask.
  3. Choose Mode B only if command -v looper succeeds and the user wants it unattended. If they want unattended but Looper isn't installed, tell them to install it (https://github.com/nexu-io/looper) or fall back to Mode A.

Keep this lightweight — ask at most one short question, and only when the user gave no signal.

Prerequisites

bash
gh auth status                  # authenticated, with push access to the PR branch
git rev-parse --show-toplevel   # run from inside the repo checkout

Identify the PR (explicit <owner>/<repo>#<num> wins; else the current branch's):

bash
gh pr view --json number,headRefName,baseRefName,url

If no PR exists for the branch, stop and ask the user to open one.

Mode B — Background (Looper daemon)

Hand the PR to Looper and you're done; it runs the reviewer + fixer loops itself.

bash
looper takeover <owner>/<repo>#<num> --merge   # --merge enables auto-merge once approved + green
looper takeover list                           # check status later
looper takeover stop <owner>/<repo>#<num>      # stop it

Scopes Looper to just this PR (it won't touch other PRs). Note: Looper runs its own agent headlessly, so its configured agent vendor must be authenticated for non-interactive use. Report the loop ids it prints, then stop — the rest happens in the background.

Mode A — Live (this session)

Loop until the PR is merged or a hard blocker needs a human. Each iteration:

1. Snapshot the live state (never act on stale data)
bash
gh pr view <num> --json state,isDraft,mergeable,mergeStateStatus,reviewDecision,statusCheckRollup,headRefOid

List unresolved review threads:

bash
gh api graphql -f query='
query($owner:String!,$repo:String!,$num:Int!){
  repository(owner:$owner,name:$repo){ pullRequest(number:$num){
    reviewThreads(first:100){ nodes{ id isResolved
      comments(first:20){ nodes{ author{login} body path line } } } } } }
}' -F owner=<owner> -F repo=<repo> -F num=<num> \
  --jq '.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved==false)
        | {id, file:.comments.nodes[0].path, line:.comments.nodes[0].line, body:.comments.nodes[-1].body, author:.comments.nodes[0].author.login}'

Pick the iteration's action:

  • state==MERGED → done. state==CLOSED → stop, tell the user.
  • actionable unresolved threads → 2.
  • none, reviewDecision==APPROVED, all required checks SUCCESS, mergeable==MERGEABLE → 4.
  • else (CI pending / awaiting re-review) → 5.
2. Fix each actionable thread

Make the change (scoped to what the thread asks — don't rewrite unrelated code), run quick tests/linters, then:

bash
git add -A && git commit -m "fix: <addresses review comment>"
git push        # if rejected non-fast-forward: git pull --rebase && git push. Never --force.
3. Reply, then resolve — or dismiss

Reply with how you fixed it, then resolve:

bash
# reply
gh api graphql -f query='mutation($t:ID!,$b:String!){addPullRequestReviewThreadReply(input:{pullRequestReviewThreadId:$t,body:$b}){comment{id}}}' -F t=<threadId> -F b="Fixed in <sha>: <summary>."
# resolve
gh api graphql -f query='mutation($t:ID!){resolveReviewThread(input:{threadId:$t}){thread{isResolved}}}' -F t=<threadId>

For a change request you can justify as incorrect or out of scope: reply with your reasoning first, then dismiss it (message is mandatory — state why):

bash
# get the CHANGES_REQUESTED review's node id (PRR_…)
gh api graphql -f query='query($o:String!,$r:String!,$n:Int!){repository(owner:$o,name:$r){pullRequest(number:$n){reviews(first:50){nodes{id state author{login}}}}}}' -F o=<owner> -F r=<repo> -F n=<num> --jq '.data.repository.pullRequest.reviews.nodes[]|select(.state=="CHANGES_REQUESTED")'
# dismiss with a reason
gh api graphql -f query='mutation($id:ID!,$m:String!){dismissPullRequestReview(input:{pullRequestReviewId:$id,message:$m}){pullRequestReview{state}}}' -F id=<reviewNodeId> -F m="Dismissing: <why this change request is wrong/out of scope>."
3b. Re-request the reviewer after pushing a new head

GitHub does not auto-re-request a reviewer when you push fixes — their CHANGES_REQUESTED stays on the record, the PR keeps showing as blocked even though you addressed everything, and the reviewer gets no notification that there's a new head to look at. So after pushing fixes that address a reviewer's change request, re-request them:

bash
# for each reviewer whose requested changes this push addresses
gh pr edit <num> --add-reviewer <login>

This is what flips a stale CHANGES_REQUESTED back into an active review request and notifies the reviewer. Skip only if they already re-reviewed the current head.

Show full SKILL.md (344 more words)Show less
4. Merge when approved and green

Only when reviewDecision==APPROVED, every required check is SUCCESS (none pending/failing), mergeable==MERGEABLE, and not a draft:

bash
gh pr merge <num> --squash --delete-branch     # use --merge/--rebase to match repo convention
# or: gh pr merge <num> --squash --auto         # let GitHub merge as soon as requirements are met

Then report and stop.

5. Wait, then re-loop

Poll on an interval instead of spinning. Use your agent's own loop/scheduler if it has one:

  • Claude Code: /loop 5m <this instruction>, or schedule a wake-up; idle between ticks.
  • Codex / opencode / Gemini / others: re-run this instruction on a timer, or iterate with a sleep 180 between checks.

Safety rails (apply even in full-auto)

  • Never merge with a failing or pending required check. Green-and-approved is the only gate. Never --admin-bypass.
  • Never force-push, rewrite others' commits, or delete the base branch.
  • Dismiss only with a written reason. If you can't articulate why a change request is wrong, treat it as valid and fix it.
  • Stop and ask a human when: someone says "hold" / "do not merge" / adds a hold label; a fix needs a product or design decision; the same thread reopens after 2 fix attempts; or a merge conflict needs real judgement.
  • Cap no-progress loops: after N iterations with no new commit and no state change, stop and summarize the blocker.

More detail

Extended gh / GraphQL recipes: references/github-commands.md (when installed as a skill), or fetch https://raw.githubusercontent.com/nexu-io/looper/main/skills/pr-takeover/references/github-commands.md.

One universal prompt (for a bot to post under a PR)

Works in any agent, with or without this skill installed — it just points the agent at this file:

Take over this PR until it merges — read https://raw.githubusercontent.com/nexu-io/looper/main/skills/pr-takeover/SKILL.md and follow it.

If your agent can't fetch URLs, paste this instead:

Take over this PR until it merges. Loop: read the open review threads (gh), fix what they ask and push, re-request the reviewer after each push (GitHub won't auto-re-request, so the reviewer won't otherwise know there's a new head), reply + resolve each thread, dismiss any change request you can justify as wrong (with a written reason), and merge once it's approved and all required checks are green. Never merge on red/pending checks, never force-push, and stop to ask me if someone says hold or a fix needs a product decision.

© nexu-io, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in skills/pr-takeover of nexu-io/looper.

  • SKILL.md
  • references/github-commands.md

Open the folder on GitHubat commit 6abd8ff

Compare with similar skills

PR Takeover next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

PR Takeover compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
PR Takeover this skillnexu-io/looper133—~2.3kAutomated safety check: PassMIT
Contributor-First PR MergeHKUDS/OpenHarness16k1 repos~847Automated safety check: PassMIT
Create Pull Requestcline/cline70k1 repos~1.6kAutomated safety check: PassApache-2.0
Pull Request Title and Body Writeropeninterpreter/openinterpreter69k2 repos~1.1kAutomated safety check: PassApache-2.0
PR Review State Fetchprisma/orm48k—~767Automated safety check: PassApache-2.0
Create Pull Request with Work Item IDmakeplane/plane61k—~824Automated safety check: PassAGPL-3.0

Similar skills

  • Contributor-First PR Merge

    HKUDS/OpenHarness

    Merges external GitHub pull requests while keeping the original author credited, and fixes conflicts after the merge instead of rewriting the contribution.

    16k GitHub starsUsed in 1 repo~847 tokens
    DevelopmentAuto-check passed

  • Create Pull Request

    cline/cline

    Opens a GitHub pull request from your current branch with the gh CLI, after reviewing the commits and diff and gathering the details the PR needs.

    70k GitHub starsUsed in 1 repo~1.6k tokens
    DevelopmentAuto-check passed

  • Pull Request Title and Body Writer

    openinterpreter/openinterpreter

    Rewrites the title and body of one or more pull requests with gh, leading with why the change was made, then what changed, and describing only the net result.

    69k GitHub starsUsed in 2 repos~1.1k tokens
    DevelopmentAuto-check passed

  • PR Review State Fetch

    prisma/orm

    Official

    Fetches a pull request's canonical review state as JSON, validates it, and renders markdown, a text summary and triage target files from it using bundled scripts.

    48k GitHub stars~767 tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Create Pull Request with Work Item ID

    makeplane/plane

    Opens a pull request for the current branch using the repo's template, a work item ID in the title and a description filled in from the actual diff.

    61k GitHub stars~824 tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Creating Description For Gh PR

    redis/jedis

    Official

    Generate a clear, concise GitHub PR title and description from the diff between two local git branches, and save it to prDescription.md in the repo root.

    12k GitHub stars~838 tokensUpdated today
    DevelopmentAuto-check passed

More from nexu-io/looper

  • Looper Review

    nexu-io/looper

    Default Looper review method for implementation and spec PRs.

    133 GitHub stars~722 tokensUpdated 4 days ago
    Auto-check passed

Works with

Categories

Questions about PR Takeover

What does PR Takeover do?

A skill your agent uses when asked to take over, adopt, or babysit a GitHub pull request until it merges — read review feedback, fix it, resolve threads, dismiss unreasonable change requests, and…. PR Takeover is an agent skill from nexu-io/looper. Use when asked to take over, adopt, or babysit a GitHub pull request until it merges — read review feedback, fix it, resolve threads, dismiss unreasonable change requests, and merge once approved and green.

When should I use PR Takeover?

PR Takeover fits situations like: asked to take over; babysit a GitHub pull request until it merges — read review feedback; resolve threads; dismiss unreasonable change requests.

How do I install PR Takeover in Claude Code?

Run `npx skills add nexu-io/looper --skill pr-takeover -a claude-code`. Or copy the skill folder (skills/pr-takeover in nexu-io/looper) into .claude/skills/pr-takeover in your project. Claude Code loads it when a task matches its description.

How do I install PR Takeover in Codex?

Run `npx skills add nexu-io/looper --skill pr-takeover -a codex`. Or copy the skill folder (skills/pr-takeover in nexu-io/looper) into .agents/skills/pr-takeover in your project. Codex loads it when a task matches its description.

Can I use PR Takeover in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add nexu-io/looper --skill pr-takeover -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/pr-takeover, .gemini/skills/pr-takeover, .github/skills/pr-takeover and .opencode/skills/pr-takeover in your project.

What does PR Takeover need to run?

Going by SKILL.md and its folder, PR Takeover needs the command-line tools its instructions call (gh and git).

Does PR Takeover access the network?

SKILL.md contains no URLs. Its commands use gh and git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is PR Takeover safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does PR Takeover use?

PR Takeover is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does PR Takeover use?

About 2.3k tokens (SKILL.md is roughly 9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.2k tokens, read only when the agent opens those files.

What are the alternatives to PR Takeover?

Skills that share tags, products or a category with PR Takeover: Contributor-First PR Merge (HKUDS/OpenHarness, 16k stars), Create Pull Request (cline/cline, 70k stars), Pull Request Title and Body Writer (openinterpreter/openinterpreter, 69k stars) and PR Review State Fetch (prisma/orm, 48k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains PR Takeover?

nexu-io (a GitHub organization) maintains it in nexu-io/looper, which has 133 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on October 6, 2026.

Source: nexu-io/looper on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.