# GitHub Issue → Claude Code Prompt Pack (`ianymu/gh-issue-to-claude-prompts`) Actor

Pick the top open issues from any GitHub repo and generate ready-to-paste Claude Code prompts that walk the model through investigation, fix planning, implementation, and test verification.

- **URL**: https://apify.com/ianymu/gh-issue-to-claude-prompts.md
- **Developed by:** [Yanlong Mu](https://apify.com/ianymu) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## GitHub Issue → Claude Code Prompt Pack

> **Pick the top open issues from any GitHub repo and get ready-to-paste Claude Code prompts. Each prompt walks the model through investigation → plan-approval → implement → test verify.**

### What does this Actor do?

You give it a GitHub repo (e.g. `anthropics/claude-code`) and it returns the top 10 open issues plus a **paste-ready Claude Code prompt** for each one. Each prompt enforces a 6-step workflow:

1. Explore the relevant code first
2. Outline a fix plan and STOP for approval before editing
3. Implement the fix only after approval
4. Add or update tests that fail on main and pass with the fix
5. Run the full suite and report results
6. Do not push or open a PR — leave that for the user

Output: structured JSON prompts + a downloadable Markdown bundle (`prompt-pack.md`) you can drop into Claude Code one section at a time.

### Why use this Actor?

The hardest part of using Claude Code on a real codebase isn't writing the code — it's **picking the right issue and framing it correctly**. Most users either:

- Pick whatever's at the top of their mind (low-priority) and let high-impact issues stagnate
- Paste a raw issue body and watch the model implement without exploring first → bad fixes

This Actor solves both: it picks the most-commented (or newest, or most-reacted) open issues, and wraps each in a prompt that **enforces investigation + approval gating before any code change**.

**Use cases:**

- **Maintainers** triaging their backlog: get a Monday-morning batch of top-10 issue prompts to plow through
- **Contributors** looking for high-impact OSS work: pick a repo, see what's most active, get a workflow that earns merges
- **Teams** standardizing how Claude Code is used: every issue gets the same prompt template
- **Bounty hunters**: scan multiple bounty-labeled repos and prioritize by reaction count

### How to use

1. Paste a GitHub repo as `owner/repo` (e.g. `anthropics/claude-code`)
2. Set **Max issues** (default 10, max 50)
3. (Optional) Filter by labels (e.g. `bug,good first issue`)
4. Pick sort criterion: most-commented (default), newest, or most reactions
5. Click **Start**
6. Download `prompt-pack.md` from the Storage tab → Key-Value Store
7. Open Claude Code in the target repo's directory, paste any prompt block, watch it work

### Input

- **`githubRepo`** *(required)* — `owner/repo` format
- **`maxIssues`** — top N open issues (default 10, max 50)
- **`labels`** — filter by labels (comma-separated)
- **`sortBy`** — `most-commented` / `newest` / `reactions`

### Output

Each issue is returned as a structured prompt object:

```json
{
  "issueNumber": 60835,
  "issueTitle": "Tests written by Claude wrote to production shared infrastructure (NAS) without isolation",
  "issueUrl": "https://github.com/anthropics/claude-code/issues/60835",
  "labels": "model, bug",
  "prompt": "I'm working on issue #60835 in anthropics/claude-code...\n\n1. First explore the relevant code...\n2. Outline a fix plan with specific files to change..."
}
````

The Markdown bundle (`prompt-pack.md`) has the same content formatted for easy paste.

### Pricing

Pay-per-event model:

- **First 10 prompts**: free trial
- **Per-prompt rate**: $0.02 per prompt generated
- **Per-batch (10 prompts)**: $0.20
- **Cost estimate**: $0.20 for a 10-issue batch, $1 for a 50-issue batch

### Tips

- **Public repos only.** GitHub anonymous API is rate-limited to 60 req/hour — small repos work fine; for very busy repos run during off-peak.
- **`labels` is powerful.** Filter by `bounty` to find paid OSS work, or `good first issue` to onboard new contributors.
- **Combine with bounty platforms.** Many Algora-listed bounty repos use the `💰 bounty` label — set `labels: bounty` and you get a paid-work pipeline.

### FAQ

#### Can I use this on private repos?

Not yet — anonymous GitHub API only. A future version may accept a `githubToken` input.

#### Will the prompts work with Cursor / Codex / Aider / Cline?

The 6-step structure works with any agentic coding tool. Paste into whichever you use. The prompts are framework-agnostic.

#### Why do prompts insist on "stop and ask before editing"?

Because false-completion + skip-verify is the #1 source of bad merges in agent-driven dev. See [`verify-before-stop`](https://github.com/ianymu/claude-verify-before-stop) for the Stop-hook companion that enforces this at the workflow level.

### Support

Issues / feature requests: open in the **Issues** tab on the Apify console.

Built by Ian Mu — github.com/ianymu — author of [`verify-before-stop`](https://github.com/ianymu/claude-verify-before-stop).

# Actor input Schema

## `githubRepo` (type: `string`):

owner/repo (e.g. anthropics/claude-code, vercel/next.js, facebook/react)

## `maxIssues` (type: `integer`):

Top N open issues by sort criterion

## `labels` (type: `string`):

e.g. bug,good first issue

## `sortBy` (type: `string`):

How to rank issues

## Actor input object example

```json
{
  "githubRepo": "anthropics/claude-code",
  "maxIssues": 10,
  "sortBy": "most-commented"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "githubRepo": "anthropics/claude-code"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ianymu/gh-issue-to-claude-prompts").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "githubRepo": "anthropics/claude-code" }

# Run the Actor and wait for it to finish
run = client.actor("ianymu/gh-issue-to-claude-prompts").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "githubRepo": "anthropics/claude-code"
}' |
apify call ianymu/gh-issue-to-claude-prompts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ianymu/gh-issue-to-claude-prompts",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Issue → Claude Code Prompt Pack",
        "description": "Pick the top open issues from any GitHub repo and generate ready-to-paste Claude Code prompts that walk the model through investigation, fix planning, implementation, and test verification.",
        "version": "0.0",
        "x-build-id": "Nn5ff1DguPf9UHez8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ianymu~gh-issue-to-claude-prompts/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ianymu-gh-issue-to-claude-prompts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ianymu~gh-issue-to-claude-prompts/runs": {
            "post": {
                "operationId": "runs-sync-ianymu-gh-issue-to-claude-prompts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ianymu~gh-issue-to-claude-prompts/run-sync": {
            "post": {
                "operationId": "run-sync-ianymu-gh-issue-to-claude-prompts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "githubRepo"
                ],
                "properties": {
                    "githubRepo": {
                        "title": "GitHub repo",
                        "type": "string",
                        "description": "owner/repo (e.g. anthropics/claude-code, vercel/next.js, facebook/react)"
                    },
                    "maxIssues": {
                        "title": "Max issues to generate prompts for",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Top N open issues by sort criterion",
                        "default": 10
                    },
                    "labels": {
                        "title": "Filter by labels (optional, comma-separated)",
                        "type": "string",
                        "description": "e.g. bug,good first issue"
                    },
                    "sortBy": {
                        "title": "Sort criterion",
                        "enum": [
                            "most-commented",
                            "newest",
                            "reactions"
                        ],
                        "type": "string",
                        "description": "How to rank issues",
                        "default": "most-commented"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
