Agent skill

Handle Issues

by aaddrick in aaddrick/claude-pipeline

Batch process GitHub issues via batch-orchestrator.sh with rate limit handling and session resumption

MITAuto-check passedBackend & APIs

Install Handle Issues

skills CLI
$ npx skills add aaddrick/claude-pipeline --skill handle-issues -a claude-code

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

GitHub CLI
$ gh skill install aaddrick/claude-pipeline handle-issues --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/aaddrick/claude-pipeline.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/handle-issues .claude/skills/handle-issues && 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
handle-issues
GitHub stars
130
Token cost
~4k tokens
SKILL.md length
610 words
Files
1
Skills in repo
12
Repo updated
First seen
Licence
MIT

At a glance

Batch process GitHub issues via batch-orchestrator.sh with rate limit handling and session resumption

  • Works in 8 steps: Check for Incomplete Batch → Parse Context Query → Fetch Matching Issues → …
  • Tasks that involve Rate limiting
  • SKILL.md covers Agent Selection, Architecture, Process and Files, plus 5 more sections
  • Calls jq, claude and gh

What it does

Handle Issues is an agent skill from aaddrick/claude-pipeline. Batch process GitHub issues via batch-orchestrator.sh with rate limit handling and session resumption

Its SKILL.md is about 4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs, covering Rate limiting. It works with GitHub and Laravel. The repository describes itself as: Portable Claude Code multi-agent pipeline - skills, agents, hooks, orchestration scripts, and quality gates. The licence is MIT.

When your agent uses it

  • Tasks that involve Rate limiting

Example prompts

  • “/handle-issues”

Workflow steps

8 steps, taken from the step headings in SKILL.md.

  1. Check for Incomplete Batch
  2. Parse Context Query
  3. Fetch Matching Issues
  4. Display Issue List for Confirmation
  5. Write Manifest
  6. Launch Orchestrator
  7. Monitor Progress
  8. Output Summary

What it can do on your machine

Read from SKILL.md and the folder at commit 402eac7. 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:

    • jq
    • claude
    • 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

Handle Issues loads about 4k tokens when it runs. Until then it costs about 29 tokens; SKILL.md has 610 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~29
When it runs · the whole SKILL.md, loaded when a task matches
~4k

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 aaddrick/claude-pipeline at commit 402eac7, republished under its MIT licence (© aaddrick). 610 words, ~4,033 tokens.

