AutoGineer
Generated banner for Iterate Pr
Generated logo for Iterate Pr

Iterate Pr

SentryOfficialPublished by Sentry

  • Skill
  • Workflow
  • Software development
  • Apache-2.0
  • Low risk
  • Has scripts
Download ZIP

From the author

Iterate on a PR until actionable CI passes and high/medium review feedback is addressed. Use for PR CI failures, review feedback, or green-check loops; do not wait for human approval, draft status, or merge gates.
— the description by Sentry

AutoGineer summary

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

The iterate-pr skill provides a structured workflow for managing pull requests by automatically monitoring CI status and review feedback. It guides an agent to identify actionable failures, apply fixes, and verify changes locally before pushing updates. The process focuses on resolving high and medium priority issues while intelligently handling low-priority feedback and ignoring non-actionable gates like human approvals or draft status.

What it does

  • Fetches and categorizes PR feedback into high, medium, and low priority buckets.
  • Monitors CI check status to distinguish between actionable failures and pending gates.
  • Provides a systematic loop for fixing root causes of CI failures and pushing updates.
  • Handles low-priority feedback by prompting the user for guidance.
  • Uses specialized scripts to interact with PR metadata, checks, and review threads.
  • Includes fallback procedures using standard CLI tools if automated scripts encounter errors.

When to use it

  • When a PR has failed CI checks that require code adjustments.
  • When there is high or medium priority review feedback that needs to be addressed.
  • To automate the repetitive cycle of fixing, testing, and pushing code to a PR.
  • When you need to ensure a PR is clean and ready for human review without manual intervention.

Advantages

  • Reduces manual overhead in the PR feedback and CI repair loop.
  • Ensures consistent handling of feedback priorities.
  • Focuses on root cause resolution rather than symptomatic fixes.
  • Integrates seamlessly with existing CI/CD workflows and GitHub CLI.

Usage examples

“Iterate on PR #123 until all CI checks pass.”
The agent will fetch the PR status, identify failed checks, apply necessary fixes, and continue looping until all actionable CI failures are resolved.
“Address the high and medium feedback on my current PR.”
The agent will retrieve the review comments, categorize them, and systematically apply fixes for all high and medium priority items.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/getsentry/iterate-pr/download

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

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

Documentation by Sentry

Iterate on PR Until CI Passes

Goal: fix actionable CI failures and high/medium review feedback. Stop and report human approval, draft-readiness, and merge-readiness gates.

Requires:

  • authenticated gh

  • uv

  • target repository root as cwd

  • skill-root-relative script paths, for example scripts/fetch_pr_checks.py

Bundled Scripts

ScriptRunOutput
scripts/fetch_pr_checks.pyuv run scripts/fetch_pr_checks.py [--pr NUMBER]JSON: pr, summary, checks, failure snippets
scripts/fetch_pr_feedback.pyuv run scripts/fetch_pr_feedback.py [--pr NUMBER]JSON buckets: high, medium, low, bot, resolved
scripts/monitor_pr_checks.pyuv run scripts/monitor_pr_checks.py [--pr NUMBER]terminal marker plus tab-separated checks
scripts/reply_to_thread.pyuv run scripts/reply_to_thread.py THREAD_ID BODY [...]JSON reply results

Check summary fields include failed, pending, actionable_pending, and human_gate_pending.

Monitor markers:

  • ALL_CHECKS_PASSED

  • CHECKS_DONE_WITH_FAILURES

  • NO_CHECKS_REGISTERED

  • DRAFT_PR_WITH_NO_CHECKS

  • CHECKS_BLOCKED_BY_REVIEW_GATE

Workflow

1. Identify PR

Run:

gh pr view --json number,url,headRefName,isDraft,reviewDecision

Stop when:

  • no PR exists

  • draft PR has no checks after monitor grace period: report DRAFT_PR_WITH_NO_CHECKS

Draft rule: inspect existing checks/feedback only. Do not mark ready for review unless asked.

2. Handle Feedback

Run uv run scripts/fetch_pr_feedback.py [--pr NUMBER].

