Skip to main content
command CX Codex

ship-ci-review-loop — Claude Code command: setup and features

ship-ci-review-loop automates the CI and code review monitoring loop for pull requests. It polls GitHub checks, waits for bot reviews, and resolves feedback before merging.

MIT ★ 2,003 updated 2026-07-26

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add composio-community/awesome-claude-plugins
/plugin install ship@awesome-claude-plugins
Open on GitHub

What ship-ci-review-loop does

This command implements phase 4 of the /ship workflow. It checks CI status by polling gh pr checks every 15 seconds until all checks finish. On the first run, the loop pauses for 3 minutes so external review bots like CodeRabbit or Copilot can finish posting comments.

The monitor loop runs up to 10 iterations with a 30-second interval. It inspects PR state using gh api graphql and filters responses with jq to track unresolved threads and change requests. Claude Code then applies fixes, commits the updates, and repeats the loop until zero unresolved conversations remain.

Without gh and jq installed and authenticated in your terminal, the bash monitor functions fail immediately.

What it helps with

  • wait for GitHub CI check runs to pass
  • fetch unresolved review threads via GraphQL
  • handle code review comments from automated bots
  • push iterative fixes until all review threads are resolved

Example prompts for the agent

  • Run ship-ci-review-loop on the current pull request
  • Check PR #12 for unresolved review comments and apply fixes
  • Wait for CI checks and resolve remaining review threads

How to install ship-ci-review-loop

1Plugin marketplace

/plugin marketplace add composio-community/awesome-claude-plugins
/plugin install ship@awesome-claude-plugins

2Manually: put the files in place

.claude/commands/ship-ci-review-loop.md

Call it with /ship-ci-review-loop. For all projects use ~/.claude/commands/

Questions about ship-ci-review-loop

How to install ship-ci-review-loop in Claude Code?

Run /plugin marketplace add composio-community/awesome-claude-plugins to add the marketplace. Then install the command with /plugin install ship@awesome-claude-plugins. You can also configure it manually by adding .claude/commands/ship-ci-review-loop.md to your repository.

What does ship-ci-review-loop do?

It runs an iterative monitor loop that waits for CI checks to pass and ensures every review comment is addressed. The execution stops after at most 10 iterations and enforces a 3-minute initial wait for automated review bots.

Which dependencies must be installed?

The underlying monitor functions rely on gh (GitHub CLI) and jq. The GitHub CLI must have active repository access to execute gh pr checks and GraphQL queries.

Source text

ship-ci-review-loop.md · MIT
<ci-review-loop>
# Phase 4: CI & Review Monitor Loop - Reference

This file contains detailed implementation for the CI & Review Monitor Loop phase of `/ship`.

**Parent document**: `ship.md`

---

<mandatory-requirements>
## This Phase Is Mandatory

This is not optional. You must:
1. Wait the full 3 minutes for auto-reviewers
2. Run the monitor loop (not just check once)
3. Address all comments before merge
</mandatory-requirements>

---

<pr-auto-review>
## PR Auto-Review Process

PRs receive automatic reviews from configured auto-reviewers (Copilot, Gemini, CodeRabbit, etc.).

**Mandatory workflow:**
1. After PR creation, wait **at least 3 minutes** for first review round
2. Read **all comments** from all reviewers
3. Address **every comment** - no exceptions
4. Iterate until **zero unresolved threads** (typically 2-4 rounds)

**Rules:**
- Always address all comments, including "minor" or "nit" suggestions
- Do not skip a comment unless factually wrong or user-approved
- Treat all feedback as **required changes**, not suggestions
</pr-auto-review>

---

<overview>
## Overview

The monitor loop must wait for:
1. CI to pass
2. All comments resolved (addressed or replied to)
3. No "changes requested" reviews remain

## Why All Comments Matter