Download SKILL.mdSave it as .claude/skills/handle-issues/SKILL.md (or your agent's skills folder).
name
handle-issues
description
Batch process GitHub issues via batch-orchestrator.sh with rate limit handling and session resumption
argument-hint
[context query]

Handle Issues

Batch process multiple GitHub issues by launching batch-orchestrator.sh which handles the execution loop, rate limits, and status tracking autonomously. This skill focuses on setup and monitoring.

Announce at start: "Using handle-issues to batch process issues. Query: $CONTEXT"

Arguments:

  • $1 — Context query describing which issues to process and how (required)

Examples:

  • /handle-issues "issues assigned to @me ordered by priority"
  • /handle-issues "all open bugs labeled 'critical'"
  • /handle-issues "issues in milestone v2.0 by creation date"
  • /handle-issues "Tailwind removal issues 306-308" (frontend work)

Agent Selection

The orchestrator uses specialized agents via --agent flag to ensure the right expertise for each stage:

StageAgentPurpose
implement-issuebulletproof-frontend-developerCSS, HTML, Blade templates, frontend styling
implement-issuelaravel-backend-developerPHP, Laravel, controllers, services, models
implement-issue(default)General implementation
process-prcode-reviewerAlways - reviews PR for quality and standards

Determine agent based on issue content:

  • Frontend issues (CSS, Tailwind, styling, UI, HTML, Blade): Use bulletproof-frontend-developer
  • Backend issues (PHP, Laravel, API, database, auth): Use laravel-backend-developer
  • Mixed or unclear: Use default (no agent specified)

Ask user during confirmation which agent to use if issue type is ambiguous.

Architecture

┌─────────────────────────────────────────────────────────────────┐
│ handle-issues (this skill)                                      │
│  • Gathers issues via gh CLI                                    │
│  • Determines appropriate agent for issue type                  │
│  • Confirms with user (ONLY interaction point)                  │
│  • Writes manifest.json (includes agent)                        │
│  • Launches batch-orchestrator.sh (background)                  │
│  • Reads status.json every 5 minutes                            │
│  • Outputs summary when complete                                │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│ batch-orchestrator.sh (shell script)                            │
│  • Loops through issues autonomously                            │
│  • Invokes claude with --agent and --dangerously-skip-permissions│
│  • Parses structured_output via jq                              │
│  • Updates status.json after each operation                     │
│  • Handles rate limits, timeouts, circuit breaker               │
└─────────────────────────────────────────────────────────────────┘

Claude CLI invocations:
  claude -p "/implement-issue #N branch" \
    --agent <frontend|backend> \
    --dangerously-skip-permissions \
    --output-format json \
    --json-schema implement-issue.json

  claude -p "/process-pr #PR #issue branch" \
    --agent code-reviewer \
    --dangerously-skip-permissions \
    --output-format json \
    --json-schema process-pr.json

Process

dot
digraph process {
    rankdir=TB;
    node [shape=box];

    check_resume [label="0. Check for incomplete batch"];
    resume_choice [label="Resume or start fresh?" shape=diamond];
    parse [label="1. Parse context query"];
    fetch [label="2. Fetch matching issues"];
    confirm [label="3. Confirm with user"];
    write_manifest [label="4. Write manifest.json"];
    launch [label="5. Launch orchestrator"];
    monitor [label="6. Monitor status.json\n(every 5 min)"];
    summary [label="7. Output summary"];

    check_resume -> resume_choice;
    resume_choice -> parse [label="fresh"];
    resume_choice -> launch [label="resume"];
    parse -> fetch -> confirm -> write_manifest -> launch -> monitor -> summary;
}
Step 0: Check for Incomplete Batch

Before fetching issues, check if a previous batch was interrupted:

bash
if [[ -f status.json ]]; then
    STATE=$(jq -r '.state' status.json)

    if [[ "$STATE" == "running" || "$STATE" == "circuit_breaker" ]]; then
        PROGRESS=$(jq -r '.progress | "\(.completed)/\(.total) complete, \(.failed) failed, \(.pending) pending"' status.json)
        LOG_DIR=$(jq -r '.log_dir' status.json)
        BRANCH=$(jq -r '.base_branch' status.json)

        echo "## Incomplete Batch Detected"
        echo ""
        echo "**State:** $STATE"
        echo "**Progress:** $PROGRESS"
        echo "**Branch:** $BRANCH"
        echo "**Log dir:** $LOG_DIR"
        echo ""

        # Show pending issues
        echo "**Pending issues:**"
        jq -r '.issues[] | select(.status == "pending" or .status == "in_progress") | "- #\(.number)"' status.json
        echo ""
    fi
fi

Use AskUserQuestion with options:

  1. Resume (continue with pending issues)
  2. Start fresh (abandon previous batch)

If resuming, skip to Step 5 (launch orchestrator). The orchestrator's idempotency check will skip completed issues.

Step 1: Parse Context Query

Extract from the user's context query:

  • Filter criteria: assignee, labels, milestone, author, state
  • Sort order: priority, created, updated, comments
  • Limit: max issues to process (default: no limit)
Step 2: Fetch Matching Issues

Build and execute gh command based on parsed criteria:

bash
# Example: issues assigned to user
gh issue list --repo OWNER/REPO \
  --assignee @me \
  --state open \
  --json number,title,labels,milestone,createdAt \
  --limit 100

# Example: critical bugs
gh issue list --repo OWNER/REPO \
  --label "bug,critical" \
  --state open \
  --json number,title,labels,milestone,createdAt

Sort by priority (if requested): Order by label priority:

  1. priority:critical or P0
  2. priority:high or P1
  3. priority:medium or P2
  4. priority:low or P3
  5. No priority label
Step 3: Display Issue List for Confirmation

Present the ordered list before processing:

Found N issues matching "$CONTEXT":

1. #123 - Fix login redirect loop [priority:high, bug]
2. #456 - Add password reset flow [priority:medium, feature]
3. #789 - Update user profile validation [priority:low, enhancement]

Base branch: aw-next

Proceed with batch processing? (yes/no)

This is the ONLY user interaction point. After confirmation, the entire batch runs autonomously.

Use AskUserQuestion to confirm:

  • Option 1: "Yes, proceed"
  • Option 2: "No, cancel"
  • Allow user to specify different base branch if needed
Step 4: Write Manifest

Create the manifest file for the orchestrator:

bash
MANIFEST="logs/handle-issues/manifest-$(date +%Y%m%d-%H%M%S).json"
mkdir -p logs/handle-issues

# Build issues array from fetched list
# $ISSUE_NUMBERS is a comma-separated list like "123,456,789"
# $AGENT is determined from issue type (frontend/backend/default)

jq -n \
  --argjson issues "[$ISSUE_NUMBERS]" \
  --arg branch "$BASE_BRANCH" \
  --arg query "$CONTEXT" \
  --arg agent "$AGENT" \
  '{
    issues: $issues,
    base_branch: $branch,
    agent: (if $agent == "" then null else $agent end),
    query: $query,
    created_at: (now | todate)
  }' > "$MANIFEST"