BucketAction
highfix
mediumfix
lowask user which to address
botskip informational comments
resolvedskip

Feedback fix checklist:

  • verify root cause

  • search related code

  • fix all instances

  • for review_bot: true: fix real issues, explain false positives

Low-priority prompt format:

Found 3 low-priority suggestions:
1. [l] "Consider renaming this variable" - @reviewer in api.py:42
2. [nit] "Could use a list comprehension" - @reviewer in utils.py:18
3. [style] "Add a docstring" - @reviewer in models.py:55

Which should I address? ("1,3", "all", or "none")
3. Check CI Status

Run uv run scripts/fetch_pr_checks.py [--pr NUMBER].

StateAction
failed > 0 and actionable_pending == 0fix failures
actionable_pending > 0wait; poll feedback while waiting
pending > 0 and actionable_pending == 0report CHECKS_BLOCKED_BY_REVIEW_GATE
no checks after grace periodreport NO_CHECKS_REGISTERED or DRAFT_PR_WITH_NO_CHECKS
all actionable checks passedrun post-CI feedback check

Wait for actionable review bots: sentry, warden, cursor, bugbot, seer, codeql. Do not wait for approval, isDraft, REVIEW_REQUIRED, Codecov, or informational bots.

4. Fix CI Failures

For each failure:

  1. read full log: gh run view <run-id> --log-failed

  2. trace from assertion/exception/lint rule to source

  3. state the cause before editing: "fails because X, affected by Y"

  4. search related call sites/patterns

  5. fix root cause, not symptom

  6. add focused test coverage when needed

5. Verify Locally, Then Commit and Push

Before commit:

  • test fix: rerun specific test

  • lint/type fix: rerun affected checker

  • code fix: rerun covering tests

  • local failure: fix before pushing

git add <files>
git commit -m "fix: <descriptive message>"
git push
6. Monitor CI and Address Feedback

Loop:

  1. run uv run scripts/fetch_pr_checks.py

  2. handle table in step 3

  3. while actionable_pending > 0, run uv run scripts/fetch_pr_feedback.py

  4. fix new high/medium feedback immediately

  5. if changed, verify, commit, push, restart loop

  6. otherwise sleep 30 seconds and repeat

  7. after checks pass, wait 10 seconds, fetch feedback once more

  8. if new high/medium feedback exists, return to step 4

Claude Code optional: run uv run scripts/monitor_pr_checks.py through MonitorTool with persistent: false; set timeout to normal repo CI duration. Restart the monitor after every push.

Exit Conditions

ExitConditions
Successactionable CI passed; post-CI feedback clean; low-priority choice handled
Ask usersame failure after 2 attempts; feedback unclear; infrastructure issue
Stopno PR; branch needs rebase; no checks; draft no-checks; only human gates remain

Fallback

If scripts fail, use gh CLI directly:

  • gh pr view --json number,url,headRefName,isDraft,reviewDecision

  • gh pr checks --json name,state,bucket,description,link

  • gh run view <run-id> --log-failed

  • gh api repos/{owner}/{repo}/pulls/{number}/comments

Files

SPEC.md

Iterate PR Specification

Intent

The iterate-pr skill drives a pull request through actionable CI failures and actionable review feedback until the work is locally fixed, pushed, and rechecked.

Its purpose is CI and feedback iteration, not merge readiness. It must not wait indefinitely for human approvals, required review decisions, draft PR state changes, or other gates that an agent cannot resolve by editing code.

Scope

In scope:

  • Identifying the PR for the current branch.

  • Fetching and categorizing PR review feedback.

  • Fixing high and medium priority review feedback.

  • Asking the user which low priority suggestions to address.

  • Fetching CI checks, failed logs, and failure snippets.

  • Fixing CI failures with local verification before pushing.

  • Monitoring checks until they pass, fail, or reach a non-actionable stop state.

  • Reporting draft/no-checks and human review/approval gates without polling forever.

Out of scope:

  • Waiting for or requesting human approval.

  • Marking draft PRs ready for review unless the user explicitly asks.

  • Merging PRs.

  • Rebasing branches without user direction.

  • Treating Codecov, Dependabot, or other informational comments as review feedback.