**Every comment must be addressed:**
- Critical/High issues: Fix immediately
- Medium issues: Fix (don't defer)
- Minor/Nit issues: Fix (shows attention to quality)
- Style suggestions: Fix (maintains codebase consistency)
- Questions: Answer with explanation
- False positives: Reply explaining why, then resolve
- Not relevant: Reply explaining why, then resolve

Do not ignore comments. Do not leave comments unresolved. A clean PR has zero unresolved conversations.
</overview>

## The Monitor Loop Algorithm

> **Note:** The JavaScript below is **conceptual pseudocode** showing the algorithm flow.
> Implement using bash functions defined in this file.

```javascript
const MAX_ITERATIONS = 10;  // Safety limit
const INITIAL_WAIT_MS = 180000;  // 3 minutes - wait for auto-reviews
const ITERATION_WAIT_MS = 30000;  // 30 seconds between iterations
let iteration = 0;

while (iteration < MAX_ITERATIONS) {
  iteration++;
  console.log(`\n## CI & Review Monitor - Iteration ${iteration}`);

  // Step 1: Wait for CI to complete
  const ciStatus = await waitForCI();
  if (ciStatus === 'failed') {
    await fixCIFailures();
    continue;  // Push fix, re-run CI
  }

  // Step 1.5: First iteration only - wait for auto-reviews
  if (iteration === 1) {
    console.log("Waiting 3 minutes for auto-reviews...");
    await sleep(INITIAL_WAIT_MS);
  }

  // Step 2: Check for PR comments and reviews
  const feedback = await checkPRFeedback();

  if (feedback.unresolvedCount === 0 && !feedback.changesRequested) {
    console.log("[OK] CI passed, all comments resolved");
    break;  // Ready to merge!
  }

  // Step 3: Address ALL feedback
  await addressAllFeedback(PR_NUMBER);

  // Step 4: Push fixes
  if (feedback.hasCodeChanges) {
    await commitAndPush(`fix: address review feedback (iteration ${iteration})`);
  }

  // Step 5: Sleep before next check
  await sleep(ITERATION_WAIT_MS);
}
```

## Step 1: Wait for CI

```bash
wait_for_ci() {
  echo "Waiting for CI checks..."

  while true; do
    CHECKS=$(gh pr checks $PR_NUMBER --json name,state 2>/dev/null || echo "[]")

    PENDING=$(echo "$CHECKS" | jq '[.[] | select(.state | IN("PENDING", "QUEUED", "IN_PROGRESS"))] | length')
    FAILED=$(echo "$CHECKS" | jq '[.[] | select(.state | IN("FAILURE", "CANCELLED"))] | length')
    PASSED=$(echo "$CHECKS" | jq '[.[] | select(.state=="SUCCESS")] | length')

    if [ "$FAILED" -gt 0 ]; then
      echo "[ERROR] CI failed ($FAILED checks)"
      gh pr checks $PR_NUMBER
      return 1
    elif [ "$PENDING" -eq 0 ] && [ "$PASSED" -gt 0 ]; then
      echo "[OK] CI passed ($PASSED checks)"
      return 0
    elif [ "$PENDING" -eq 0 ] && [ "$PASSED" -eq 0 ]; then
      echo "[WARN] No CI checks found, proceeding..."
      return 0
    fi

    echo "  Waiting... ($PENDING pending, $PASSED passed)"
    sleep 15
  done
}
```

## Step 2: Check PR Feedback

```bash
check_pr_feedback() {
  local pr_number=$1

  echo "Checking PR feedback..."

  # Extract owner and repo from git remote
  REPO_INFO=$(gh repo view --json owner,name --jq '"\(.owner.login)/\(.name)"')
  OWNER=$(echo "$REPO_INFO" | cut -d'/' -f1)
  REPO=$(echo "$REPO_INFO" | cut -d'/' -f2)

  # Get review state
  REVIEWS=$(gh pr view $pr_number --json reviews --jq '.reviews')
  CHANGES_REQUESTED=$(echo "$REVIEWS" | jq '[.[] | select(.state=="CHANGES_REQUESTED")] | length')

  # Get unresolved review threads
  # NOTE: Fetches first 100 threads. For PRs with >100 threads, implement pagination.
  UNRESOLVED_THREADS=$(gh api graphql -f query='
    query($owner: String!, $repo: String!, $pr: Int!) {
      repository(owner: $owner, name: $repo) {
        pullRequest(number: $pr) {
          reviewThreads(first: 100) {
            nodes {
              isResolved
            }
          }
        }
      }
    }
  ' -f owner="$OWNER" -f repo="$REPO" -F pr=$pr_number \
    --jq '[.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved == false)] | length')

  echo "  Unresolved threads: $UNRESOLVED_THREADS"
  echo "  Changes requested: $CHANGES_REQUESTED"

  echo "{\"unresolvedThreads\": $UNRESOLVED_THREADS, \"changesRequested\": $CHANGES_REQUESTED}"
}
```

### Get Full Thread Details

```bash
get_unresolved_threads() {
  local pr_number=$1

  REPO_INFO=$(gh repo view --json owner,name --jq '"\(.owner.login)/\(.name)"')
  OWNER=$(echo "$REPO_INFO" | cut -d'/' -f1)
  REPO=$(echo "$REPO_INFO" | cut -d'/' -f2)

  # NOTE: Fetches first 100 threads. For PRs with >100, implement pagination.
  gh api graphql -f query='
    query($owner: String!, $repo: String!, $pr: Int!) {
      repository(owner: $owner, name: $repo) {
        pullRequest(number: $pr) {
          reviewThreads(first: 100) {
            nodes {
              id
              isResolved
              path
              line
              diffHunk
              comments(first: 1) {
                nodes {
                  id
                  body
                }
              }
            }
          }
        }
      }
    }
  ' -f owner="$OWNER" -f repo="$REPO" -F pr=$pr_number \
    --jq '.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved == false)'
}
```

## Step 3: Address ALL Feedback

> **Note:** This is **conceptual pseudocode** showing the algorithm flow.
> Implement using: gh api, Read, Edit, Task (ci-fixer), etc.

```javascript
async function addressAllFeedback(prNumber) {
  const threads = await getUnresolvedThreads(prNumber);

  console.log(`\nAddressing ${threads.length} unresolved threads...`);

  for (const thread of threads) {
    console.log(`\n--- Thread: ${thread.path}:${thread.line} ---`);
    const analysis = analyzeComment(thread);

    switch (analysis.type) {
      case 'code_fix_required':
        console.log(`Action: Fixing code issue`);
        await implementFix(thread);  // Use Task(ci-fixer) or Edit tool
        break;

      case 'style_suggestion':
        console.log(`Action: Applying style fix`);
        await implementFix(thread);
        break;

      case 'question':
        console.log(`Action: Answering question`);
        await replyToComment(prNumber, thread.commentId, generateAnswer(thread));
        await resolveThread(thread.id);
        break;

      case 'false_positive':
        console.log(`Action: Explaining false positive`);
        await replyToComment(prNumber, thread.commentId,
          `This is a false positive because: ${analysis.reason}\n\n` +
          `Resolving. Please reopen if you disagree.`
        );
        await resolveThread(thread.id);
        break;

      case 'not_relevant':
        console.log(`Action: Explaining out of scope`);
        await replyToComment(prNumber, thread.commentId,
          `Outside scope of this PR: ${analysis.reason}\n\n` +
          `Resolving. Please reopen if needed.`
        );
        await resolveThread(thread.id);
        break;

      case 'already_addressed':
        console.log(`Action: Confirming addressed`);
        await replyToComment(prNumber, thread.commentId,
          `Addressed in commit ${gitRevParseHead}.`
        );
        await resolveThread(thread.id);
        break;
    }
  }

  // Request re-review from those who requested changes
  const changesRequestedReviews = await getChangesRequestedReviews(prNumber);
  for (const review of changesRequestedReviews) {
    await requestReReview(prNumber, review.author);
  }
}
```

## Comment Analysis Heuristics

> **Note:** Classification heuristics for comment handling.

```javascript
function analyzeComment(thread) {
  const body = thread.body.toLowerCase();

  // Question patterns
  if (body.includes('?') || body.startsWith('why') || body.startsWith('how') ||
      body.startsWith('what') || body.startsWith('could you explain')) {
    return { type: 'question', reason: 'Comment is a question' };
  }

  // Style/nit patterns
  if (body.includes('nit:') || body.includes('nitpick') || body.includes('minor:') ||
      body.includes('style:') || body.includes('consider') || body.includes('optional')) {
    return { type: 'style_suggestion', reason: 'Style or minor suggestion' };
  }

  // Out of scope patterns
  if (!thread.diffHunk || commentRefersToUnchangedCode(thread)) {
    return { type: 'not_relevant', reason: 'Comment refers to unchanged code' };
  }

  // Default: treat as code fix required
  return { type: 'code_fix_required', reason: 'Valid code feedback' };
}
```

## Implementing Fixes

Use the ci-fixer agent for code changes:

```javascript
Task({
  subagent_type: "next-task:ci-fixer",
  prompt: `Fix the following review comment:

**File**: ${thread.path}
**Line**: ${thread.line}
**Comment**: ${thread.body}
**Code Context**:
\`\`\`
${thread.diffHunk}
\`\`\`

Requirements:
1. Make the minimal change to address the feedback
2. Do NOT over-engineer or add unrelated changes
3. Ensure tests still pass after the fix`
});
```

## Resolving Threads

```bash
resolve_thread() {
  local thread_id=$1

  gh api graphql -f query='
    mutation($threadId: ID!) {
      resolveReviewThread(input: {threadId: $threadId}) {
        thread {
          isResolved
        }
      }
    }
  ' -f threadId="$thread_id"
}