echo "Manifest written to: $MANIFEST"

Agent values:

  • bulletproof-frontend-developer — CSS, Tailwind removal, UI, Blade templates
  • laravel-backend-developer — PHP, Laravel, API, database
  • null or omitted — Default behavior
Show full SKILL.md (231 more words)Show less
Step 5: Launch Orchestrator

Launch the batch orchestrator as a background process:

bash
# Launch orchestrator (agent is read from manifest, or can be overridden via --agent)
nohup .claude/scripts/batch-orchestrator.sh --manifest "$MANIFEST" \
  > "logs/handle-issues/orchestrator-$(date +%Y%m%d-%H%M%S).log" 2>&1 &

# Or with explicit agent override:
# nohup .claude/scripts/batch-orchestrator.sh --manifest "$MANIFEST" --agent bulletproof-frontend-developer \
#   > "logs/handle-issues/orchestrator-$(date +%Y%m%d-%H%M%S).log" 2>&1 &

ORCHESTRATOR_PID=$!
echo "$ORCHESTRATOR_PID" > logs/handle-issues/.orchestrator.pid

echo "Orchestrator launched (PID: $ORCHESTRATOR_PID)"
echo "Status file: status.json"
echo "Logs: logs/batch-*/"

The orchestrator will:

  • Use the specified agent for implement-issue stage
  • Always use code-reviewer agent for process-pr stage
Step 6: Monitor Progress

Check status.json every 5 minutes until complete. Also report lines changed vs base branch:

bash
echo ""
echo "Monitoring progress (checking every 5 minutes)..."
echo ""

BASE_BRANCH=$(jq -r '.base_branch' status.json)

while true; do
    # Check if orchestrator is still running
    if [[ -f logs/handle-issues/.orchestrator.pid ]]; then
        ORCHESTRATOR_PID=$(cat logs/handle-issues/.orchestrator.pid)
        if ! kill -0 "$ORCHESTRATOR_PID" 2>/dev/null; then
            echo "Orchestrator process finished."
            rm -f logs/handle-issues/.orchestrator.pid
            break
        fi
    else
        break
    fi

    # Read and display progress
    if [[ -f status.json ]]; then
        STATE=$(jq -r '.state' status.json)
        COMPLETED=$(jq -r '.progress.completed' status.json)
        FAILED=$(jq -r '.progress.failed' status.json)
        TOTAL=$(jq -r '.progress.total' status.json)
        CURRENT=$(jq -r '(.current_issues // []) | if length == 0 then "none" elif length == 1 then "#\(.[0])" else [.[] | "#\(.)"] | join(", ") end' status.json)
        RATE_LIMITED=$(jq -r '.rate_limit.waiting' status.json)

        # Calculate lines changed since start (vs base branch)
        LINES_CHANGED=$(git diff "$BASE_BRANCH"...HEAD --shortstat 2>/dev/null | grep -oE '[0-9]+ insertion|[0-9]+ deletion' | grep -oE '[0-9]+' | paste -sd+ | bc 2>/dev/null || echo "0")

        if [[ "$RATE_LIMITED" == "true" ]]; then
            RESUME_AT=$(jq -r '.rate_limit.resume_at' status.json)
            echo "[$(date +%H:%M)] $COMPLETED/$TOTAL complete, $FAILED failed | Current: $CURRENT | Lines changed: $LINES_CHANGED | Rate limited until $RESUME_AT"
        else
            echo "[$(date +%H:%M)] $COMPLETED/$TOTAL complete, $FAILED failed | Current: $CURRENT | Lines changed: $LINES_CHANGED"
        fi

        # Exit conditions
        if [[ "$STATE" == "completed" || "$STATE" == "completed_with_errors" || "$STATE" == "circuit_breaker" ]]; then
            break
        fi
    fi

    sleep 300  # 5 minutes
