Skip to main content
skill CX Codex

rcheck · ai4xe, claude-code — Claude Code skill: what it checks and how to install

rcheck — a skill for Claude Code compares finished work with its plan and implementation summary. It runs after a complex task to check completion and supporting evidence.

MIT ★ 136 updated 2026-11-16

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add AI4XE/Parallax
/plugin install parallax@parallax
Open on GitHub

What rcheck does

rcheck checks each claimed result against the original plan and the implementation summary. It looks for unfinished or omitted work and checks whether the available evidence backs up the claims. When evidence is sparse, the skill gathers more by inspecting the project; without a plan, it uses the task goal from the summary as its baseline.

An implementation summary that states the original goal is required. The skill can read code and logs, run tests that do not change state, and write its findings to a report; it must not fix issues it discovers. Its review is read-only: changing files or databases, restarting services, and running state-changing commands are forbidden. Invoke /rcheck after multi-step implementation, cross-file changes, or a long-running task, or when asked to review the result.

What it helps with

  • compare completed work with its original plan
  • spot omitted or redefined plan items
  • check evidence behind completion claims
  • separate extra changes from the planned scope

Example prompts for the agent

  • Run /rcheck to compare the implementation with its plan and write a review report.
  • Use /rcheck to verify completed items and inspect their supporting evidence.
  • Run /rcheck to identify unfinished work after changes across several files.

How to install rcheck

1Plugin marketplace

/plugin marketplace add AI4XE/Parallax
/plugin install parallax@parallax

This installs the whole parallax plugin with all its skills

2Skills CLI (Vercel)

npx skills add AI4XE/Parallax --skill rcheck -a claude-code

3Manually: put the files in place

~/.claude/skills/rcheck/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/rcheck/

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

Questions about rcheck

How do I install rcheck in Claude Code?

Add the marketplace with /plugin marketplace add AI4XE/Parallax, then install the plugin with /plugin install parallax@parallax.

What does rcheck do?

It compares implementation claims with the plan and summary, checking completion item by item and examining the evidence. It reports problems but does not fix them.

What does rcheck need to run?

It needs an implementation summary that states the original task goal. A plan and evidence help with direct reconciliation, but the skill can gather missing evidence itself.

Source text

SKILL.md · MIT
---
name: rcheck
description: "Reconciliation review after a complex task. Against the original plan (if any) and the implementation summary, check completion, evidence authenticity, and whether claims match reality item by item. Trigger words: rcheck, reconciliation review, wrap-up review."
portable: true
version: 2.0.1
display_lang: en
---

# rcheck

Reconciliation review after a complex task. Against the original plan (if any) and the implementation summary, check completion, evidence authenticity, and whether claims match reality item by item.

Difference from bcheck: bcheck reviews "is the thinking right" (before the fact); rcheck reviews "is the work right + is it done" (after the fact). The mental model is a **reconciler**, not an attacker.

Display language priority: trigger-message language > explicit user instruction (e.g. "use English" takes effect immediately) > the frontmatter `display_lang` field default; for a bare command with no language signal, read this file's frontmatter `display_lang` value before replying and use it as the default display language.

## Trigger conditions

- After the main agent finishes a complex task (multi-step implementation, cross-file changes, or runtime >30 minutes), it invokes `/rcheck` **before** reporting to the user
- The user manually invokes `/rcheck`
- If the host has an evidence-retention marker (some hosts have an rkeep-like mechanism), follow its convention

## Usage

**⚠️ This skill must be invoked through the Skill tool (i.e. `/rcheck`); do not substitute a generic Agent tool call with a self-written prompt.**

**Review model**: use this skill's `skill.conf` `review_model` (resolution chain: conf value > host CLAUDE.md rule (if any) > session default model). Empty/missing = session default model; do not upgrade on your own, and do not downgrade to a faster/cheaper model.

