CH

checkpoint-ambiguity-review

Audits tests to ensure they enforce explicit specs rather than ambiguous interpretations.

Install

mkdir -p .claude/skills/checkpoint-ambiguity-review && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/18667" && unzip -o skill.zip -d .claude/skills/checkpoint-ambiguity-review && rm skill.zip

Installs to .claude/skills/checkpoint-ambiguity-review

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Review checkpoint specs and tests to identify tests that encode ambiguous interpretations rather than explicit requirements. Use when asked to check checkpoint_N.md against test_checkpoint_N.py, when auditing tests for ambiguity, or when reviewing snapshot eval failures for interpretive issues.
295 chars✓ has a “when” triggerlonger than Claude Code's old 250-char listing cap (fine on current versions)
Intermediate

Key capabilities

  • Collect problem name and checkpoint number
  • Read checkpoint spec and test files
  • Extract explicit requirements from the spec
  • Map test assertions to spec clauses or implied behaviors
  • Flag ambiguous interpretations in tests

How it works

The skill reads a checkpoint's specification and associated tests to identify assertions that enforce non-explicit interpretations. It flags these ambiguities with explanations and proposed resolutions.

Inputs & outputs

You give it
Problem name, checkpoint number, and optionally test/spec file paths
You get back
A report detailing ambiguous tests with rationale and proposed fixes, or a statement of no ambiguity

When to use checkpoint-ambiguity-review

  • Auditing test ambiguity
  • Comparing specs with tests
  • Reviewing snapshot failures

About this skill

Checkpoint Ambiguity Review

Overview

Review a checkpoint's spec and tests to find tests that enforce a reasonable but non-explicit interpretation, and report those cases with rationale and fixes.

Workflow

1) Collect inputs

  • Problem name and checkpoint number (N).
  • Test file path(s) and checkpoint spec path (if not provided, infer):
    • Spec: problems/{problem}/checkpoint_{N}.md
    • Tests: problems/{problem}/tests/test_checkpoint_{N}.py
    • Also scan problems/{problem}/tests/conftest.py and problems/{problem}/tests/data/ if they influence expectations.
  • Optional: snapshot path for ambiguity verification.

2) Read the spec and tests

  • Extract explicit requirements from the spec.
  • Map each test assertion to a specific spec clause or an implied behavior.
  • Note any test assumptions that are not spelled out in the spec.

3) Flag ambiguous interpretations

Only report tests that enforce an interpretation that could reasonably differ given the spec wording. Do not report tests that are simply incorrect against explicit requirements.

Common ambiguity cues:

  • Output ordering when the spec does not mandate order.
  • Tie-breaking rules that are unstated.
  • Whitespace, casing, or formatting details not defined by the spec.
  • Rounding or precision requirements not defined.
  • Error handling for invalid inputs when not specified.
  • Boundary behavior (inclusive/exclusive) not stated.
  • Default values or optional fields not defined.
  • Determinism or randomness expectations not specified.
  • Multiple reasonable data structure representations (list vs set, map order).

4) Optional snapshot verification

If a snapshot is provided, run:

slop-code --quiet eval-snapshot {snapshot} -p {problem} -o /tmp/eval -c {N} -e configs/environments/docker-python3.12-uv.yaml --json

Use failures to corroborate ambiguity, not to invent it. A failing test is ambiguous only if the spec supports multiple reasonable interpretations.

5) Report format

Use the following structure for each ambiguous test:

## {test name} ({path}::{node_id})

**Why:** {spec language + alternate interpretation that could be valid}
**Fix:** {proposed test relaxation or spec clarification}

Keep entries concise and actionable. If no ambiguity is found, state that clearly (e.g., "No ambiguity issues found.").

When not to use it

  • When reporting tests that are simply incorrect against explicit requirements
  • When the user needs to fix code directly without ambiguity analysis

Limitations

  • Only reports tests that enforce an interpretation that could reasonably differ given the spec wording
  • Does not fix the code or spec directly, only provides recommendations
  • Optional snapshot verification requires `slop-code` tool

How it compares

This skill systematically identifies and reports ambiguities between specifications and tests, providing actionable fixes, unlike a manual review that might overlook subtle interpretive differences.

Compared to similar skills

checkpoint-ambiguity-review side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
checkpoint-ambiguity-review (this skill)07moReviewIntermediate
python-testing-patterns772moReviewIntermediate
python-playground24moReviewBeginner
mflux-manual-testing21moReviewBeginner

Try saying

Example prompts that trigger this skill in your AI assistant.

Search skills

Search the agent skills registry