done
Step 7: Output Summary

Read final results from status.json and output summary:

bash
STATE=$(jq -r '.state' status.json)
COMPLETED=$(jq -r '.progress.completed' status.json)
FAILED=$(jq -r '.progress.failed' status.json)
TOTAL=$(jq -r '.progress.total' status.json)
LOG_DIR=$(jq -r '.log_dir' status.json)

echo ""
echo "## Handle Issues Complete"
echo ""
echo "**State:** $STATE"
echo "**Progress:** $COMPLETED/$TOTAL completed, $FAILED failed"
echo ""
echo "### Results"
echo ""
echo "| Issue | PR | Status | Follow-ups |"
echo "|-------|-----|--------|------------|"

jq -r '.issues[] | "| #\(.number) | \(if .pr then "#\(.pr)" else "—" end) | \(.status) | \(.follow_ups // [] | if length > 0 then map("#\(.)") | join(", ") else "—" end) |"' status.json

# Show failures if any
if [[ $FAILED -gt 0 ]]; then
    echo ""
    echo "### Failed Issues"
    echo ""
    jq -r '.issues[] | select(.status == "failed" or .status == "skipped") | "- **#\(.number)**: \(.error // "Unknown error")"' status.json
fi

# Show circuit breaker message if triggered
if [[ "$STATE" == "circuit_breaker" ]]; then
    echo ""
    echo "### Circuit Breaker Triggered"
    echo ""
    echo "3 consecutive failures detected. Batch stopped to prevent further issues."
    echo ""
    echo "**To resume:** Fix the underlying issues, then run:"
    echo "\`/handle-issues \"resume\"\`"
fi

echo ""
echo "**Logs:** $LOG_DIR"

Files

FilePurpose
.claude/scripts/batch-orchestrator.shMain orchestration script (loops through issues)
.claude/scripts/schemas/implement-issue.jsonJSON schema for implement-issue output
.claude/scripts/schemas/process-pr.jsonJSON schema for process-pr output
status.jsonReal-time status (read by this skill, written by orchestrator)
logs/handle-issues/manifest-*.jsonBatch manifest (issues list + branch)
logs/batch-*/Per-batch logs and summary
logs/.batch-orchestrator.lockLock file preventing parallel batches

Integration