Users And Trigger Context

  • Primary users: engineers and coding agents iterating on existing pull requests.

  • Invocation: model-invocable in Claude Code and Codex when the request or current PR state matches this skill's trigger context.

  • Common user requests: fix CI on this PR, iterate on this PR until checks pass, address PR feedback, keep pushing fixes until green.

  • Should not trigger for: creating a PR, writing commits without a PR, reviewing unrelated code, or monitoring merge approval state only.

Runtime Contract

  • Required first actions: resolve the current PR, read isDraft and reviewDecision, fetch current review feedback, and fetch current CI state before editing.

  • Required outputs: concise progress updates, commits and pushes when fixes are made, and a final state that distinguishes passing CI from non-actionable review/draft/approval gates.

  • Non-negotiable constraints: investigate failures before editing, verify locally before pushing, do not push known-broken fixes, do not wait for human approval, and do not treat draft PRs with no checks as pending forever.

  • Expected bundled files loaded at runtime: SKILL.md and, when needed, scripts under scripts/.

Source And Evidence Model

Authoritative sources:

  • GitHub CLI PR and checks output.

  • Sentry LOGAF review guidance.

  • Repository-level agent instructions.

  • Bundled script behavior documented in SKILL.md.

Useful improvement sources:

  • positive examples: PRs where CI failures were fixed and checks passed after the loop.

  • negative examples: PRs where the agent waited on draft status, required review, or approval gates.

  • issue or PR feedback: reviewer comments about missing fixes, false positives, or feedback categorization.

  • validation results: structural skill validation and script syntax checks.

Data that must not be stored:

  • secrets

  • customer data

  • private URLs or identifiers not needed for reproduction

  • full CI logs when small failure snippets are enough

Reference Architecture

  • SKILL.md contains the runtime workflow, script contracts, feedback handling rules, CI loop, and exit conditions.

  • SPEC.md contains this maintenance contract.

  • references/ contains no files currently; add focused troubleshooting or evidence references only if runtime guidance becomes noisy.

  • references/evidence/ contains no files currently; use it for durable positive or negative PR-loop examples if regressions recur.

  • scripts/ contains non-interactive helpers for PR checks, PR feedback, check monitoring, and review-thread replies.

  • assets/ contains no files currently.

Validation

  • Lightweight validation: run uv run skills/skill-writer/scripts/quick_validate.py skills/iterate-pr.

  • Script validation: run uv run -m py_compile skills/iterate-pr/scripts/*.py after script changes.

  • Holdout examples: include a draft PR with no registered checks, a PR with reviewDecision: REVIEW_REQUIRED but passing checks, a PR with an actionable pending CI bot check, and a PR with failed CI logs.

  • Acceptance gates: validator passes, scripts compile, draft/no-check states terminate with a report, human review gates are not treated as actionable pending CI, and actionable CI failures still route back to investigation and fixes.

Known Limitations

  • Human-gate detection depends on check names, states, and descriptions exposed by GitHub or CI integrations.

  • Some repositories may intentionally model deployment or approval workflows as status checks; this skill reports those as blocked/non-actionable unless the user asks to manage that gate.

  • The helper scripts use GitHub CLI output and can drift if gh pr checks changes its JSON schema.

Maintenance Notes

  • Update SKILL.md when the runtime loop, script contracts, feedback policy, or exit conditions change.

  • Update SPEC.md when the skill's scope, validation expectations, or non-actionable gate policy changes.

  • Add focused reference files only when repeated troubleshooting guidance would make SKILL.md hard to scan.

  • Keep public inventories pointed at the canonical skills/iterate-pr skill, not mirrors or aliases.

Requirements and compatibility

Written for: Claude Code

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.

Needs: Claude Code frontmatter, Needs a command-line tool, Needs Python

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

Published by
Sentry
Publisher
Sentry (Official)
Source
getsentry/skills · skills/iterate-pr · commit e94f222
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Sentry.

Download ZIP

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