Claude Cursor Skill

meta-verify

Runs a second-pass quality check on a skill's output before it goes out, re-checking it against the originating skill's Quality Gate and Operating Rules and returning specific fixes, not just pass/fail. Trigger on: "verify this", "check this before I send it", "second-pass this b

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Download stefanoskarakasis-product-marketing-skills-pmm-meta_skills_meta-verify-5de42dc.zip · 4 KB

Install

skills CLI npx skills add https://github.com/stefanoskarakasis/Product-Marketing-Skills/tree/main/pmm-meta/skills/meta-verify
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install stefanoskarakasis-product-marketing-skills@llmmart
Git git clone https://github.com/stefanoskarakasis/Product-Marketing-Skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole stefanoskarakasis/product-marketing-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

meta-verify

A second pair of eyes on a skill's output, applying the exact standard the originating skill already committed to — its own ## Quality Gate table and ## Operating Rules. Catches what the first pass missed, especially when the same session that produced the output is also the one that's about to mark it done.

This isn't a second opinion using a different, invented rubric — it's a faithful re-application of the standard that skill already declared for itself. If a skill's own Quality Gate is weak, that's a meta-review finding against that skill's SKILL.md, not something this skill compensates for by inventing its own scoring.

Trigger

  • When: A skill has produced output and it's about to be delivered externally (sent to sales, shared with leadership, published) — a second pass before it leaves the building.

  • Not for: Auditing a SKILL.md's own structure → use meta-review. Extracting learnings from a completed session → use meta-learn. Detecting patterns across sessions → use meta-synthesis.

  • Example prompts:

    • "Check this positioning brief before I send it"
    • "Verify the last GTM strategy output"
    • "Did this retro actually pass its own quality gate?"
    • "Second-pass this before it goes to leadership"

Inputs

  • Args: The output to verify, and which skill produced it. N/A if invoked immediately after that skill's own session — infer both from context.
  • Defaults: If the originating skill isn't obvious from the output itself, ask.
  • Context keys: The originating skill's own SKILL.md — specifically its ## Quality Gate and ## Operating Rules sections. No brain context needed beyond what the originating skill itself required.

Pre-flight

  • Load the originating skill's SKILL.md. If it doesn't exist or doesn't declare quality_gate: true, say so — there's no standard to re-check against, and this skill isn't the place to invent one on the spot.
  • This skill is context-agnostic. It applies the originating skill's own declared standard; it does not load /foundation/brain.md independently.

Steps

Step 1: Load the Originating Standard

Read the originating skill's ## Quality Gate table and ## Operating Rules in full. These are the only standard this pass applies — not a generic rubric, not this skill's own opinion of what "good" looks like.

Step 2: Re-run Every Quality Gate Check

For each row in the originating skill's Quality Gate table, check the actual output against it independently — don't trust that the first pass marked it correctly. Mark each pass/fail with the specific evidence.

## Second-Pass Verification — [skill-name] output