Requires:

  • .claude/scripts/batch-orchestrator.sh (orchestration script)
  • .claude/scripts/schemas/*.json (JSON schemas)
  • implement-issue skill (invoked by orchestrator)
  • process-pr skill (invoked by orchestrator)
  • gh CLI authenticated
  • jq for JSON parsing
  • Claude Code CLI installed

Creates:

  • One PR per issue (via implement-issue)
  • Merged PRs with closed issues (via process-pr)
  • Follow-up issues from review comments (via process-pr)
  • status.json with real-time progress
  • Log directory with per-issue logs

Red Flags

TemptationWhy It Fails
Manage the loop yourselfContext bloat. Let orchestrator handle it.
Check status more often than 5 minUnnecessary overhead. Orchestrator updates status.json.
Skip the confirmation stepMay process wrong issues.
Run multiple batches in parallelLock file exists for a reason.
Ignore incomplete batch checkMay reprocess or lose progress.

Example Session (Backend)

User: /handle-issues "open issues assigned to me, priority order"

Claude: Using handle-issues to batch process issues. Query: open issues assigned to me, priority order

Found 3 issues:
1. #130 - Critical auth bug [priority:critical]
2. #128 - Add MFA support [priority:high]
3. #125 - Update docs [priority:low]

Base branch: aw-next
Agent: laravel-backend-developer (backend/auth issues detected)
Proceed with batch processing? (yes/no)

User: yes

Claude: Launching batch orchestrator...
Orchestrator launched (PID: 12345)
Implement agent: laravel-backend-developer
Process-PR agent: code-reviewer
...

Example Session (Frontend)

User: /handle-issues "Tailwind removal issues 306-308"

Claude: Using handle-issues to batch process issues. Query: Tailwind removal issues 306-308

Found 3 issues:
1. #306 - Tailwind Removal: Admin Pages
2. #307 - Tailwind Removal: Dashboard & Notifications
3. #308 - Tailwind Removal: Auth, Account, Landing Components

Base branch: aw-next
Agent: bulletproof-frontend-developer (CSS/frontend issues detected)
Proceed with batch processing? (yes/no)

User: yes

Claude: Launching batch orchestrator...
Orchestrator launched (PID: 12345)
Implement agent: bulletproof-frontend-developer
Process-PR agent: code-reviewer

Monitoring progress (checking every 5 minutes)...

[14:30] 0/3 complete, 0 failed | Current: #306 | Lines changed: 0
[14:35] 0/3 complete, 0 failed | Current: #306 | Lines changed: 245
[14:40] 1/3 complete, 0 failed | Current: #307 | Lines changed: 512
[15:40] 3/3 complete, 0 failed | Current: none | Lines changed: 1247
Orchestrator process finished.

## Handle Issues Complete

**State:** completed
**Progress:** 3/3 completed, 0 failed

### Results

| Issue | PR | Status | Follow-ups |
|-------|-----|--------|------------|
| #306 | #315 | completed | — |
| #307 | #316 | completed | — |
| #308 | #317 | completed | — |

**Logs:** logs/batch-20260131-143022/

Resume Example

User: /handle-issues "open bugs"

Claude: ## Incomplete Batch Detected

**State:** circuit_breaker
**Progress:** 1/3 complete, 2 failed, 0 pending
**Branch:** aw-next
**Log dir:** logs/batch-20260129-100000/

**Pending issues:**
- #456
- #789

Options:
1. Resume (continue with pending issues)
2. Start fresh (abandon previous batch)

User: 1

Claude: Resuming batch...
Orchestrator launched (PID: 12346)
...

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

Files

Just SKILL.md in .claude/skills/handle-issues of aaddrick/claude-pipeline.

Open the folder on GitHubat commit 402eac7

Compare with similar skills

Handle Issues 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.

Handle Issues compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Handle Issues this skillaaddrick/claude-pipeline130—~4kAutomated safety check: PassMIT
Repo2skillzhangyanxs/repo2skill246—~3.6kAutomated safety check: PassNone
Better Auth Security Best PracticesEpicenterHQ/epicenter4.8k—~896Automated safety check: PassCustom licence
Dload Fetch Toolphp-internal/dload105—~1.1kAutomated safety check: PassBSD-3-Clause
Apikerhodgef/apiker127—~1.4kAutomated safety check: PassMIT
GitHub Issuesscify/laravel-cookie-guard148—~170Automated safety check: PassApache-2.0

Similar skills

  • Repo2skill

    zhangyanxs/repo2skill

    Convert GitHub/GitLab/Gitee repositories into comprehensive OpenCode Skills using embedded LLM calls with multiple mirrors and rate limit handling

    246 GitHub stars~3.6k tokensUpdated 7 mo ago
    Backend & APIsAuto-check passed
  • Better Auth security hardening: rate limits, secrets, CSRF, trusted origins, cookies, sessions, OAuth tokens, and audit logging.

    4.8k GitHub stars~896 tokensUpdated today
    Backend & APIsAuto-check passed
  • Dload Fetch Tool

    php-internal/dload

    Get a CLI tool — native binary or PHAR — from a GitHub release into a project folder with dload (vendor/bin/dload).

    105 GitHub stars~1.1k tokensUpdated yesterday
    Backend & APIsAuto-check passed
  • Apiker

    hodgef/apiker

    Develop, review, and extend the Apiker library — a framework for building serverless REST APIs on Cloudflare Workers + Durable Objects.

    127 GitHub stars~1.4k tokensUpdated 1 mo ago
    Backend & APIsAuto-check passed
  • GitHub Issues

    scify/laravel-cookie-guard

    Fetches open GitHub issues for the current repository using the gh CLI.

    148 GitHub stars~170 tokensUpdated 2 days ago
    Backend & APIsAuto-check passed
  • Goosetown Researcher GitHub

    aaif-goose/goosetown

    Search GitHub issues, PRs, code, and discussions using the gh CLI.

    154 GitHub stars~1.6k tokensUpdated 3 mo ago
    Backend & APIsAuto-check passed

More from aaddrick/claude-pipeline

All 12 skills in this repo
  • Writing Agents

    aaddrick/claude-pipeline

    A skill your agent uses when creating new agents, editing existing agents, or defining specialized subagent roles for the Task tool

    130 GitHub starsUsed in 1 repo~3.3k tokens
    Auto-check passed
  • Adapting Claude Pipeline

    aaddrick/claude-pipeline

    A skill your agent uses when adapting the generic .claude pipeline folder to a specific codebase - adjusting skills, agents, hooks, scripts, prompts, and settings for the target project's tech stack…

    130 GitHub stars~2.8k tokensUpdated 7 mo ago
    Auto-check passed
  • A skill your agent uses when asked to create user stories from a codebase, document existing features as stories, or reverse-engineer requirements from code

    130 GitHub stars~2.2k tokensUpdated 7 mo ago
    Auto-check passed
  • Review UI

    aaddrick/claude-pipeline

    Comprehensive UI/CSS review using parallel agents. An agent skill from aaddrick/claude-pipeline.

    130 GitHub stars~2.5k tokensUpdated 7 mo ago
    Auto-check passed
  • Using Git Worktrees

    aaddrick/claude-pipeline

    A skill your agent uses when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees in .worktrees/

    130 GitHub stars~1.3k tokensUpdated 7 mo ago
    Auto-check passed
  • Implement Issue

    aaddrick/claude-pipeline

    A skill your agent uses when given a GitHub issue number and base branch to implement end-to-end

    130 GitHub starsUsed in 1 repo~889 tokens
    Auto-check passed

Works with

Questions about Handle Issues

What does Handle Issues do?

Batch process GitHub issues via batch-orchestrator.sh with rate limit handling and session resumption. Handle Issues is an agent skill from aaddrick/claude-pipeline.

When should I use Handle Issues?

Handle Issues fits situations like: tasks that involve Rate limiting.

How do I install Handle Issues in Claude Code?

Run `npx skills add aaddrick/claude-pipeline --skill handle-issues -a claude-code`. Or copy the skill folder (.claude/skills/handle-issues in aaddrick/claude-pipeline) into .claude/skills/handle-issues in your project. Claude Code loads it when a task matches its description.

How do I install Handle Issues in Codex?

Run `npx skills add aaddrick/claude-pipeline --skill handle-issues -a codex`. Or copy the skill folder (.claude/skills/handle-issues in aaddrick/claude-pipeline) into .agents/skills/handle-issues in your project. Codex loads it when a task matches its description.

Can I use Handle Issues 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 aaddrick/claude-pipeline --skill handle-issues -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/handle-issues, .gemini/skills/handle-issues, .github/skills/handle-issues and .opencode/skills/handle-issues in your project.

What does Handle Issues need to run?

Going by SKILL.md and its folder, Handle Issues needs the command-line tools its instructions call (jq, claude, gh and git).

Does Handle Issues 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 Handle Issues 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 Handle Issues use?

Handle Issues 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 Handle Issues use?

About 4k tokens (SKILL.md is roughly 16k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Handle Issues?

Skills that share tags, products or a category with Handle Issues: Repo2skill (zhangyanxs/repo2skill, 246 stars), Better Auth Security Best Practices (EpicenterHQ/epicenter, 4.8k stars), Dload Fetch Tool (php-internal/dload, 105 stars) and Apiker (hodgef/apiker, 127 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Handle Issues?

aaddrick (a GitHub user) maintains it in aaddrick/claude-pipeline, which has 130 GitHub stars. The repository holds 12 skills in this directory. The repository was last updated on February 25, 2026.

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