# GitHub Repo AI Readiness Score (`ianymu/gh-repo-ai-readiness-score`) Actor

Score any public GitHub repo on AI-readiness. Checks for CLAUDE.md, AGENTS.md, .cursorrules, copilot instructions, .claude/{agents,skills,hooks}, MCP config, AI-tagged CI, and more. Returns 0-100 + AI-Native/Friendly/Curious/Aware/Absent tier + per-signal breakdown.

- **URL**: https://apify.com/ianymu/gh-repo-ai-readiness-score.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 Repo AI Readiness Score

> **Score any public GitHub repo on AI-readiness. 0-100 + AI-Native / AI-Friendly / AI-Curious / AI-Aware / AI-Absent tier + per-signal breakdown. Stop guessing whether a repo plays nice with Claude Code, Cursor, Copilot, Aider, Continue.dev, and Windsurf.**

### What does GitHub Repo AI Readiness Score do?

In 2026 every popular AI coding agent (Claude Code, Cursor, GitHub Copilot, Aider, Continue.dev, Windsurf, Cline) reads a slightly different set of project-config files: `CLAUDE.md`, `AGENTS.md`, `.cursorrules`, `.github/copilot-instructions.md`, `CONVENTIONS.md`, `.continuerc.json`, `.windsurfrules`, and so on. The presence or absence of these files determines whether agents work brilliantly or burn tokens guessing.

This Actor inspects the default branch of a public GitHub repo, audits which signals are present, and outputs:

- An **AI-readiness score** from 0-100
- A **tier label** (AI-Native >= 80, AI-Friendly >= 60, AI-Curious >= 40, AI-Aware >= 20, AI-Absent < 20)
- The **list of high-impact missing files** so you know what to add
- A full per-signal breakdown with weights