| Check (from [skill-name]'s own Quality Gate) | Pass? | Evidence |
|---|---|---|
| [Check name] | ✅ / ❌ | [Specific quote or observation] |

Step 3: Spot-Check Operating Rules

Operating Rules aren't a checklist — they're standing constraints. Scan the output against each rule from the originating skill and flag any it appears to violate, even if the Quality Gate table doesn't have a matching row for it.

Step 4: Report

## meta-verify — [skill-name] output

**Quality Gate:** [N]/[total] passed
**Operating Rules:** [clean / N flagged]

### Failed checks
- [Check] — [specific evidence of the gap, and what would fix it]

### Rule flags
- [Rule] — [where the output appears to violate it]

### Verdict
[CLEARS SECOND PASS / NEEDS FIXES BEFORE DELIVERY] — [one sentence]

If everything passes, say so plainly. Don't invent soft findings to seem thorough — a clean pass is a legitimate, useful result.

Outputs

  • Files written: N/A — this skill produces a report only.
  • Chat output format: The verification report from Step 4.
  • External side effects: N/A

Verification

  • Every row of the originating skill's actual Quality Gate table was re-checked, not assumed passed from the first run.
  • Operating Rules were scanned even where no Quality Gate row corresponds to them.
  • Every failed check has specific evidence, not a generic "doesn't meet standard."

Do Not Use For

  • meta-review — when the task is auditing the skill file itself (SKILL.md structure) rather than one piece of output it produced
  • meta-learn — when the task is capturing what the session taught the user, not re-checking output correctness
  • meta-synthesis — when the task is finding a pattern across multiple sessions, not a single output's quality

Operating Rules

  • Apply the originating skill's own standard — never a substitute one. This skill has no independent rubric. If the originating skill's Quality Gate is thin, that's a finding for meta-review against that skill, not something to paper over here with invented criteria.
  • Re-check independently, don't trust the first pass. The value of a second pass is that it doesn't inherit the first pass's blind spots.
  • Evidence, not adjectives. Every fail cites the specific text or gap — "positioning statement absent" not "positioning could be stronger."
  • Operating Rules matter even without a matching gate row. A skill's rules are binding regardless of whether its own Quality Gate table happens to test each one.
  • A clean pass is a real result. Don't manufacture findings to justify having run. If nothing failed, report that plainly.
  • No skill has a quality gate → no verification possible. If quality_gate: false or the section is missing, say clearly that there's no standard to check against rather than inventing one.

Quality Gate

Check Standard Pass =
Originating skill loaded SKILL.md and its own Quality Gate read before scoring Yes
Every gate row re-checked No row skipped or assumed from first pass Yes
Operating Rules scanned Checked even without a matching gate row Yes
Evidence specific Every fail cites the actual gap, not a vague label Yes
Verdict stated plainly Clear pass/needs-fixes call, not just a score Yes
Files (product-marketing-skills)
  • evals
    • meta-verify.eval.md 3.4 KB
      Loading…
  • SKILL.md 6.6 KB
    ---
    name: meta-verify
    version: 3.0.0
    description: >
      Runs a second-pass quality check on a skill's output before it goes out, re-checking it
      against the originating skill's Quality Gate and Operating Rules and returning specific
      fixes, not just pass/fail. Trigger on: "verify this", "check this before I send it",
      "second-pass this brief", "did that pass quality gate", or any request to re-check a
      skill's output before it's delivered externally.
    metadata:
      author: Stefanos Karakasis
      context: context-agnostic
      quality_gate: true
    last_updated: 2026-08-22
    ---
    
    # meta-verify
    
    A second pair of eyes on a skill's output, applying the exact standard the
    originating skill already committed to — its own `## Quality Gate` table and
    `## Operating Rules`. Catches what the first pass missed, especially when
    the same session that produced the output is also the one that's about to
    mark it done.
    
    This isn't a second opinion using a different, invented rubric — it's a
    faithful re-application of the standard that skill already declared for
    itself. If a skill's own Quality Gate is weak, that's a `meta-review`
    finding against that skill's `SKILL.md`, not something this skill
    compensates for by inventing its own scoring.
    
    ## Trigger
    
    - **When:** A skill has produced output and it's about to be delivered
      externally (sent to sales, shared with leadership, published) — a second
      pass before it leaves the building.
    
    - **Not for:** Auditing a `SKILL.md`'s own structure → use `meta-review`.
      Extracting learnings from a completed session → use `meta-learn`.
      Detecting patterns across sessions → use `meta-synthesis`.
    
    - **Example prompts:**
      - "Check this positioning brief before I send it"
      - "Verify the last GTM strategy output"
      - "Did this retro actually pass its own quality gate?"
      - "Second-pass this before it goes to leadership"
    
    ## Inputs
    
    - **Args:** The output to verify, and which skill produced it. `N/A` if
      invoked immediately after that skill's own session — infer both from
      context.
    - **Defaults:** If the originating skill isn't obvious from the output
      itself, ask.
    - **Context keys:** The originating skill's own `SKILL.md` — specifically
      its `## Quality Gate` and `## Operating Rules` sections. No brain context
      needed beyond what the originating skill itself required.
    
    ## Pre-flight
    
    - Load the originating skill's `SKILL.md`. If it doesn't exist or doesn't
      declare `quality_gate: true`, say so — there's no standard to re-check
      against, and this skill isn't the place to invent one on the spot.
    - This skill is context-agnostic. It applies the originating skill's own
      declared standard; it does not load `/foundation/brain.md` independently.
    
    ## Steps
    
    ### Step 1: Load the Originating Standard
    
    Read the originating skill's `## Quality Gate` table and `## Operating
    Rules` in full. These are the only standard this pass applies — not a
    generic rubric, not this skill's own opinion of what "good" looks like.
    
    ### Step 2: Re-run Every Quality Gate Check
    
    For each row in the originating skill's Quality Gate table, check the actual
    output against it independently — don't trust that the first pass marked it
    correctly. Mark each pass/fail with the specific evidence.
    
    ```markdown
    ## Second-Pass Verification — [skill-name] output
    
    | Check (from [skill-name]'s own Quality Gate) | Pass? | Evidence |
    |---|---|---|
    | [Check name] | ✅ / ❌ | [Specific quote or observation] |
    ```
    
    ### Step 3: Spot-Check Operating Rules
    
    Operating Rules aren't a checklist — they're standing constraints. Scan the
    output against each rule from the originating skill and flag any it appears
    to violate, even if the Quality Gate table doesn't have a matching row for
    it.
    
    ### Step 4: Report
    
    ```markdown
    ## meta-verify — [skill-name] output
    
    **Quality Gate:** [N]/[total] passed
    **Operating Rules:** [clean / N flagged]
    
    ### Failed checks
    - [Check] — [specific evidence of the gap, and what would fix it]
    
    ### Rule flags
    - [Rule] — [where the output appears to violate it]
    
    ### Verdict
    [CLEARS SECOND PASS / NEEDS FIXES BEFORE DELIVERY] — [one sentence]
    ```
    
    If everything passes, say so plainly. Don't invent soft findings to seem
    thorough — a clean pass is a legitimate, useful result.
    
    ## Outputs
    
    - **Files written:** N/A — this skill produces a report only.
    - **Chat output format:** The verification report from Step 4.
    - **External side effects:** N/A
    
    ## Verification
    
    - Every row of the originating skill's actual Quality Gate table was
      re-checked, not assumed passed from the first run.
    - Operating Rules were scanned even where no Quality Gate row corresponds
      to them.
    - Every failed check has specific evidence, not a generic "doesn't meet
      standard."
    
    ## Do Not Use For
    
    - **meta-review** — when the task is auditing the *skill file itself*
      (`SKILL.md` structure) rather than one piece of output it produced
    - **meta-learn** — when the task is capturing what the session taught the
      user, not re-checking output correctness
    - **meta-synthesis** — when the task is finding a pattern across multiple
      sessions, not a single output's quality
    
    ## Operating Rules
    
    - **Apply the originating skill's own standard — never a substitute one.**
      This skill has no independent rubric. If the originating skill's Quality
      Gate is thin, that's a finding for `meta-review` against that skill, not
      something to paper over here with invented criteria.
    - **Re-check independently, don't trust the first pass.** The value of a
      second pass is that it doesn't inherit the first pass's blind spots.
    - **Evidence, not adjectives.** Every fail cites the specific text or gap —
      "positioning statement absent" not "positioning could be stronger."
    - **Operating Rules matter even without a matching gate row.** A skill's
      rules are binding regardless of whether its own Quality Gate table
      happens to test each one.
    - **A clean pass is a real result.** Don't manufacture findings to justify
      having run. If nothing failed, report that plainly.
    - **No skill has a quality gate → no verification possible.** If
      `quality_gate: false` or the section is missing, say clearly that there's
      no standard to check against rather than inventing one.
    
    ## Quality Gate
    
    | Check | Standard | Pass = |
    |---|---|---|
    | Originating skill loaded | `SKILL.md` and its own Quality Gate read before scoring | Yes |
    | Every gate row re-checked | No row skipped or assumed from first pass | Yes |
    | Operating Rules scanned | Checked even without a matching gate row | Yes |
    | Evidence specific | Every fail cites the actual gap, not a vague label | Yes |
    | Verdict stated plainly | Clear pass/needs-fixes call, not just a score | Yes |
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.