[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M730T64KS2FSQVVXW8JB22BS":3,"skill-same:01M730T64KS2FSQVVXW8JB22BS":48},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":25,"commitSha":26,"skillDirectory":27,"forksCount":28,"repositoryHtmlUrl":29,"repositoryHomepageUrl":6,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M730T64KS2FSQVVXW8JB22BS","santa-method",null,"Multi-agent adversarial verification with convergence loop. Two independent review agents must both pass before output ships.","SriramGandhiS\u002FSkills","SriramGandhiS","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F211849986?v=4","01M72WQCW12BYX71C6WN584TTA","Sriram S","01M72WQCWTJ2RD0ET1X31AF1RC",1,"MIT","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fskills\u002Feverything-claude-code\u002Fskills\u002Fsanta-method\u002FSKILL.md",[],[],"2026-11-11 15:11:14",false,"---\nname: santa-method\ndescription: \"Multi-agent adversarial verification with convergence loop. Two independent review agents must both pass before output ships.\"\norigin: \"Ronald Skelton - Founder, RapportScore.ai\"\n---\n\n# Santa Method\n\nMulti-agent adversarial verification framework. Make a list, check it twice. If it's naughty, fix it until it's nice.\n\nThe core insight: a single agent reviewing its own output shares the same biases, knowledge gaps, and systematic errors that produced the output. Two independent reviewers with no shared context break this failure mode.\n\n## When to Activate\n\nInvoke this skill when:\n- Output will be published, deployed, or consumed by end users\n- Compliance, regulatory, or brand constraints must be enforced\n- Code ships to production without human review\n- Content accuracy matters (technical docs, educational material, customer-facing copy)\n- Batch generation at scale where spot-checking misses systemic patterns\n- Hallucination risk is elevated (claims, statistics, API references, legal language)\n\nDo NOT use for internal drafts, exploratory research, or tasks with deterministic verification (use build\u002Ftest\u002Flint pipelines for those).\n\n## Architecture\n\n```\n┌─────────────┐\n│  GENERATOR   │  Phase 1: Make a List\n│  (Agent A)   │  Produce the deliverable\n└──────┬───────┘\n       │ output\n       ▼\n┌──────────────────────────────┐\n│     DUAL INDEPENDENT REVIEW   │  Phase 2: Check It Twice\n│                                │\n│  ┌───────────┐ ┌───────────┐  │  Two agents, same rubric,\n│  │ Reviewer B │ │ Reviewer C │  │  no shared context\n│  └─────┬─────┘ └─────┬─────┘  │\n│        │              │        │\n└────────┼──────────────┼────────┘\n         │              │\n         ▼              ▼\n┌──────────────────────────────┐\n│        VERDICT GATE           │  Phase 3: Naughty or Nice\n│                                │\n│  B passes AND C passes → NICE  │  Both must pass.\n│  Otherwise → NAUGHTY           │  No exceptions.\n└──────┬──────────────┬─────────┘\n       │              │\n    NICE           NAUGHTY\n       │              │\n       ▼              ▼\n   [ SHIP ]    ┌─────────────┐\n               │  FIX CYCLE   │  Phase 4: Fix Until Nice\n               │              │\n               │ iteration++  │  Collect all flags.\n               │ if i > MAX:  │  Fix all issues.\n               │   escalate   │  Re-run both reviewers.\n               │ else:        │  Loop until convergence.\n               │   goto Ph.2  │\n               └──────────────┘\n```\n\n## Phase Details\n\n### Phase 1: Make a List (Generate)\n\nExecute the primary task. No changes to your normal generation workflow. Santa Method is a post-generation verification layer, not a generation strategy.\n\n```python\n# The generator runs as normal\noutput = generate(task_spec)\n```\n\n### Phase 2: Check It Twice (Independent Dual Review)\n\nSpawn two review agents in parallel. Critical invariants:\n\n1. **Context isolation** — neither reviewer sees the other's assessment\n2. **Identical rubric** — both receive the same evaluation criteria\n3. **Same inputs** — both receive the original spec AND the generated output\n4. **Structured output** — each returns a typed verdict, not prose\n\n```python\nREVIEWER_PROMPT = \"\"\"\nYou are an independent quality reviewer. You have NOT seen any other review of this output.\n\n## Task Specification\n{task_spec}\n\n## Output Under Review\n{output}\n\n## Evaluation Rubric\n{rubric}\n\n## Instructions\nEvaluate the output against EACH rubric criterion. For each:\n- PASS: criterion fully met, no issues\n- FAIL: specific issue found (cite the exact problem)\n\nReturn your assessment as structured JSON:\n{\n  \"verdict\": \"PASS\" | \"FAIL\",\n  \"checks\": [\n    {\"criterion\": \"...\", \"result\": \"PASS|FAIL\", \"detail\": \"...\"}\n  ],\n  \"critical_issues\": [\"...\"],   \u002F\u002F blockers that must be fixed\n  \"suggestions\": [\"...\"]         \u002F\u002F non-blocking improvements\n}\n\nBe rigorous. Your job is to find problems, not to approve.\n\"\"\"\n```\n\n```python\n# Spawn reviewers in parallel (Claude Code subagents)\nreview_b = Agent(prompt=REVIEWER_PROMPT.format(...), description=\"Santa Reviewer B\")\nreview_c = Agent(prompt=REVIEWER_PROMPT.format(...), description=\"Santa Reviewer C\")\n\n# Both run concurrently — neither sees the other\n```\n\n### Rubric Design\n\nThe rubric is the most important input. Vague rubrics produce vague reviews. Every criterion must have an objective pass\u002Ffail condition.\n\n| Criterion | Pass Condition | Failure Signal |\n|-----------|---------------|----------------|\n| Factual accuracy | All claims verifiable against source material or common knowledge | Invented statistics, wrong version numbers, nonexistent APIs |\n| Hallucination-free | No fabricated entities, quotes, URLs, or references | Links to pages that don't exist, attributed quotes with no source |\n| Completeness | Every requirement in the spec is addressed | Missing sections, skipped edge cases, incomplete coverage |\n| Compliance | Passes all project-specific constraints | Banned terms used, tone violations, regulatory non-compliance |\n| Internal consistency | No contradictions within the output | Section A says X, section B says not-X |\n| Technical correctness | Code compiles\u002Fruns, algorithms are sound | Syntax errors, logic bugs, wrong complexity claims |\n\n#### Domain-Specific Rubric Extensions\n\n**Content\u002FMarketing:**\n- Brand voice adherence\n- SEO requirements met (keyword density, meta tags, structure)\n- No competitor trademark misuse\n- CTA present and correctly linked\n\n**Code:**\n- Type safety (no `any` leaks, proper null handling)\n- Error handling coverage\n- Security (no secrets in code, input validation, injection prevention)\n- Test coverage for new paths\n\n**Compliance-Sensitive (regulated, legal, financial):**\n- No outcome guarantees or unsubstantiated claims\n- Required disclaimers present\n- Approved terminology only\n- Jurisdiction-appropriate language\n\n### Phase 3: Naughty or Nice (Verdict Gate)\n\n```python\ndef santa_verdict(review_b, review_c):\n    \"\"\"Both reviewers must pass. No partial credit.\"\"\"\n    if review_b.verdict == \"PASS\" and review_c.verdict == \"PASS\":\n        return \"NICE\"  # Ship it\n\n    # Merge flags from both reviewers, deduplicate\n    all_issues = dedupe(review_b.critical_issues + review_c.critical_issues)\n    all_suggestions = dedupe(review_b.suggestions + review_c.suggestions)\n\n    return \"NAUGHTY\", all_issues, all_suggestions\n```\n\nWhy both must pass: if only one reviewer catches an issue, that issue is real. The other reviewer's blind spot is exactly the failure mode Santa Method exists to eliminate.\n\n### Phase 4: Fix Until Nice (Convergence Loop)\n\n```python\nMAX_ITERATIONS = 3\n\nfor iteration in range(MAX_ITERATIONS):\n    verdict, issues, suggestions = santa_verdict(review_b, review_c)\n\n    if verdict == \"NICE\":\n        log_santa_result(output, iteration, \"passed\")\n        return ship(output)\n\n    # Fix all critical issues (suggestions are optional)\n    output = fix_agent.execute(\n        output=output,\n        issues=issues,\n        instruction=\"Fix ONLY the flagged issues. Do not refactor or add unrequested changes.\"\n    )\n\n    # Re-run BOTH reviewers on fixed output (fresh agents, no memory of previous round)\n    review_b = Agent(prompt=REVIEWER_PROMPT.format(output=output, ...))\n    review_c = Agent(prompt=REVIEWER_PROMPT.format(output=output, ...))\n\n# Exhausted iterations — escalate\nlog_santa_result(output, MAX_ITERATIONS, \"escalated\")\nescalate_to_human(output, issues)\n```\n\nCritical: each review round uses **fresh agents**. Reviewers must not carry memory from previous rounds, as prior context creates anchoring bias.\n\n## Implementation Patterns\n\n### Pattern A: Claude Code Subagents (Recommended)\n\nSubagents provide true context isolation. Each reviewer is a separate process with no shared state.\n\n```bash\n# In a Claude Code session, use the Agent tool to spawn reviewers\n# Both agents run in parallel for speed\n```\n\n```python\n# Pseudocode for Agent tool invocation\nreviewer_b = Agent(\n    description=\"Santa Review B\",\n    prompt=f\"Review this output for quality...\\n\\nRUBRIC:\\n{rubric}\\n\\nOUTPUT:\\n{output}\"\n)\nreviewer_c = Agent(\n    description=\"Santa Review C\",\n    prompt=f\"Review this output for quality...\\n\\nRUBRIC:\\n{rubric}\\n\\nOUTPUT:\\n{output}\"\n)\n```\n\n### Pattern B: Sequential Inline (Fallback)\n\nWhen subagents aren't available, simulate isolation with explicit context resets:\n\n1. Generate output\n2. New context: \"You are Reviewer 1. Evaluate ONLY against this rubric. Find problems.\"\n3. Record findings verbatim\n4. Clear context completely\n5. New context: \"You are Reviewer 2. Evaluate ONLY against this rubric. Find problems.\"\n6. Compare both reviews, fix, repeat\n\nThe subagent pattern is strictly superior — inline simulation risks context bleed between reviewers.\n\n### Pattern C: Batch Sampling\n\nFor large batches (100+ items), full Santa on every item is cost-prohibitive. Use stratified sampling:\n\n1. Run Santa on a random sample (10-15% of batch, minimum 5 items)\n2. Categorize failures by type (hallucination, compliance, completeness, etc.)\n3. If systematic patterns emerge, apply targeted fixes to the entire batch\n4. Re-sample and re-verify the fixed batch\n5. Continue until a clean sample passes\n\n```python\nimport random\n\ndef santa_batch(items, rubric, sample_rate=0.15):\n    sample = random.sample(items, max(5, int(len(items) * sample_rate)))\n\n    for item in sample:\n        result = santa_full(item, rubric)\n        if result.verdict == \"NAUGHTY\":\n            pattern = classify_failure(result.issues)\n            items = batch_fix(items, pattern)  # Fix all items matching pattern\n            return santa_batch(items, rubric)   # Re-sample\n\n    return items  # Clean sample → ship batch\n```\n\n## Failure Modes and Mitigations\n\n| Failure Mode | Symptom | Mitigation |\n|-------------|---------|------------|\n| Infinite loop | Reviewers keep finding new issues after fixes | Max iteration cap (3). Escalate. |\n| Rubber stamping | Both reviewers pass everything | Adversarial prompt: \"Your job is to find problems, not approve.\" |\n| Subjective drift | Reviewers flag style preferences, not errors | Tight rubric with objective pass\u002Ffail criteria only |\n| Fix regression | Fixing issue A introduces issue B | Fresh reviewers each round catch regressions |\n| Reviewer agreement bias | Both reviewers miss the same thing | Mitigated by independence, not eliminated. For critical output, add a third reviewer or human spot-check. |\n| Cost explosion | Too many iterations on large outputs | Batch sampling pattern. Budget caps per verification cycle. |\n\n## Integration with Other Skills\n\n| Skill | Relationship |\n|-------|-------------|\n| Verification Loop | Use for deterministic checks (build, lint, test). Santa for semantic checks (accuracy, hallucinations). Run verification-loop first, Santa second. |\n| Eval Harness | Santa Method results feed eval metrics. Track pass@k across Santa runs to measure generator quality over time. |\n| Continuous Learning v2 | Santa findings become instincts. Repeated failures on the same criterion → learned behavior to avoid the pattern. |\n| Strategic Compact | Run Santa BEFORE compacting. Don't lose review context mid-verification. |\n\n## Metrics\n\nTrack these to measure Santa Method effectiveness:\n\n- **First-pass rate**: % of outputs that pass Santa on round 1 (target: >70%)\n- **Mean iterations to convergence**: average rounds to NICE (target: \u003C1.5)\n- **Issue taxonomy**: distribution of failure types (hallucination vs. completeness vs. compliance)\n- **Reviewer agreement**: % of issues flagged by both reviewers vs. only one (low agreement = rubric needs tightening)\n- **Escape rate**: issues found post-ship that Santa should have caught (target: 0)\n\n## Cost Analysis\n\nSanta Method costs approximately 2-3x the token cost of generation alone per verification cycle. For most high-stakes output, this is a bargain:\n\n```\nCost of Santa = (generation tokens) + 2×(review tokens per round) × (avg rounds)\nCost of NOT Santa = (reputation damage) + (correction effort) + (trust erosion)\n```\n\nFor batch operations, the sampling pattern reduces cost to ~15-20% of full verification while catching >90% of systematic issues.\n","# Santa Method\n\nMulti-agent adversarial verification framework. Make a list, check it twice. If it's naughty, fix it until it's nice.\n\nThe core insight: a single agent reviewing its own output shares the same biases, knowledge gaps, and systematic errors that produced the output. Two independent reviewers with no shared context break this failure mode.\n\n## When to Activate\n\nInvoke this skill when:\n- Output will be published, deployed, or consumed by end users\n- Compliance, regulatory, or brand constraints must be enforced\n- Code ships to production without human review\n- Content accuracy matters (technical docs, educational material, customer-facing copy)\n- Batch generation at scale where spot-checking misses systemic patterns\n- Hallucination risk is elevated (claims, statistics, API references, legal language)\n\nDo NOT use for internal drafts, exploratory research, or tasks with deterministic verification (use build\u002Ftest\u002Flint pipelines for those).\n\n## Architecture\n\n```\n┌─────────────┐\n│  GENERATOR   │  Phase 1: Make a List\n│  (Agent A)   │  Produce the deliverable\n└──────┬───────┘\n       │ output\n       ▼\n┌──────────────────────────────┐\n│     DUAL INDEPENDENT REVIEW   │  Phase 2: Check It Twice\n│                                │\n│  ┌───────────┐ ┌───────────┐  │  Two agents, same rubric,\n│  │ Reviewer B │ │ Reviewer C │  │  no shared context\n│  └─────┬─────┘ └─────┬─────┘  │\n│        │              │        │\n└────────┼──────────────┼────────┘\n         │              │\n         ▼              ▼\n┌──────────────────────────────┐\n│        VERDICT GATE           │  Phase 3: Naughty or Nice\n│                                │\n│  B passes AND C passes → NICE  │  Both must pass.\n│  Otherwise → NAUGHTY           │  No exceptions.\n└──────┬──────────────┬─────────┘\n       │              │\n    NICE           NAUGHTY\n       │              │\n       ▼              ▼\n   [ SHIP ]    ┌─────────────┐\n               │  FIX CYCLE   │  Phase 4: Fix Until Nice\n               │              │\n               │ iteration++  │  Collect all flags.\n               │ if i > MAX:  │  Fix all issues.\n               │   escalate   │  Re-run both reviewers.\n               │ else:        │  Loop until convergence.\n               │   goto Ph.2  │\n               └──────────────┘\n```\n\n## Phase Details\n\n### Phase 1: Make a List (Generate)\n\nExecute the primary task. No changes to your normal generation workflow. Santa Method is a post-generation verification layer, not a generation strategy.\n\n```python\n# The generator runs as normal\noutput = generate(task_spec)\n```\n\n### Phase 2: Check It Twice (Independent Dual Review)\n\nSpawn two review agents in parallel. Critical invariants:\n\n1. **Context isolation** — neither reviewer sees the other's assessment\n2. **Identical rubric** — both receive the same evaluation criteria\n3. **Same inputs** — both receive the original spec AND the generated output\n4. **Structured output** — each returns a typed verdict, not prose\n\n```python\nREVIEWER_PROMPT = \"\"\"\nYou are an independent quality reviewer. You have NOT seen any other review of this output.\n\n## Task Specification\n{task_spec}\n\n## Output Under Review\n{output}\n\n## Evaluation Rubric\n{rubric}\n\n## Instructions\nEvaluate the output against EACH rubric criterion. For each:\n- PASS: criterion fully met, no issues\n- FAIL: specific issue found (cite the exact problem)\n\nReturn your assessment as structured JSON:\n{\n  \"verdict\": \"PASS\" | \"FAIL\",\n  \"checks\": [\n    {\"criterion\": \"...\", \"result\": \"PASS|FAIL\", \"detail\": \"...\"}\n  ],\n  \"critical_issues\": [\"...\"],   \u002F\u002F blockers that must be fixed\n  \"suggestions\": [\"...\"]         \u002F\u002F non-blocking improvements\n}\n\nBe rigorous. Your job is to find problems, not to approve.\n\"\"\"\n```\n\n```python\n# Spawn reviewers in parallel (Claude Code subagents)\nreview_b = Agent(prompt=REVIEWER_PROMPT.format(...), description=\"Santa Reviewer B\")\nreview_c = Agent(prompt=REVIEWER_PROMPT.format(...), description=\"Santa Reviewer C\")\n\n# Both run concurrently — neither sees the other\n```\n\n### Rubric Design\n\nThe rubric is the most important input. Vague rubrics produce vague reviews. Every criterion must have an objective pass\u002Ffail condition.\n\n| Criterion | Pass Condition | Failure Signal |\n|-----------|---------------|----------------|\n| Factual accuracy | All claims verifiable against source material or common knowledge | Invented statistics, wrong version numbers, nonexistent APIs |\n| Hallucination-free | No fabricated entities, quotes, URLs, or references | Links to pages that don't exist, attributed quotes with no source |\n| Completeness | Every requirement in the spec is addressed | Missing sections, skipped edge cases, incomplete coverage |\n| Compliance | Passes all project-specific constraints | Banned terms used, tone violations, regulatory non-compliance |\n| Internal consistency | No contradictions within the output | Section A says X, section B says not-X |\n| Technical correctness | Code compiles\u002Fruns, algorithms are sound | Syntax errors, logic bugs, wrong complexity claims |\n\n#### Domain-Specific Rubric Extensions\n\n**Content\u002FMarketing:**\n- Brand voice adherence\n- SEO requirements met (keyword density, meta tags, structure)\n- No competitor trademark misuse\n- CTA present and correctly linked\n\n**Code:**\n- Type safety (no `any` leaks, proper null handling)\n- Error handling coverage\n- Security (no secrets in code, input validation, injection prevention)\n- Test coverage for new paths\n\n**Compliance-Sensitive (regulated, legal, financial):**\n- No outcome guarantees or unsubstantiated claims\n- Required disclaimers present\n- Approved terminology only\n- Jurisdiction-appropriate language\n\n### Phase 3: Naughty or Nice (Verdict Gate)\n\n```python\ndef santa_verdict(review_b, review_c):\n    \"\"\"Both reviewers must pass. No partial credit.\"\"\"\n    if review_b.verdict == \"PASS\" and review_c.verdict == \"PASS\":\n        return \"NICE\"  # Ship it\n\n    # Merge flags from both reviewers, deduplicate\n    all_issues = dedupe(review_b.critical_issues + review_c.critical_issues)\n    all_suggestions = dedupe(review_b.suggestions + review_c.suggestions)\n\n    return \"NAUGHTY\", all_issues, all_suggestions\n```\n\nWhy both must pass: if only one reviewer catches an issue, that issue is real. The other reviewer's blind spot is exactly the failure mode Santa Method exists to eliminate.\n\n### Phase 4: Fix Until Nice (Convergence Loop)\n\n```python\nMAX_ITERATIONS = 3\n\nfor iteration in range(MAX_ITERATIONS):\n    verdict, issues, suggestions = santa_verdict(review_b, review_c)\n\n    if verdict == \"NICE\":\n        log_santa_result(output, iteration, \"passed\")\n        return ship(output)\n\n    # Fix all critical issues (suggestions are optional)\n    output = fix_agent.execute(\n        output=output,\n        issues=issues,\n        instruction=\"Fix ONLY the flagged issues. Do not refactor or add unrequested changes.\"\n    )\n\n    # Re-run BOTH reviewers on fixed output (fresh agents, no memory of previous round)\n    review_b = Agent(prompt=REVIEWER_PROMPT.format(output=output, ...))\n    review_c = Agent(prompt=REVIEWER_PROMPT.format(output=output, ...))\n\n# Exhausted iterations — escalate\nlog_santa_result(output, MAX_ITERATIONS, \"escalated\")\nescalate_to_human(output, issues)\n```\n\nCritical: each review round uses **fresh agents**. Reviewers must not carry memory from previous rounds, as prior context creates anchoring bias.\n\n## Implementation Patterns\n\n### Pattern A: Claude Code Subagents (Recommended)\n\nSubagents provide true context isolation. Each reviewer is a separate process with no shared state.\n\n```bash\n# In a Claude Code session, use the Agent tool to spawn reviewers\n# Both agents run in parallel for speed\n```\n\n```python\n# Pseudocode for Agent tool invocation\nreviewer_b = Agent(\n    description=\"Santa Review B\",\n    prompt=f\"Review this output for quality...\\n\\nRUBRIC:\\n{rubric}\\n\\nOUTPUT:\\n{output}\"\n)\nreviewer_c = Agent(\n    description=\"Santa Review C\",\n    prompt=f\"Review this output for quality...\\n\\nRUBRIC:\\n{rubric}\\n\\nOUTPUT:\\n{output}\"\n)\n```\n\n### Pattern B: Sequential Inline (Fallback)\n\nWhen subagents aren't available, simulate isolation with explicit context resets:\n\n1. Generate output\n2. New context: \"You are Reviewer 1. Evaluate ONLY against this rubric. Find problems.\"\n3. Record findings verbatim\n4. Clear context completely\n5. New context: \"You are Reviewer 2. Evaluate ONLY against this rubric. Find problems.\"\n6. Compare both reviews, fix, repeat\n\nThe subagent pattern is strictly superior — inline simulation risks context bleed between reviewers.\n\n### Pattern C: Batch Sampling\n\nFor large batches (100+ items), full Santa on every item is cost-prohibitive. Use stratified sampling:\n\n1. Run Santa on a random sample (10-15% of batch, minimum 5 items)\n2. Categorize failures by type (hallucination, compliance, completeness, etc.)\n3. If systematic patterns emerge, apply targeted fixes to the entire batch\n4. Re-sample and re-verify the fixed batch\n5. Continue until a clean sample passes\n\n```python\nimport random\n\ndef santa_batch(items, rubric, sample_rate=0.15):\n    sample = random.sample(items, max(5, int(len(items) * sample_rate)))\n\n    for item in sample:\n        result = santa_full(item, rubric)\n        if result.verdict == \"NAUGHTY\":\n            pattern = classify_failure(result.issues)\n            items = batch_fix(items, pattern)  # Fix all items matching pattern\n            return santa_batch(items, rubric)   # Re-sample\n\n    return items  # Clean sample → ship batch\n```\n\n## Failure Modes and Mitigations\n\n| Failure Mode | Symptom | Mitigation |\n|-------------|---------|------------|\n| Infinite loop | Reviewers keep finding new issues after fixes | Max iteration cap (3). Escalate. |\n| Rubber stamping | Both reviewers pass everything | Adversarial prompt: \"Your job is to find problems, not approve.\" |\n| Subjective drift | Reviewers flag style preferences, not errors | Tight rubric with objective pass\u002Ffail criteria only |\n| Fix regression | Fixing issue A introduces issue B | Fresh reviewers each round catch regressions |\n| Reviewer agreement bias | Both reviewers miss the same thing | Mitigated by independence, not eliminated. For critical output, add a third reviewer or human spot-check. |\n| Cost explosion | Too many iterations on large outputs | Batch sampling pattern. Budget caps per verification cycle. |\n\n## Integration with Other Skills\n\n| Skill | Relationship |\n|-------|-------------|\n| Verification Loop | Use for deterministic checks (build, lint, test). Santa for semantic checks (accuracy, hallucinations). Run verification-loop first, Santa second. |\n| Eval Harness | Santa Method results feed eval metrics. Track pass@k across Santa runs to measure generator quality over time. |\n| Continuous Learning v2 | Santa findings become instincts. Repeated failures on the same criterion → learned behavior to avoid the pattern. |\n| Strategic Compact | Run Santa BEFORE compacting. Don't lose review context mid-verification. |\n\n## Metrics\n\nTrack these to measure Santa Method effectiveness:\n\n- **First-pass rate**: % of outputs that pass Santa on round 1 (target: >70%)\n- **Mean iterations to convergence**: average rounds to NICE (target: \u003C1.5)\n- **Issue taxonomy**: distribution of failure types (hallucination vs. completeness vs. compliance)\n- **Reviewer agreement**: % of issues flagged by both reviewers vs. only one (low agreement = rubric needs tightening)\n- **Escape rate**: issues found post-ship that Santa should have caught (target: 0)\n\n## Cost Analysis\n\nSanta Method costs approximately 2-3x the token cost of generation alone per verification cycle. For most high-stakes output, this is a bargain:\n\n```\nCost of Santa = (generation tokens) + 2×(review tokens per round) × (avg rounds)\nCost of NOT Santa = (reputation damage) + (correction effort) + (trust erosion)\n```\n\nFor batch operations, the sampling pattern reduces cost to ~15-20% of full verification while catching >90% of systematic issues.\n",{"name":5,"origin":24,"description":7},"Ronald Skelton - Founder, RapportScore.ai","master","d6ca01da0f24a3b0e26e4a8b7b66cbd25d429f5d","skills\u002Feverything-claude-code\u002Fskills\u002Fsanta-method",0,"https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills","https:\u002F\u002Fgithub.com\u002FSriramGandhiS","https:\u002F\u002Fsriram.website\u002F","Curious guy who keeps tinkering until something works","2026-05-20 16:21:34",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add SriramGandhiS\u002FSkills --skill santa-method",{"tool":40,"command":41},"bunx","bunx skills add SriramGandhiS\u002FSkills --skill santa-method",{"tool":43,"command":44},"pnpm","pnpm dlx skills add SriramGandhiS\u002FSkills --skill santa-method","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fskills\u002Feverything-claude-code\u002Fskills\u002Fsanta-method\u002FSKILL.md",true,[],[49,56,61,67,74,81],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":55,"publishedAt":19},"01M732609EPJWV13PVTX3GT4TM","webgpu-threejs-tsl","Comprehensive guide for developing WebGPU-enabled Three.js applications using TSL (Three.js Shading Language). Covers WebGPU renderer setup, TSL syntax and node materials, compute shaders, post-processing effects, and WGSL integration. Use this skill when working with Three.js WebGPU, TSL shaders, node materials, or GPU compute in Three.js.","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fwebgpu-threejs-tsl\u002Fskills\u002Fwebgpu-threejs-tsl\u002FSKILL.md",[],[],{"skillNo":57,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":58,"categories":59,"keywords":60,"publishedAt":19},"01M7325XM47AGWB6K6C4VXKE6B","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fwebgpu-threejs-tsl\u002FSKILL.md",[],[],{"skillNo":62,"name":63,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":19},"01M7325WP6DES69JKC840VMFEP","verification-loop","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-TW\u002Fskills\u002Fverification-loop\u002FSKILL.md",[],[],{"skillNo":68,"name":69,"nameZh":6,"description":70,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":71,"categories":72,"keywords":73,"publishedAt":19},"01M7325TFQF1DZTQ6J3WGQQ1VR","tdd-workflow","Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests.","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-TW\u002Fskills\u002Ftdd-workflow\u002FSKILL.md",[],[],{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":19},"01M7325RGV9AY9PK92D2V8KKPW","strategic-compact","Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction.","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-TW\u002Fskills\u002Fstrategic-compact\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":19},"01M7325MZC28SE86E7NMCNEFS4","security-review","Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment\u002Fsensitive features. Provides comprehensive security checklist and patterns.","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-TW\u002Fskills\u002Fsecurity-review\u002FSKILL.md",[],[]]