Skip to main content
skill CX Codex

review-skill-improver — Claude Code skill: feedback analysis

review-skill-improver reviews code-review feedback logs, spots recurring rejection patterns, and proposes changes to review skills. Use it after feedback has accumulated and you want to refine review rules.

Apache-2.0 125 installs ★ 89 updated 2026-09-15

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add existential-birds/beagle --skill review-skill-improver -a claude-code
Open on GitHub

What review-skill-improver does

The skill groups entries by rule_source, counts ACCEPT and REJECT verdicts, calculates rejection rates, and collects rejection rationales. Rules above a 30% rejection rate are marked for investigation; rules below 10% are listed as performing well. Each proposed change needs evidence tied to log rows or file locations, with a short quote.

Before producing its report, the skill checks that the log has a stated source and follows the enhanced review-feedback-schema. Malformed rows must be counted and identified by row index, and aggregation across parsed entries comes before recommendations. The log must use the schema’s fields, such as rule_source, verdict, and rationale; without that structure, the required checks cannot be completed. The report includes a summary, a rule table, and proposed edits.

What it helps with

  • find review rules with frequent rejections
  • group false-positive feedback by rationale
  • spot issues that review rules miss
  • draft evidence-backed changes to review skills

Example prompts for the agent

  • Analyze feedback.csv and write a report on patterns in the review feedback.
  • Group rejected findings by rule_source and propose changes with evidence from the log.
  • Save the feedback analysis as improvement-report.md.

How to install review-skill-improver

1Skills CLI (Vercel)

npx skills add existential-birds/beagle --skill review-skill-improver -a claude-code

2Manually: put the files in place

~/.claude/skills/review-skill-improver/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/review-skill-improver/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about review-skill-improver

How do I install review-skill-improver in Claude Code?

Run npx skills add existential-birds/beagle --skill review-skill-improver -a claude-code. The skill file will be at ~/.claude/skills/review-skill-improver/SKILL.md.

What does review-skill-improver do?

It examines code-review feedback, identifies rules that are often rejected, and suggests edits to review skills. Recommendations must point to supporting log entries or file locations.

What feedback log format does the skill need?

It expects the enhanced review-feedback-schema, with fields such as rule_source, verdict, and rationale. It also checks the log’s source and reports malformed rows by index.

Source text

SKILL.md · Apache-2.0
---
name: review-skill-improver
description: Analyzes feedback logs to identify patterns and suggest improvements to review skills. Use when you have accumulated feedback data and want to improve review accuracy.
user-invocable: false
---

# Review Skill Improver

## Purpose

Analyzes structured feedback logs to:
1. Identify rules that produce false positives (high REJECT rate)
2. Identify missing rules (issues that should have been caught)
3. Suggest specific skill modifications

## Input

Feedback log in enhanced schema format (see the [review-feedback-schema](../review-feedback-schema/SKILL.md) skill).

## Hard gates

Run in order; do not emit the final **Review Skill Improvement Report** until each gate passes.

1. **Input on record** — The log is loaded from a stated path in the repo or from an attached artifact, not from memory or paraphrase. **Pass:** the report header or Summary names that path or states “attached feedback blob” with byte/line count.
2. **Schema / shape** — Entries match the enhanced schema (`rule_source`, `verdict`, `rationale`, etc. per the [review-feedback-schema](../review-feedback-schema/SKILL.md) skill). **Pass:** either all rows parse, or skipped malformed rows are counted and listed by row index (not silently dropped).
3. **Aggregation before thresholds** — Complete Step 1 (per–`rule_source` totals, ACCEPT vs REJECT, rejection rate, rejection rationales) for the full parsed set before labeling any rule “high-rejection” or writing recommendations. **Pass:** Summary includes “Unique rules triggered” consistent with the aggregation table.
4. **Evidence-bound recommendations** — Every recommendation includes at least one concrete evidence pointer (log row(s), or file:line + short quote) before **Proposed Fix**. **Pass:** **Evidence** is non-empty for each recommendation.

## Analysis Process

### Step 1: Aggregate by Rule Source

```
For each unique rule_source:
  - Count total issues flagged
  - Count ACCEPT vs REJECT
  - Calculate rejection rate
  - Extract rejection rationales
```

### Step 2: Identify High-Rejection Rules

Rules with >30% rejection rate warrant investigation:
- Read the rejection rationales
- Identify common themes
- Determine if rule needs refinement or exception

### Step 3: Pattern Analysis

Group rejections by rationale theme:
- "Linter already handles this" -> Add linter verification step
- "Framework supports this pattern" -> Add exception to skill
- "Intentional design decision" -> Add codebase context check
- "Wrong code path assumed" -> Add code tracing step

### Step 4: Generate Improvement Recommendations

For each identified issue, produce:

```markdown
## Recommendation: [SHORT_TITLE]

**Affected Skill:** `skill-name/SKILL.md` or `skill-name/references/file.md`

**Problem:** [What's causing false positives]

**Evidence:**
- [X] rejections with rationale "[common theme]"
- Example: [file:line] - [issue] - [rationale]

**Proposed Fix:**
```markdown
[Exact text to add/modify in the skill]
```

**Expected Impact:** Reduce false positive rate for [rule] from X% to Y%
```

