Attacks plans to identify the single most critical point of failure.

Install

mkdir -p .claude/skills/hate && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/17556" && unzip -o skill.zip -d .claude/skills/hate && rm skill.zip

Installs to .claude/skills/hate

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.

Attack a plan, design, or argument like you want it to fail before you commit real effort — return the single load-bearing objection and the cheapest experiment that would prove it matters, not a checklist. User-invoked on purpose: a hate-it reflex always in the agent's reach would bias it toward demolition. Weighs many failure axes but owns the synthesis to one root.
370 charsno explicit “when” triggerlonger than Claude Code's old 250-char listing cap (fine on current versions)
Advanced

Key capabilities

  • Identify the single load-bearing objection to a plan
  • Propose the cheapest experiment to test the objection
  • Pin load-bearing assumptions in a plan
  • Attack plans based on confabulation or false analogies
  • Synthesize findings into a single root objection

How it works

The skill identifies the critical assumption of a plan and then attacks it from various angles to find the single root objection. It then proposes the cheapest experiment to falsify this assumption.

Inputs & outputs

You give it
a plan, design, or argument
You get back
{ root, first_nail }

When to use hate

  • Stress testing a system design
  • Identifying flaws in a development plan
  • Validating critical assumptions

About this skill

Refuse to be nice to the plan — return the one objection that could kill it and the cheapest shot that proves it matters.

Goal

hate asks "what would someone who wants this to fail attack first?" (validity). It attacks the whole plan — not one fact or one line, but the load-bearing structure — and collapses the attack to a single root. The highest-value output is never a checklist — it's one objection plus the cheaper experiment hiding inside the elaborate plan.

Workflow

  1. Pin the load-bearing assumption(s) — what must hold for the whole thing to stand.
  2. Attack on whatever axes apply — the general ones first: a load-bearing fact that may be false, confabulation (a post-hoc story treated as ground truth), analogy-mistaken-for-isomorphism (structure assumed to transfer across domains where it doesn't), future-tense suture (the argument leans on a result that doesn't exist yet), and the sharpest — cites a principle but implements its opposite; and for empirical / research plans, leakage (no external ground-truth enters the validation independently) and statistical power / family-wise α (a true hypothesis auto-failing from uncorrected tests; a near-zero-power condition that rubber-stamps regardless of truth).
  3. Collapse the findings to the single root objection — the one whose failure makes the others moot.
  4. Find the first nail — the cheapest falsification of the load-bearing assumption: the check (in time / cost / sample) that could kill it before the expensive program runs.
  5. Return { root, first_nail } — not a list.

Rules

  • Attack, don't improve — improving is a different reflex.
  • Own the synthesis — many axes may fire, but collapse them to the single load-bearing root; return that, never a list.

Verification

Before finishing:

  1. The root is genuinely load-bearing — the plan falls without it.
  2. The first nail is genuinely cheaper than the plan it would pre-empt.

When not to use it

  • When the goal is to improve a plan
  • When a checklist of issues is desired
  • When the plan is already committed to

Limitations

  • Returns only one root objection
  • Returns only one cheapest falsification experiment
  • Does not improve the plan, only attacks it

How it compares

This skill focuses on finding the single most critical flaw and its cheapest test, rather than providing a list of improvements or general feedback.

Compared to similar skills

hate side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
hate (this skill)021dNo flagsAdvanced
confidence-check134moReviewBeginner
specification-architect138moReviewAdvanced
drift-analysis24moNo flagsIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

confidence-check

SuperClaude-Org

Pre-implementation confidence assessment (≥90% required). Use before starting any implementation to verify readiness with duplicate check, architecture compliance, official docs verification, OSS references, and root cause identification.

13114

specification-architect

adrianpuiu

A rigorous, traceability-first system that generates five interconnected architectural documents (blueprint.md, requirements.md, design.md, tasks.md, and validation.md) with complete requirements-to-implementation traceability. Use this skill when users need to architect systems, create technical specifications, or develop structured project documentation with guaranteed traceability.

1388

drift-analysis

avifenesh

This skill should be used when the user asks about "plan drift", "reality check", "comparing docs to code", "project state analysis", "roadmap alignment", "implementation gaps", or needs guidance on identifying discrepancies between documented plans and actual implementation state.

213

flow-next-plan-review

gmickel

Carmack-level plan review via RepoPrompt or Codex. Use when reviewing Flow epic specs or design docs. Triggers on /flow-next:plan-review.

11

rfc-check

meta-pytorch

Determine if proposed changes require an RFC. Use when planning significant changes, before starting major work, or when asked whether an RFC is needed.

11

feature-planning

mhattingpete

Break down feature requests into detailed, implementable plans with clear tasks. Use when user requests a new feature, enhancement, or complex change.

10

Search skills

Search the agent skills registry