reply_to_comment() {
  local pr_number=$1
  local comment_id=$2
  local body=$3

  REPO_INFO=$(gh repo view --json owner,name --jq '"\(.owner.login)/\(.name)"')
  OWNER=$(echo "$REPO_INFO" | cut -d'/' -f1)
  REPO=$(echo "$REPO_INFO" | cut -d'/' -f2)

  gh api -X POST "repos/$OWNER/$REPO/pulls/$pr_number/comments" \
    -f body="$body" \
    -F in_reply_to="$comment_id"
}
```

## Step 4: Commit and Push

```bash
commit_and_push_fixes() {
  local message=$1
  local branch=${2:-$(git branch --show-current)}

  if [ -n "$(git status --porcelain)" ]; then
    git add -A
    git commit -m "$message"
    git push origin "$branch"
    echo "[OK] Pushed fixes"
    return 0
  else
    echo "No code changes to commit (only comment replies)"
    return 1
  fi
}
```

## Complete Loop Script

```bash
#!/bin/bash
# Phase 4: CI & Review Monitor Loop

MAX_ITERATIONS=10
INITIAL_WAIT=${SHIP_INITIAL_WAIT:-180}  # Configurable via env var
ITERATION_WAIT=30
iteration=0

while [ $iteration -lt $MAX_ITERATIONS ]; do
  iteration=$((iteration + 1))
  echo "[CI Monitor] Iteration $iteration"

  # Step 1: Wait for CI
  if ! wait_for_ci; then
    echo "CI failed - launching ci-fixer agent..."
    continue
  fi

  # Step 1.5: First iteration - wait for auto-reviews
  if [ $iteration -eq 1 ] && [ "$INITIAL_WAIT" -gt 0 ]; then
    echo "First iteration - waiting ${INITIAL_WAIT}s for auto-reviews..."
    sleep $INITIAL_WAIT
  fi

  # Step 2: Check feedback
  FEEDBACK=$(check_pr_feedback $PR_NUMBER)
  UNRESOLVED=$(echo "$FEEDBACK" | jq -r '.unresolvedThreads')
  CHANGES_REQ=$(echo "$FEEDBACK" | jq -r '.changesRequested')

  if [ "$UNRESOLVED" -eq 0 ] && [ "$CHANGES_REQ" -eq 0 ]; then
    echo "[OK] ALL CHECKS PASSED"
    echo "[OK] ALL COMMENTS RESOLVED"
    echo "Ready to merge!"
    break
  fi

  # Step 3: Address all feedback
  echo "Addressing $UNRESOLVED unresolved threads..."

  # Step 4: Commit and push
  commit_and_push_fixes "fix: address review feedback (iteration $iteration)"

  # Step 5: Wait before next iteration
  echo "Waiting ${ITERATION_WAIT}s..."
  sleep $ITERATION_WAIT
