Skip to main content
skill CX Codex

benchmark-due-diligence — Claude Code skill: tear down a rival's

Runs adversarial due diligence on a benchmark that looks inflated, splits marketing bubble from real signal, and maps the playbook onto your own resources.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add daymade/claude-code-skills --skill benchmark-due-diligence -a claude-code
Open on GitHub

What benchmark-due-diligence does

The skill takes a benchmark you envy — a founder, KOL, company or product whose success looks suspiciously shiny — and produces a teardown that ends in what it means for you, not a neutral report. It answers three things a balanced briefing skips: how much of the success is real, how much is replicable method, and what you can actually do with it.

It works as an orchestrator, spawning parallel collection and verification agents through Workflow or Task, and can call other skills such as deep-research and osint-investigate. Run it inline only. Add context: fork and subagents can no longer spawn subagents, so the whole fan-out breaks silently. Phase 0 insists you confirm the entity graph and the attribution of the headline claim by evidence first: a shared domain or a similar name is an observation, not ownership.

Input is split into two channels. Verified public facts reach every agent; the commissioner's private context reaches only the final mapping agent. Leak client names or strategy into collection prompts and they get searched on the open web. That is worth checking before you run it on anything sensitive.

What it helps with

  • separate a competitor's real metrics from marketing noise
  • check who actually owns the trophy claim
  • split success into replicable method and luck or timing
  • hunt falsifying evidence for inflated numbers
  • map someone else's playbook onto assets you control, not client assets

Example prompts for the agent

  • Tear down this product with benchmark-due-diligence: how much of its growth is real and what can I copy
  • Run due diligence on this company, their claimed reach looks off to me
  • Compare their playbook against my resources and tell me what actually transfers

How to install benchmark-due-diligence

1Skills CLI (Vercel)

npx skills add daymade/claude-code-skills --skill benchmark-due-diligence -a claude-code

2Manually: put the files in place

~/.claude/skills/benchmark-due-diligence/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/benchmark-due-diligence/

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

Questions about benchmark-due-diligence

How do I install benchmark-due-diligence in Claude?

Install it from the skills marketplace: npx skills add daymade/claude-code-skills --skill benchmark-due-diligence -a claude-code. The skill then lives at ~/.claude/skills/benchmark-due-diligence/SKILL.md.

What does benchmark-due-diligence do?

It runs adversarial due diligence on a benchmark whose success looks inflated, separates marketing bubble from real signal, and maps the validated playbook onto the commissioner's own resources.

How is it different from deep-research?

deep-research builds a trustworthy picture of the world. This skill assumes the picture is inflated until proven otherwise, so reach for it when you are debunking claims rather than writing a neutral briefing.

Source text

SKILL.md · MIT
---
name: benchmark-due-diligence
description: >-
  Runs adversarial due-diligence on a benchmark the user envies — a founder, KOL, company, or
  product whose success looks inflated — splitting marketing bubble from real signal, then mapping
  the validated playbook onto the user's own resources. Use for 尽调/对标/拆解 a competitor, 抄/偷师 their
  playbook, or suspecting 水分/泡沫 in claims. Prefer over deep-research when debunking inflated claims,
  not a neutral briefing.
---

# Benchmark Due Diligence

Take a benchmark the user envies — a founder, KOL, company, or product whose success looks suspiciously shiny — and produce a teardown that ends in **"what this means for ME"**, not a neutral report. The deliverable answers three questions a balanced briefing never does: *How much of this success is real vs marketing bubble? How much is replicable method vs luck/timing? And what, specifically, can the commissioner do with it?*

This is the adversarial, decision-oriented cousin of `deep-research`. Where deep-research builds a trustworthy picture of the world, this skill **assumes the picture is inflated until proven otherwise** and converts the survivors into the commissioner's own moves.

## CRITICAL: run inline, never `context: fork`

