greploop-apps
Run the greploop workflow with the @greptile-apps trigger when the normal trigger refuses a large PR. Requires the greploop skill installed alongside this entrypoint.
Install / Use
npx skills add michaelshimeles/skills --skill greploop-appsInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AutomationSupported Platforms
Tags
Our assessment of greploop-apps
greploop-apps scores 93/100 on our quality scale, 710th of 2,790 Automation skills we index (top 26%).
Its SKILL.md is 14 KB long, well organised into 20 sections with 32 code examples: a thorough specification that gives an agent plenty to work with.
With 1,076 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so greploop-apps is actively maintained.
- Our last check on 2026-10-26 found the source still online.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
greploop-apps compared with similar skills
All 4 of these similar skills score higher than greploop-apps; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| greploop-apps (this skill)by michaelshimeles | 93 | 1.1k | 2mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 39.7k | 7d ago | CLAUDE.md |
| Scraplingby D4Vinci | 100 | 103.6k | 2d ago | MCP Server |
Frequently asked questions
- How do I install greploop-apps?
- Run
npx skills add michaelshimeles/skills --skill greploop-apps. The install tabs above show the steps for each supported agent. - Which AI agents does greploop-apps work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is greploop-apps safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is greploop-apps still maintained?
- The repository was last updated about 2 months ago, so greploop-apps is actively maintained.
Skill content
View source on GitHubname: greploop-apps description: > Iteratively improves a PR (GitHub), MR (GitLab), or shelved changelist (Perforce) until Greptile gives it a 5/5 confidence score with zero unresolved comments. Identical to greploop, but triggers reviews by tagging @greptile-apps, which bypasses Greptile's file-count limit on huge PRs that the plain @greptile mention refuses to review. Use when the user wants to fully optimize a large PR/MR/CL against Greptile's code review standards. license: MIT compatibility: Requires git, gh (GitHub CLI) or glab (GitLab CLI) authenticated, and Greptile installed on the repo. For Perforce, requires p4 CLI authenticated. metadata: author: greptileai version: "1.3" allowed-tools: Bash(gh:) Bash(glab:) Bash(git:) Bash(p4:)
Greploop Apps
Iteratively fix a PR/MR/CL until Greptile gives a perfect review: 5/5 confidence, zero unresolved comments. This variant tags @greptile-apps to trigger reviews, which bypasses the file-count limit that makes Greptile skip huge PRs (e.g. "Too many files changed for review"). Because auto-review skips those PRs, every push needs a fresh @greptile-apps review comment.
Inputs
- PR/MR/CL number (optional): If not provided, detect the PR/MR for the current branch, or the default pending changelist for p4.
--max-iterations N(optional, default 10): cap on review-fix-push cycles before the loop stops and reports the current state. Raise it for large PRs where Greptile keeps surfacing new findings; lower it to bound cost.
Instructions
0. Detect platform
First check for Perforce, then fall back to git remote detection:
# Check for Perforce environment
if p4 info >/dev/null 2>&1; then
VCS="perforce"
else
REMOTE_URL=$(git remote get-url origin)
if echo "$REMOTE_URL" | grep -qi "gitlab"; then
VCS="gitlab"
else
VCS="github"
fi
fi
For self-hosted GitLab instances whose hostname doesn't contain "gitlab", the user can override by passing --vcs gitlab as an input. For Perforce, pass --vcs perforce.
1. Identify the PR/MR/CL
GitHub:
gh pr view --json number,headRefName -q '{number: .number, branch: .headRefName}'
GitLab:
glab mr view --output json | jq '{iid: .iid, branch: .source_branch}'
Switch to the PR/MR branch if not already on it.
Perforce:
# List pending changelists for current user/client
p4 changes -s pending -u $P4USER -c $P4CLIENT
# Describe a specific CL
p4 describe -s <CL_NUMBER>
Ensure the correct workspace (p4 client) is set before proceeding.
Key field differences:
- GitHub:
number,headRefName,headRefOid - GitLab:
iid,source_branch,sha - Perforce: changelist number,
P4CLIENT, shelved files
2. Loop
Repeat the following cycle at most --max-iterations times (default 10) to avoid runaway loops.
A. Trigger Greptile review
Push/shelve the latest changes (if any):
GitHub/GitLab:
git push
Perforce:
# Re-shelve to update the shelved files for review
p4 shelve -f -c <CL_NUMBER>
Wait for checks to start after push/shelve:
sleep 5
GitHub — check if Greptile is already running before posting a new trigger comment:
GREPTILE_STATE=$(gh pr checks <PR_NUMBER> --json name,state | jq -r '.[] | select(.name | test("greptile"; "i")) | .state')
If Greptile is not already running (PENDING or IN_PROGRESS), request a fresh review:
if [ "$GREPTILE_STATE" != "PENDING" ] && [ "$GREPTILE_STATE" != "IN_PROGRESS" ]; then
gh pr comment <PR_NUMBER> --body "@greptile-apps review"
fi
Then poll for the Greptile check run to complete:
HEAD_SHA=$(gh pr view <PR_NUMBER> --json headRefOid -q .headRefOid)
ATTEMPTS=0
MAX_ATTEMPTS=60
POLL_INTERVAL_SECONDS=10
while true; do
ATTEMPTS=$((ATTEMPTS + 1))
if [ "$ATTEMPTS" -gt "$MAX_ATTEMPTS" ]; then
echo "Timed out waiting for the Greptile check run after approximately 10 minutes." >&2
exit 1
fi
GREPTILE_CHECK=$(gh api "repos/{owner}/{repo}/commits/$HEAD_SHA/check-runs" \
--jq '.check_runs[] | select(.name | test("greptile"; "i"))' 2>/dev/null)
if [ -z "$GREPTILE_CHECK" ]; then
echo "Waiting for Greptile check to appear..."
sleep "$POLL_INTERVAL_SECONDS"
continue
fi
STATUS=$(echo "$GREPTILE_CHECK" | jq -r '.status // "completed"')
CONCLUSION=$(echo "$GREPTILE_CHECK" | jq -r '.conclusion // "pending"')
if [ "$STATUS" = "completed" ]; then
if [ "$CONCLUSION" = "success" ]; then
echo "Greptile check passed!"
else
echo "Greptile check completed with: $CONCLUSION"
fi
break
fi
echo "Waiting for Greptile... (status: $STATUS)"
sleep "$POLL_INTERVAL_SECONDS"
done
Huge-PR fallback: on PRs over Greptile's file limit, the tagged review may never create a check run for the new head — Greptile instead edits its existing summary comment when it finishes. If the check run has not appeared after a few attempts, poll the latest Greptile-authored issue comment instead and stop when its updated_at moves past the time you posted the trigger and its body carries a confidence score (rather than the "Too many files changed" notice):
gh api --paginate "repos/{owner}/{repo}/issues/<PR_NUMBER>/comments?per_page=100" \
--jq '[.[] | select(.user.login | test("greptile"; "i"))] | sort_by(.updated_at) | last | {updated_at, body}'
If polling times out, stop the greploop workflow and report the timeout. Do not continue with stale or missing review results.
GitLab — check if Greptile is already running before posting a trigger comment:
PIPELINES=$(glab api "projects/:fullpath/merge_requests/<MR_IID>/pipelines")
GREPTILE_RUNNING=$(echo "$PIPELINES" | jq '[.[] | select(.status == "running" or .status == "pending")] | length')
If no pipeline is running, post a trigger comment:
if [ "$GREPTILE_RUNNING" = "0" ]; then
glab mr note <MR_IID> --message "@greptile-apps review"
fi
Perforce — Perforce does not have native check runs. If Greptile is integrated via a webhook triggered on p4 shelve, wait for it to process. Check your Greptile installation's webhook endpoint or dashboard for the review status. Poll by re-fetching the Greptile review comment on the CL until a score appears.
Then poll for the Greptile pipeline job to complete (see GitLab API reference):
HEAD_SHA=$(glab mr view <MR_IID> --output json | jq -r '.sha')
ATTEMPTS=0
MAX_ATTEMPTS=60
POLL_INTERVAL_SECONDS=10
while true; do
ATTEMPTS=$((ATTEMPTS + 1))
if [ "$ATTEMPTS" -gt "$MAX_ATTEMPTS" ]; then
echo "Timed out waiting for the Greptile pipeline job after approximately 10 minutes." >&2
exit 1
fi
PIPELINES=$(glab api "projects/:fullpath/merge_requests/<MR_IID>/pipelines")
# Find the most recent pipeline for this SHA
PIPELINE_ID=$(echo "$PIPELINES" | jq -r --arg sha "$HEAD_SHA" \
'[.[] | select(.sha == $sha)] | sort_by(.id) | last | .id // empty')
if [ -z "$PIPELINE_ID" ]; then
echo "Waiting for Greptile pipeline to appear..."
sleep "$POLL_INTERVAL_SECONDS"
continue
fi
JOBS=$(glab api "projects/:fullpath/pipelines/$PIPELINE_ID/jobs")
GREPTILE_JOB=$(echo "$JOBS" | jq '.[] | select(.name | test("greptile"; "i"))')
if [ -z "$GREPTILE_JOB" ]; then
echo "Waiting for Greptile job to appear..."
sleep "$POLL_INTERVAL_SECONDS"
continue
fi
JOB_STATUS=$(echo "$GREPTILE_JOB" | jq -r '.status')
if [ "$JOB_STATUS" = "success" ] || [ "$JOB_STATUS" = "failed" ] || [ "$JOB_STATUS" = "canceled" ]; then
echo "Greptile job completed with: $JOB_STATUS"
break
fi
echo "Waiting for Greptile... (status: $JOB_STATUS)"
sleep "$POLL_INTERVAL_SECONDS"
done
If polling times out, stop the greploop workflow and report the timeout. Do not continue with stale or missing review results.
B. Fetch Greptile review results
Greptile may surface its score in several places — check all of the relevant sources:
GitHub:
1. PR description (body):
gh pr view <PR_NUMBER> --json body -q '.body'
2. General PR comments (issue comments):
gh api --paginate "repos/{owner}/{repo}/issues/<PR_NUMBER>/comments?per_page=100"
Filter for Greptile-authored comments and use the body from the most recently updated comment (updated_at), not the most recently created comment. Greptile may edit the same general PR comment on each review cycle; parse the current body, including the "Prompt to fix all with AI" section, before deciding there are no remaining issues.
3. PR reviews:
gh api repos/{owner}/{repo}/pulls/<PR_NUMBER>/reviews
Look for the most recent entry from greptile-apps[bot] or greptile-apps-staging[bot].
GitLab:
1. MR description (body):
glab mr view <MR_IID> --output json | jq -r '.description'
2. MR notes (comments):
glab api "projects/:fullpath/merge_requests/<MR_IID>/notes"
Filter for notes from the Greptile bot user (check the author.username field — the exact username may vary per installation; verify on first run).
Perforce:
1. CL description:
p4 describe -s <CL_NUMBER>
Check the description field for a Greptile-appended score block.
2. CL comments / review notes: If your installation uses a review tool such as Helix Swarm, fetch comments via its API.
Example (Swarm API): GET /api/v11/comments?topic=reviews/<REVIEW_ID>
Response fields of interest typically include:
- user (author username)
- body (comment text)
- flags/state indicating whether the comment is resolved
Filter to comments authored by the Greptile bot:
- Prefer exact username match if known
- Otherwise, use a heuristic where the author name contains "greptile" (case-insensitive)
For all platforms, parse the text for:
- Confidence score: a pattern like
3/5or5/5(orConfidence: 3/5). - Comment count: Number of inline review comments noted in the summary.
Use whichever source has the most recently updated score. For GitHub, prefer updated_at from issue comments when comparing an edited Greptile summary against older review entries.
Also fetch all unresolved inline comments:
GitHub:
gh api repos/{owner}/{repo}/pulls/<PR_NUMBER>/comments
Also carry forward actionable items from the latest Greptile general PR comment, especially the "Prompt to fix all with AI" section, even if the inline comment endpoint returns zero unresolved comments.
GitLab:
glab api "projects/:fullpath/merge_requests/<MR_IID>/discussions"
Filter to DiffNote type discussions (notes[0].type == "DiffNote") from Greptile that are on the latest commit and not yet resolved ("resolved": false).
Perforce: If using Swarm:
Fetch inline diff comments for the review associated with the CL
GET /api/v11/comments?topic=reviews/<REVIEW_ID>
Filter to comments from the Greptile bot user that have not been marked as resolved/addressed.
C. Check exit conditions
Stop the loop if any of these are true:
- Confidence score is 5/5 AND there are zero unresolved comments
--max-iterationsreached (report current state)
D. Fix actionable comments
For each unresolved Greptile comment:
- Read the file and understand the comment in context.
- Determine if it's actionable (code change needed) or informational.
- If actionable, make the fix.
- If informational or a false positive, note it but still resolve the thread.
E. Resolve threads
GitHub — fetch unresolved review threads and resolve all that have been addressed (see GraphQL reference):
gh api graphql -f query='
query($cursor: String) {
repository(owner: "OWNER", name: "REPO") {
pullRequest(number: PR_NUMBER) {
reviewThreads(first: 100, after: $cursor) {
pageInfo { hasNextPage endCursor }
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
Claude-Code-Game-Studios
39.7kTurn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Scrapling
103.6k🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