done

if [ $iteration -ge $MAX_ITERATIONS ]; then
  echo "[ERROR] Max iterations reached - manual intervention required"
  exit 1
fi
```

<iteration-summary>
## Iteration Summary Output

```markdown
## Iteration ${iteration} Summary

**CI Status**: [OK] Passed
**Comments Addressed**: ${addressedCount}
  - Code fixes: ${codeFixCount}
  - Answered questions: ${questionCount}
  - Resolved as not applicable: ${notApplicableCount}
**Remaining Unresolved**: ${remainingCount}

${remainingCount > 0 ? 'Continuing...' : 'Ready to merge!'}
```
</iteration-summary>
</ci-review-loop>

© Community · MIT · composio-community/awesome-claude-plugins

Similar slash commands

All slash commands for Code review and refactoring →

From the same set68

The whole set →
help help prints skill-bus status plus its slash-command list. Add advanced to get the longer reference on settings and conditions. CX Codex +1 ★ 2,003repo stars onboard The onboard command for Claude Code configures skill-bus by discovering repository documents, routing them to skills through subscriptions, and enabling local telemetry. CX Codex +1 ★ 2,003repo stars perf-orchestrator perf-orchestrator coordinates performance investigations from baseline measurements through profiling and validation. Keeps each phase sequential and logged. CX Codex ★ 2,003repo stars audit-project-agents audit-project-agents sends a whole codebase to specialised review agents, each on its own slice of files, and collects their findings in one queue. CX Codex +1 ★ 2,003repo stars ship ship runs a commit-to-production workflow with pull requests, CI checks, review monitoring, merge, deployment, and validation. CX Codex +1 ★ 2,003repo stars perf Runs a performance investigation in phases, from a baseline measurement through profiling to a decision backed by numbers. CX Codex +1 ★ 2,003repo stars developer-growth-analysis developer-growth-analysis analyzes recent Claude Code chat history to detect skill gaps, pulls learning resources from HackerNews, and delivers an individual growth report. ★ 2,003repo stars security-guidance security-guidance — a Claude Code hook flags possible security trouble while files are edited, including command injection, XSS, and risky code patterns. ★ 2,003repo stars

Project sponsors

Companies that keep this analytics open