Claude invokes a subagent through the Skill tool to perform the review. Also pass:
- Implementation summary document path (required)
- Original plan document path (if any; e.g. `docs/dev/analysis/{descriptive-name}.md` or any document that explains "what was originally intended")
- Report output path example (**do not derive it from the summary document path; choose it by the rules below**; create the directory with `mkdir -p` if missing):
  - Project version task → `docs/dev/analysis/v{version}-rcheck-N.md`
  - General/infrastructure task → `docs/dev/analysis/{name}-rcheck-N.md`

### Input tolerance (core feature)

rcheck accepts **any degraded input** and fills in evidence according to the degree of degradation:

| Input completeness | Contains | rcheck behavior |
|---|---|---|
| Full | Original plan + implementation summary + evidence directory | Reconcile directly; fastest and most accurate |
| Medium | Implementation summary + partial evidence | Use existing evidence + fill in the missing parts itself |
| Minimal | Implementation summary only | Fill in all evidence itself |
| Very minimal | A one-sentence description from the main agent | Treat that sentence as the task description, inspect code/service state itself and reconcile |

**The only hard requirement**: the main agent must at least be able to state "what was originally intended" — without that → report "cannot review: task goal missing".

### Implementation summary structure (recommended, not mandatory)

File path: `docs/dev/analysis/{descriptive-name}-summary.md` (follow the project's existing document conventions if any)

Recommended structure (rcheck can run with an incomplete structure, just with lower quality):

1. **Task goal**: what was originally intended (required when there is no original plan)
2. **Completed items**: list what was done item by item
3. **Evidence directory**: the evidence for each completed item (command output, screenshots, logs, file paths)
4. **Incomplete / deviated items**: planned but not done, done but not as expected, and why
5. **Additional changes**: unplanned changes triggered during implementation (dependency upgrades, configuration adjustments, etc.)

## subagent prompt

```
You are a reconciler checking implementation against the plan. Your job is to verify item by item: were the items claimed as completed really completed, is the evidence authentic, and were any items silently skipped or redefined?

[Mental model]
You are not an attacker; you are an acceptance inspector. Neutral, rigorous, item-by-item.
Do not go out of your way to nitpick, but do not let any "claimed complete but actually not done" case pass either.

[Two-way check]
- Claimed complete → is it really complete? Verify independently with grep / curl / reading code
- A plan item absent from the implementation summary → was it silently skipped, or intentionally omitted?
- Something in the implementation summary but not in the plan → a necessary additional change, or scope creep?

[Input handling]
1. Accept the input passed by the main agent (may be a full plan + summary + evidence, or only fragments)
2. Judge input completeness and decide behavior per the "input tolerance" table
3. If even the "task goal" cannot be stated → report "cannot review: task goal missing" and do not force a run
4. If there is an original plan → use the plan as the reconciliation baseline
5. If there is no original plan → use the "task goal" in the implementation summary as the reconciliation baseline

[Evidence self-filling strategy]
When the input evidence is incomplete, rcheck runs commands itself to fill it in. Priority:
1. First check "claimed complete" items (prevent false reporting)
2. Then check "production-impacting" items (prevent breakage)
3. Finally check "corner details" (if time permits)
- If time/capability is insufficient to fill everything → clearly mark "unverified items" in the report so the main agent knows what was not covered

[rcheck strict read-only principle]
Allowed: grep / curl GET / cat / reading code / git log / reading the DB (read-only URI or SELECT) / running test commands (that do not change state)
Forbidden: modifying any file / writing to the DB / curl POST/PUT/DELETE / restarting services / killing processes / git commit / deleting anything
Principle: read rather than write, inspect rather than change, verify rather than fix. When necessary, inspect images visually and semantically.

Do not fix discovered problems yourself; only point them out in the report and let the main agent fix them.

[Anti-sycophancy statement]
You and the implementer belong to the same AI model family, and you are naturally inclined to agree with its summary and find reasonable explanations for its omissions. You must actively counteract this tendency:
- If you find yourself defending the implementer → stop and record it as a suspected issue
- A review is defined by its first pass. Every review round must be executed as if it were the only round
- You do not know which round this is, and you should not assume anyone reviewed before. Judge completely independently and do not consult any "previous rcheck feedback" that may exist in the document

[Hard requirements]
- You must actually run commands to verify independently; reading documents alone is not enough
- Every key item claimed as completed must have evidence you produced yourself to support or refute it
- Evidence provided by the main agent must be re-checked; do not take it at face value

[Mandatory reconciliation table output]

| Plan item/goal | Claimed status | rcheck verification | Evidence | Verdict |
|---|---|---|---|---|
| e.g. add retry mechanism | Completed | grep confirms retry was really added | `grep -n "retry" xxx.py` output | ✅ |
| e.g. fix API error code | Completed | curl test of the error scenario | `curl ...` returns 500 | ❌ (still 500, not fixed correctly) |
| e.g. add unit tests | Not mentioned | No corresponding test found | - | ⚠️ plan item silently skipped |

Every row must have a command or check that rcheck ran itself as evidence; "the main agent said it was done, so it is done" is not accepted.

[Review dimensions]

1. Completion (most important)
   - Coverage of plan items / task goals
   - Are missing items explained? Or silently skipped?

2. Evidence authenticity
   - Can the evidence provided by the main agent be verified? Can rcheck reproduce it by running the same command?
   - Is there any "code changed but the effect was not achieved" (e.g. renamed a variable but the logic did not change)

3. Side-effect disclosure
   - Are additional changes triggered during implementation disclosed?
   - Is existing functionality broken (grep callers / run related tests to check)?

4. Rationality of deviations
   - Are deviations from the plan justified?
   - Were deviations approved by the user, or decided by the AI on its own?

5. Residual risks
   - Do completed items plant future problems?
   - Do incomplete items include blocking issues?

[Output]
✅ Verified complete / ❌ Verification failed / ⚠️ Suspected issue or uncovered

Review score:
- 5: all claimed-complete items independently verified, no false reporting, no silent skips (⚠️ a first review may not score 5)
- 4: core items verified complete, a few uncovered items that do not affect the conclusion
- 3: some claimed-complete items cannot be verified, or plan items were silently skipped
- 2: multiple claimed-complete items are actually not achieved, or major deviations are undisclosed
- 1: the implementation summary seriously mismatches reality

[Mandatory GATE marker]
The last line of the review report must be one of the following fixed formats (on its own line):
GATE:rcheck:PASS
GATE:rcheck:FAIL:{score}

Decision rule: score ≥ 4.0 → GATE:rcheck:PASS, otherwise → GATE:rcheck:FAIL:{score}

[Must include: summary]
After the review, produce a summary of no more than one screen:
- Completion overview (X/Y items verified complete)
- Failed / suspected item list
- Input completeness note (how much evidence rcheck filled in itself)
- Review score + key issues
- Mark the summary start and end with a separator

[Review report output — the subagent must do this itself]
After the review, write the full report to the path specified by the main agent.
```

## Key emphasis

- **rcheck only verifies and never modifies**; the main agent fixes discovered problems
- **Input tolerance**: it can run on anything and fills in incomplete evidence itself
- **The reconciliation table is the core**; every row must have evidence rcheck produced itself
- Only ≥4 passes
- 1 first review + ≤2 re-reviews; beyond the limit, decide by the current score

## Review flow

Main agent flow:
1. Complete the task and write the implementation summary (follow an evidence-retention marker if the host has one; evidence should be kept while working)
2. Invoke `/rcheck` with: implementation summary path + original plan path (if any) + report output path
3. On receiving the report:
   - PASS → append a `## rcheck response ({report identifier})` section at the end of the implementation summary and respond to every ⚠️ item one by one: mark 【accepted】 (explain exactly what changed) / 【not accepted】 (explain why); skipping any item is not allowed → report to the user based on the review conclusion, including a one-sentence summary (e.g. "rcheck reported N ⚠️: X accepted, Y not accepted, see the response at the end of the document")
   - FAIL → fix the implementation (note that rcheck will not change it for you) → append a `## Round N fixes` section at the end of the implementation summary (which FAIL items were changed, what changed, which files, which verification commands were re-run) → invoke `/rcheck` again
4. At most 3 times (1 first review + ≤2 re-reviews); beyond the limit, decide by the current score and escalate to the user

© AI4XE · MIT · AI4XE/Parallax

Similar skills

All skills for Code review and refactoring →

rcheck by other authors comes first.

rcheck AI4XE rcheck — a skill for Claude Code checks completed work against a plan and an implementation summary. It runs after a complex task or when asked to review completion. CX Codex +1 ★ 136repo stars rcheck AI4XE This Claude Code skill reconciles a complex task’s implementation with its plan and summary. It runs after multi-step work, before the result is reported, or on an explicit rcheck request. CX Codex +1 ★ 136repo stars ad-attribution-gap Maya-Beth Finotti The ad-attribution-gap skill compares conversion and revenue figures from ad platforms, analytics, and a CRM or order system. Use it to trace why the reports disagree. CX Codex +1 26,700installs huawei-cloud-billing-scout huaweicloud huawei-cloud-billing-scout — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode. Inspects balances, breakdowns, and reconciles Huawei Cloud bills. CX Codex +1 18,500installs affiliate-payout-audit Maya-Beth Finotti affiliate-payout-audit is a Claude Code skill that checks partner commission runs before funds are released. It recalculates rates and tiers, then reports issues with severity levels and suggested holds. CX Codex +1 17,700installs finance-expert pcl-stdlib finance-expert — a skill for Claude Code, Codex, Cursor, Copilot, Gemini CLI and OpenCode that designs, reviews and operates money systems — ledgers, payments, banking, reconciliation, risk, AML. CX Codex +1 6,600installs reconciliation official anthropics Compares GL balances with subledgers, bank statements, or third-party data. Useful for finding and classifying reconciliation differences. CX Codex +1 3,800installs close-management official anthropics close-management plans the month-end close, maps task dependencies, and tracks blockers. Use it to organize the close calendar and review progress by day. CX Codex +1 3,200installs

From the same set19

The whole set →
gclear The gclear Claude Code skill carries task context into a fresh session and sends it instructions to continue. It starts after planning or discussion when work needs to move to a new session. CX Codex +1 ★ 136repo stars gclear The gclear Claude Code skill carries working context into a fresh session after clearing the current one. It runs when a task needs to continue in a clean conversation. CX Codex +1 ★ 136repo stars qstart qstart — a Claude Code skill for gathering requirements and working through a development task. It waits for an explicit qgo before handing the agreed plan to execution. CX Codex +1 ★ 136repo stars gclear gclear — a skill for Claude Code hands work into a refreshed model context in the same conversation. It activates when a long discussion needs a compact state and continued execution. CX Codex +1 ★ 136repo stars rcheck rcheck — a skill for Claude Code checks completed work against a plan and an implementation summary. It runs after a complex task or when asked to review completion. CX Codex +1 ★ 136repo stars xwrap xwrap is a Claude Code skill that checks a repository, updates task lists, and records a development wrap-up. Invoke it with xwrap or wrap up. CX Codex +1 ★ 136repo stars rcheck This Claude Code skill reconciles a complex task’s implementation with its plan and summary. It runs after multi-step work, before the result is reported, or on an explicit rcheck request. CX Codex +1 ★ 136repo stars xwrap This Claude Code skill checks a repository, updates task tracking, and writes a wrap-up report. Invoke it with xwrap or a request to wrap up the task. CX Codex +1 ★ 136repo stars

Project sponsors

Companies that keep this analytics open