This skill is an **orchestrator** — it spawns parallel collection + verification agents (via the `Workflow` tool, or `Task` agents) and may invoke other skills (`deep-research`, `osint-investigate`, `qcc`). Subagents cannot spawn subagents or call skills. Setting `context: fork` would silently break the entire fan-out. **Do not add a `context` field.** (Same constraint osint-investigate documents — it's a hard runtime rule, not a preference.)

## The one rule that protects the commissioner: two injection channels

Everything the agents see flows through exactly two channels. Keeping them separate is the single most important discipline in this skill:

| Channel | Content | Injected into |
|---|---|---|
| **FACTS** | Already-verified *public* facts about the benchmark (relationships, who-owns-what, the headline claim flagged `⚠️ to-verify`) | **Every** agent — collection, verification, synthesis |
| **COMMISSIONER_CONTEXT** | The commissioner's *private* reality — real resources, client names, strategic intent, what they can actually leverage | **Only the final mapping agent (Phase 4)** |

**Why this split is non-negotiable:** collection and verification agents take their input and run external `WebSearch` on it. If the commissioner's client names or strategy leak into those prompts, they get searched on the open web — a privacy breach. The mapping phase genuinely needs "who is the commissioner"; the collection phase must never see it. Encode this in the orchestration (see `references/workflow_orchestration_template.md`), don't rely on remembering it mid-run.

## Phase 0 — nail the foundation by evidence, not appearance (do this BEFORE any agent)

The fastest way to waste a 12-agent fan-out is to build it on a foundation you *inferred from appearances*. Two failure modes recur and both have burned real runs:

1. **Inferring relationships between entities from names/domains.** "Their content lives at `academy.example.com`, and they're the founder, so they must own that community" — when in reality they were just an invited guest. A shared domain, a similar name, or co-occurrence is an **observation**, not ownership. Verify with an authoritative source before treating any A↔B relationship as fact.
2. **Treating the commissioner's *client* as the commissioner's *asset*.** If the commissioner does service work for an accelerator/brand, that accelerator is the *client's* asset — the commissioner can't leverage its audience or capital. Mapping the benchmark's playbook onto resources the commissioner doesn't actually control produces castles in the air.

So before fanning out, establish by evidence (not vibes):
- **The benchmark's real entity graph** — who owns whom, who merely partners/guests. Don't reason from names.
- **The headline-claim attribution** — the benchmark's whole narrative usually rests on one trophy stat ("took product X from 0 → 1M users"). Are they the founder, or the *departed growth lead*? This is the **#1 to-verify target**; write it into FACTS with a `⚠️`.
- **What the commissioner truly controls** — separate *owned assets* from *client/partner assets*.

Write the results into `FACTS` (public half) and `COMMISSIONER_CONTEXT` (private half). A shaky foundation makes every downstream agent confidently wrong.

## The four-phase orchestration

Use the `Workflow` tool (preferred — deterministic fan-out, see the ready-to-fill template in `references/workflow_orchestration_template.md`) or `Task` agents. Scale agent count to how thorough the user wants (a few dimensions for a quick read, 6+ with multi-vote verification for a deep audit).

**Phase 1 + 2 — collect → verify, per dimension, as a pipeline** (each dimension verifies the moment its collection finishes; no global barrier):

- **Collection agent** — *objective* stance. Every finding carries a source URL and a `source_kind` (`对象自述/营销` vs `第三方独立信源` vs `混合`). Anything not found goes in `gaps` — **never** filled by guessing.
- **Verification agent** — *adversarial, default-skeptical* stance. Grade every claim `L1–L4` and rule `坐实 / 大体可信 / 存疑 / 证伪-水分`. The job is to actively hunt **falsifying** evidence, especially for the headline claims (the trophy stat, "#1 ranking", funding amount, user counts). `bubble_summary` names the biggest water in that dimension.

Grading rubric, `source_kind`, verdicts, and both JSON schemas → **`references/evidence_grading_rubric.md`**.

Typical dimensions (tailor to the benchmark type — person / company / product):
1. Subject background **+ headline-claim attribution** (the #1 bubble target)
2. Corporate base — entity, founding, funding/valuation
3. Core product/business **real metrics** — user counts, revenue, rankings, awards, cross-verified against third parties
4. Playbook teardown — platform matrix, persona, content types, how they borrow other people's audiences, how personal IP funnels to the product
5. Comparison sample — a structurally-similar peer or parallel path
6. Sector + how this class of playbook usually wins **and usually fails**

**Phase 3 — synthesis: due-diligence conclusion** (single agent, consumes all verdicts):
1. Real relationship map (correcting the common misreadings from Phase 0)
2. **Bubble-busting table** — claim | evidence level | verdict | one-line basis, sorted by most-water-first
3. Playbook teardown — concrete, copyable actions
4. **Attribution breakdown (the core)** — what share of the success is product vs market-timing vs personal-IP-marketing vs operations? Give % ranges with reasons, and explicitly split *replicable method* from *luck / timing / non-transferable endowment*.

**Phase 4 — synthesis: what this means for the commissioner** (single agent; consumes Phase 3 **+ COMMISSIONER_CONTEXT**):
1. **Resource-mapping table** — benchmark's playbook elements × the commissioner's real resources; tag each cell ✅ borrow-able / ⚠️ not-replicable (luck/timing) / 🔄 already-doing / 🚫 bubble-don't-copy, one line each
2. Landing points — exactly how the commissioner uses it (their to-B service / their own IP / their tooling)
3. Action list + open questions (what's still unconfirmed)

Attribution weighting and the four-tag mapping framework → **`references/attribution_and_resource_mapping.md`**.

## Don't rebuild what already exists

This skill's edge is the *adversarial bubble-busting + attribution + commissioner-mapping* layers. The plumbing underneath is not novel — reuse it:

- **Fan-out collection / source governance** — borrow the lead-agent + subagent pattern from `deep-research`. (What's unique here is the skeptical verification stance and the L1–L4 bubble grading, not the parallelism.)
- **Person-subject identity / footprint checks** — invoke `osint-investigate` (ACH hypothesis matrix, Bellingcat-style pivots) rather than re-deriving identity attribution.
- **Mainland-China corporate registration / funding** — invoke the `qcc` family of skills for 工商 data.
- **Social-platform playbook data** — the `agent-reach` CLI covers B站/小红书/抖音/YouTube/X.

## Read before you run

- **`references/evidence_discipline_traps.md`** — the recurring traps (inferring relationships from appearances, headline-claim attribution, client-vs-asset, foundation-before-fan-out, grade-don't-binary, privacy leak) with real teardown war-stories. Read this first; it's where runs actually break.
- **`references/evidence_grading_rubric.md`** — L1–L4, source_kind, verdicts, collection/verification schemas.
- **`references/attribution_and_resource_mapping.md`** — attribution weighting + four-tag mapping + landing-point framework.
- **`references/workflow_orchestration_template.md`** — a ready-to-fill `Workflow` script with the FACTS / COMMISSIONER_CONTEXT injection split already wired in.

## Next Step

After the due-diligence conclusion is ready, suggest the natural follow-on (opt-in, never auto-run):

```
Due-diligence teardown is done.

Options:
A) Render it as a shareable PDF report — pdf-creator (Recommended if this goes to a partner/team)
B) One dimension needs deeper neutral background — deep-research on that sub-topic
C) No thanks — the markdown teardown is enough
```

© daymade · MIT · daymade/claude-code-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set73

stepfun-tts Generates Chinese and Japanese speech with StepFun Contextual TTS. Controls emotion and prosody using natural-language instructions and inline brackets. CX Codex +1 639installs feishu-doc-scraper Exports Feishu/Lark documents, wikis, sheets, and meeting transcripts to local Markdown. Use it when the saved copy must retain the source content. CX Codex +1 615installs stepfun-asr Converts audio in Chinese and English to text via StepFun's stepaudio-3-asr-max model. Use when switching from older models or encountering an API error saying the model is unsupported — usually the request is hitting the wrong endpoint. CX Codex +1 581installs frontend-visual-qa Checks the interface you can actually see in a real browser: typography, overflow, responsive layout, routes, charts. Useful right after UI work, when the build passes but nobody looked. CX Codex +1 572installs bigdata-skill Extracts structured Bigdata.com (RavenPack) financial and news data via SDK and REST API. Built for data pipelines when MCP tear sheets lack machine-readable fields. CX Codex +1 473installs auto-repo-setup Diagnoses and repairs repository setup, startup sync and hooks. Useful when a repo won't run or you need guarded commit and push. CX Codex +1 469installs pdf-to-html Turns a PDF into one self-contained HTML file that keeps images, tables and reading order. Handy when you want to read a report on your phone instead of scrolling pages. CX Codex +1 458installs terminal-screenshot Renders colored terminal output into a PNG image. It lets the agent visually verify syntax themes and contrast instead of guessing from ANSI codes. CX Codex +1 433installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor