Provides tools for analyzing GitHub pull requests, enabling AI agents to fetch PR metadata and diffs, generate humorous but brutally honest code reviews with severity ratings, and list open PRs for review selection.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@pr-roast-mcp roast my latest PR"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server that roasts your pull requests. Brutally honest code review with humor.
claude mcp add pr-roast -- uv run --directory /path/to/pr-roast-mcp pr-roast-mcpOr add to your MCP config:
{
"mcpServers": {
"pr-roast": {
"command": "uv",
"args": ["run", "--directory", "/path/to/pr-roast-mcp", "pr-roast-mcp"],
"env": {
"ANTHROPIC_API_KEY": "sk-ant-..."
}
}
}
}Requires: gh CLI authenticated, ANTHROPIC_API_KEY env var.
Related MCP server: MCP Git/PR Assist
Ask Claude:
"Roast my latest PR"
"Roast PR #89"
"List my open PRs so I can pick one to roast"
roast_prRoast a specific pull request.
Parameter | Type | Description |
| string | PR number, |
roast_my_prsList your PRs to pick one for roasting.
Parameter | Type | Default | Description |
| string | current repo | Repository in |
| string | "open" | PR state: "open", "closed", or "merged" |
Fetches PR metadata and diff via gh CLI
Sends to Claude Haiku for a roast
Returns a brutally honest review with severity rating (๐ฅ to ๐ฅ๐ฅ๐ฅ๐ฅ๐ฅ)
Always ends with one genuine compliment
๐ฅ๐ฅ๐ฅ CODE REVIEW: "Initiative Bonus"
Your tests are thorough. Like, suspiciously thorough. 156 lines for a POST endpoint? You're basically writing a dissertation on HTTP status codes.
That
selectChainhelper is magical incantation โ nobody knows why.select()returns itself. Add a comment explaining the Supabase API you're mimicking.849 lines added, 7 removed. That's 121:1 ratio. For a "bonus feature," this sprawls.
Severity: ๐ฅ๐ฅ๐ฅ (Ship after fixing migration description, simplifying mocks)
List your PRs and pick one to roast.
Args: repo: Repository in owner/repo format. If not set, uses current repo. state: PR state โ "open", "closed", or "merged" (default: open).
| Name | Required | Description | Default |
|---|---|---|---|
| repo | No | ||
| state | No | open |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions listing PRs and picking one to roast, but doesn't disclose behavioral traits like whether this is read-only or destructive, authentication needs, rate limits, or what 'roast' actually does (e.g., generates feedback, marks as reviewed). The description is minimal and leaves key behaviors unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences: one for the purpose and one for parameters. It's front-loaded with the main action, and the Args section is structured clearly. However, the first sentence could be more concise by integrating the parameter info more seamlessly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 parameters with no schema descriptions, an output schema exists, and no annotations, the description is moderately complete. It covers parameter meanings adequately but lacks behavioral context and doesn't leverage the output schema to explain return values. For a tool with 'roast' in the name, more detail on the roasting process would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by explaining both parameters in the Args section: 'repo' specifies format and default behavior, and 'state' defines possible values and default. This adds meaningful semantics beyond the bare schema, though it doesn't cover all potential nuances (e.g., what 'current repo' means).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List your PRs and pick one to roast' which provides a clear verb ('list' and 'pick') and resource ('PRs'), but it's somewhat vague about what 'roast' entails. It distinguishes from sibling 'roast_pr' by implying this tool lists multiple PRs first, while 'roast_pr' likely roasts a specific PR. However, the purpose could be more specific about the roasting action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by listing PRs and selecting one to roast, but doesn't explicitly state when to use this vs. 'roast_pr'. It provides some context with default values in the args section, but lacks clear guidance on prerequisites, alternatives, or exclusions. Usage is somewhat implied rather than explicitly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Roast a pull request. Give it a PR number, owner/repo#number, or URL.
Args: pr: PR reference โ "123", "owner/repo#123", or full GitHub URL.
| Name | Required | Description | Default |
|---|---|---|---|
| pr | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'roast' suggests some form of critique or analysis, the description doesn't explain what the tool actually does operationally, what permissions are required, whether it's read-only or has side effects, what the output format is, or any rate limits. The description is insufficient for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and well-structured. The first sentence states the purpose, the second provides usage guidance with parameter examples, and every sentence earns its place. No wasted words or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there's an output schema (which handles return values), the description doesn't need to explain outputs. However, for a tool with no annotations and a single parameter, the description should do more to explain what 'roast' means operationally and any behavioral characteristics. The parameter explanation is adequate but the overall behavioral context is insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by explaining the 'pr' parameter with examples of valid formats ('123', 'owner/repo#123', or full GitHub URL). This adds meaningful context beyond the bare schema. However, it doesn't explain constraints like maximum length, validation rules, or what happens with invalid formats.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Roast a pull request' with the verb 'roast' and resource 'pull request'. It distinguishes from the sibling tool 'roast_my_prs' by specifying this tool requires a PR reference while the sibling suggests working with multiple PRs. However, it doesn't fully explain what 'roast' means operationally.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool by specifying the required PR reference format and showing examples. It distinguishes from the sibling 'roast_my_prs' by implication (this requires a specific PR reference while the sibling likely works with the user's PRs). However, it doesn't explicitly state when NOT to use this tool or provide explicit alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0roast_my_prsroast_prScored across 2 tools
The two tools have clearly distinct purposes: 'roast_my_prs' lists and selects PRs for roasting, while 'roast_pr' performs the roasting action on a specific PR. There is no overlap or ambiguity between these functions.
Both tools follow a consistent 'verb_noun' pattern with 'roast' as the verb, making them predictable and readable. The naming is uniform across the set.
With only 2 tools, the server feels thin for a PR roasting domain. It lacks tools for broader interactions like viewing roast history, managing roasts, or handling multiple repos, which limits its scope and utility.
The toolset is severely incomplete for a PR roasting server. It covers listing and roasting PRs but misses essential operations such as retrieving past roasts, updating or deleting roasts, or handling user feedback, leaving significant gaps in the domain coverage.
AI code review for GitHub PRs with an MCP autofix loop for Claude Code and Cursor
Screens public GitHub repos and PRs to generate risk maps, findings, and merge-readiness signals.
Agentic code review, no signup to try: reality gates + frontier-model review, with veto.
A Model Context Protocol (MCP) application for automated GitHub PR analysis and issue management.โฆ