It is the **repo-level companion** to [gh-org-ai-fingerprinter (#9)](https://apify.com/ianymu/gh-org-ai-fingerprinter), which scores at the org level. Use this Actor when you want one repo at a time, or batch it with a list of `owner/name` inputs.

### Why use GitHub Repo AI Readiness Score?

- **Picking dependencies**: an AI-Native library will give your agent better context than an AI-Absent one — favor those for vibe-coding sessions
- **Onboarding a repo to Claude Code / Cursor**: see what's missing before you hit the first error
- **OSS maintainers**: identify gaps in your AI-readiness and add files to reduce drive-by AI-generated PR noise
- **Recruiters / scouts**: an AI-Native engineering culture is a strong hiring signal in 2026
- **Investors**: portfolio-wide AI-readiness audit of every dep tree of every portfolio company

### How to use GitHub Repo AI Readiness Score

1. Enter a public GitHub repo as `owner/name` or full URL (e.g., `anthropics/claude-code` or `https://github.com/microsoft/playwright`)
2. Click **Start**
3. Open the dataset row OR download `ai-readiness-report.md` from the **Storage** tab

### Input

- **`githubRepo`** — the repo to score, in `owner/name` form or full GitHub URL

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. Each row contains:

```json
{
  "repo": "anthropics/claude-code",
  "url": "https://github.com/anthropics/claude-code",
  "defaultBranch": "main",
  "stars": 8420,
  "description": "Official CLI for Claude Code",
  "language": "TypeScript",
  "aiReadinessScore": 84,
  "tier": "AI-Native",
  "detected": {
    "claudeMd": true,
    "agentsMd": false,
    "cursorRules": true,
    "copilotInstructions": false,
    "claudeDir": true,
    "claudeAgents": true,
    "claudeSkills": true,
    "claudeHooks": true,
    "claudeSettings": true,
    "aiderConventions": false,
    "continueRc": false,
    "windsurfConfig": false,
    "mcpConfig": true,
    "githubPromptIssueTemplates": true,
    "ciAi": true,
    "readmeMentions": true,
    "description": true
  },
  "missingHighValue": ["AGENTS.md at root", "GitHub Copilot instructions"]
}
````

### Data table

| Field | Meaning |
|---|---|
| repo | owner/name path |
| stars | Star count |
| aiReadinessScore | 0-100 composite |
| tier | One of: AI-Native, AI-Friendly, AI-Curious, AI-Aware, AI-Absent |
| detected | Per-signal boolean map |
| missingHighValue | List of weight >= 6 signals not present |
| signals | Full breakdown with weight + present flag |

### Signal weights

| Signal | Weight |
|---|---|
| CLAUDE.md at root | 18 |
| AGENTS.md at root | 8 |
| .cursorrules / .cursor/rules | 8 |
| GitHub Copilot instructions | 7 |
| .claude/ directory | 6 |
| .claude/agents/ | 6 |
| .claude/skills/ | 6 |
| .claude/hooks/ | 6 |
| .claude/settings.json | 5 |
| MCP config (mcp.json) | 6 |
| Aider CONVENTIONS.md | 3 |
| Continue.dev (.continuerc.json) | 3 |
| Windsurf (.windsurfrules) | 3 |
| README mentions Claude/Cursor/Copilot | 4 |
| CI workflow tagged AI/agent | 3 |
| Issue templates present | 2 |
| Repo description mentions AI/LLM | 2 |

### Pricing / Cost estimation

Pay-per-event:

- **First scan**: free trial
- **Per-repo scan**: $0.05
- **Bulk pack (50 repos)**: $2
- **Monthly portfolio audit subscription**: $4/month

Each scan uses only 2 GitHub API calls (repo metadata + git tree), so even free anonymous quotas (60/h) support ~30 scans per hour.

### Tips and Advanced options

- Set `GITHUB_TOKEN` in the Actor's Source > Environment Variables tab for a 5000 req/h ceiling (lets you scan thousands of repos in one run)
- Combine with the org-level companion [gh-org-ai-fingerprinter (#9)](https://apify.com/ianymu/gh-org-ai-fingerprinter) for a top-down audit
- Pair with [claude-md-completeness-grader](https://apify.com/ianymu/claude-md-completeness-grader) — the readiness score tells you *if* a CLAUDE.md exists; the grader tells you *how good* it is

### FAQ, disclaimers, and support

#### What is "AI-readiness"?

It's a measure of how much project-specific context an AI coding agent can read on first sight. A repo with CLAUDE.md + AGENTS.md + .cursorrules + a populated `.claude/` directory will produce dramatically better agent output than a repo with nothing — the agent doesn't have to guess at conventions, security rules, or testing setup.

#### Why is the weight for CLAUDE.md so high (18)?

CLAUDE.md is the broadest and most-actioned file. Claude Code reads it on every session, and other agents (Cursor, Cline) have started honoring it too. It's the single highest leverage signal.

#### Limitations

- Only inspects the default branch — content on feature branches is ignored
- Detection is file-existence based; a `.cursorrules` file that's empty still counts (use the companion grader to check quality)
- For very large monorepos (>100k files) the GitHub git-tree response truncates and some deep paths may be missed; a warning is logged

#### Legality

This Actor only reads metadata and file listings via the public GitHub REST API. No private repos, no scraping.

#### Support

Companion repo: [github.com/ianymu/claude-verify-before-stop](https://github.com/ianymu/claude-verify-before-stop) — a Claude Code Stop hook that catches "task complete" hallucinations before they ship.

Built by Ian Mu — [github.com/ianymu](https://github.com/ianymu). Open an issue on the Actor's Issues tab if you find a missing AI-tool signal worth tracking.

# Actor input Schema

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

Public GitHub repo to score. Accepts 'owner/name' or full URL.

## Actor input object example

```json
{
  "githubRepo": "anthropics/claude-code"
}
```

# 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-repo-ai-readiness-score").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-repo-ai-readiness-score").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-repo-ai-readiness-score --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Repo AI Readiness Score",
        "description": "Score any public GitHub repo on AI-readiness. Checks for CLAUDE.md, AGENTS.md, .cursorrules, copilot instructions, .claude/{agents,skills,hooks}, MCP config, AI-tagged CI, and more. Returns 0-100 + AI-Native/Friendly/Curious/Aware/Absent tier + per-signal breakdown.",
        "version": "0.0",
        "x-build-id": "fvBSCi8kJ8xEMZ4km"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ianymu~gh-repo-ai-readiness-score/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ianymu-gh-repo-ai-readiness-score",
                "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-repo-ai-readiness-score/runs": {
            "post": {
                "operationId": "runs-sync-ianymu-gh-repo-ai-readiness-score",
                "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-repo-ai-readiness-score/run-sync": {
            "post": {
                "operationId": "run-sync-ianymu-gh-repo-ai-readiness-score",
                "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 (owner/name)",
                        "type": "string",
                        "description": "Public GitHub repo to score. Accepts 'owner/name' or full URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
