Mine Comb

Fine-Toothed Comb

A one-off, open-ended holistic review of an artifact — a brief, design doc, plan, spec, or an implementation against the design it was built from. It is not a checklist or rubric: it takes the artifact in as a whole and surfaces what a structured pass can't — the doc reading as inconsistent, inaccurate, or thin; a requirement silently dropped; behavior that drifted from intent.

This is the standalone form of the comb that mine-define (Phase 5.5), mine-plan (Phase 5.5), and mine-sketch (Phase 4) run inside their workflows. Reach for this skill to comb something those workflows didn't produce — a brief written by hand, a design from elsewhere, an implementation whose design lives in a doc.

Phase 1: Resolve the target

Determine what to comb and whether there's a reference to comb against:

• Single artifact — the user points at one file or doc ("comb this brief"). Comb it for internal consistency, accuracy, and thoroughness.
• Artifact against a reference — the user names both ("comb the implementation against the design", "do the tasks match the design"). Read the reference first, then comb the artifact for fidelity.

If the reference is a design.md with a terminal **Status:** (archived or abandoned), tell the agent so in the dispatch prompt — see Phase 2. That doc is frozen; drift from it isn't something to reconcile.

If the target is ambiguous (no path given, several candidates), ask the user which artifact and whether there's a reference — one focused AskUserQuestion, then proceed.

Pick the model:

• Default: dispatch the agent on its declared model (sonnet) — right for docs, briefs, plans, and implementation diffs. Sonnet 5 has a 1M context window, which handles large diffs without compaction risk.
• For diffs so large that design + diff exceeds ~900k tokens, comb by file group and reconcile.

Phase 2: Dispatch the comb

Agent:
  subagent_type: fine-toothed-comb
  prompt: |
    <For a single artifact:>
    Read this <artifact type>: <path>
    Go over it with a fine-toothed comb and make sure it's accurate, consistent,
    and thorough. Report anything you find.

    <For an artifact against a reference, instead:>
    Read this reference: <reference path(s)>
    Then read/get the artifact: <path, or the diff command>
    Go over the artifact against the reference with a fine-toothed comb — is it
    consistent, accurate, and thorough; is everything the reference specified
    actually present; did anything get silently dropped or drift. Report anything
    you find.

    <Always:>
    Define blocking as: an inconsistency, inaccuracy, gap, or drift that would
    mislead whoever acts on this next<, or make the artifact wrong relative to
    the reference — if a reference was given>.

    <If the reference is a design.md with Status: archived or abandoned, add:>
    The reference design.md is terminal-status (archived/abandoned): it's frozen,
    documenting a past decision rather than a live spec. Do not report drift from
    it as a finding, and do not suggest editing its body sections; note any
    Addendum-worthy divergence separately, non-blocking.

The agent classifies findings and returns a ## Summary line plus grouped findings. (See ${CLAUDE_CONFIG_DIR:-~/.claude}/agents/fine-toothed-comb.md.)

Phase 3: Comb gate

Read ${CLAUDE_CONFIG_DIR:-~/.claude}/skills/mine-comb/comb-gate.md and apply it with:

• <header>: Comb
• minor_blocks: true — the user invoked this to make a call on what it finds, so surface minor findings too
• <proceed_label> / <proceed_description>: Fix and finish / "Fix the findings but skip the next comb — I'm done here"
• <re_review_instructions>: apply the fixes to the combed artifact (only the listed findings — don't expand scope), then re-comb from the top

On a clean comb (or once findings are fixed), report the final result to the user: the summary and any remaining minor findings.