## Output Format

```markdown
# Review Skill Improvement Report

## Summary
- Feedback entries analyzed: [N]
- Unique rules triggered: [N]
- High-rejection rules identified: [N]
- Recommendations generated: [N]

## High-Rejection Rules

| Rule Source | Total | Rejected | Rate | Theme |
|-------------|-------|----------|------|-------|
| ... | ... | ... | ... | ... |

## Recommendations

[Numbered list of recommendations in format above]

## Rules Performing Well

[Rules with <10% rejection rate - preserve these]
```

## Usage

Invoke the **review-skill-improver** skill to analyze feedback and generate an improvement report, optionally passing an output path:

```
review-skill-improver --output improvement-report.md
```

## Example Analysis

Given this feedback data:

```csv
rule_source,verdict,rationale
python-code-review:line-length,REJECT,ruff check passes
python-code-review:line-length,REJECT,no E501 violation
python-code-review:line-length,REJECT,linter config allows 120
python-code-review:line-length,ACCEPT,fixed long line
pydantic-ai-common-pitfalls:tool-decorator,REJECT,docs support raw functions
python-code-review:type-safety,ACCEPT,added type annotation
python-code-review:type-safety,ACCEPT,fixed Any usage
```

Analysis output:

```markdown
# Review Skill Improvement Report

## Summary
- Feedback entries analyzed: 7
- Unique rules triggered: 3
- High-rejection rules identified: 2
- Recommendations generated: 2

## High-Rejection Rules

| Rule Source | Total | Rejected | Rate | Theme |
|-------------|-------|----------|------|-------|
| python-code-review:line-length | 4 | 3 | 75% | linter handles this |
| pydantic-ai-common-pitfalls:tool-decorator | 1 | 1 | 100% | framework supports pattern |

## Recommendations

### 1. Add Linter Verification for Line Length

**Affected Skill:** `commands/review-python.md`

**Problem:** Flagging line length issues that linters confirm don't exist

**Evidence:**
- 3 rejections with rationale "linter passes/handles this"
- Example: amelia/drivers/api/openai.py:102 - Line too long - ruff check passes

**Proposed Fix:**
Add step to run `ruff check` before manual review. If linter passes for line length, do not flag manually.

**Expected Impact:** Reduce false positive rate for line-length from 75% to <10%

### 2. Add Raw Function Tool Registration Exception

**Affected Skill:** `skills/pydantic-ai-common-pitfalls/SKILL.md`

**Problem:** Flagging valid pydantic-ai pattern as error

**Evidence:**
- 1 rejection with rationale "docs support raw functions"

**Proposed Fix:**
Add "Valid Patterns" section documenting that passing functions with RunContext to Agent(tools=[...]) is valid.

**Expected Impact:** Eliminate false positives for this pattern

## Rules Performing Well

| Rule Source | Total | Accepted | Rate |
|-------------|-------|----------|------|
| python-code-review:type-safety | 2 | 2 | 100% |
```

## Future: Automated Skill Updates

Once confidence is high, this skill can:
1. Generate PRs to beagle with skill improvements
2. Track improvement impact over time
3. A/B test rule variations

## Feedback Loop

```
Review Code -> Log Outcomes -> Analyze Patterns -> Improve Skills -> Better Reviews
     ^                                                                    |
     +--------------------------------------------------------------------+
```

This creates a continuous improvement cycle where review quality improves based on empirical data rather than guesswork.

© existential-birds · Apache-2.0 · existential-birds/beagle

Similar skills

All skills for Code review and refactoring →

From the same set68

The whole set →
deepagents-code-review deepagents-code-review reviews Deep Agents code and flags what breaks agents at runtime: interrupt_on with no checkpointer, backends with no store. CX Codex +1 134installs healthkit-code-review healthkit-code-review walks HealthKit code through a fixed sequence: authorization, queries, observers, background delivery. Handy when you are the one reviewing health data work. CX Codex +1 134installs cloudkit-code-review cloudkit-code-review audits CloudKit code for custom zones, batching, error backoff, and asset size limits. CX Codex +1 127installs prometheus-go-code-review The prometheus-go-code-review skill reviews Prometheus instrumentation in Go, covering metric types, labels, naming, and registration. Use it when checking prometheus/client_golang code. CX Codex +1 126installs elixir-code-review elixir-code-review reviews Elixir files for OTP conventions, security caveats, and idiomatic style across .ex and .exs code. CX Codex +1 124installs app-intents-code-review app-intents-code-review reviews Swift App Intents code for intent structure, shortcuts phrases, entity queries, and iOS deployment quirks. CX Codex +1 124installs review-feedback-schema review-feedback-schema — a skill for recording code review outcomes in CSV and checking the evidence behind each verdict. Use it when review decisions need a history. CX Codex +1 124installs combine-code-review combine-code-review is a Claude Code skill that checks Combine code for subscription, operator, memory, and error-handling issues during Swift code review. CX Codex +1 123installs

Project sponsors

Companies that keep this analytics open