write-crazy-skill
Design and build complete, portable Agent Skills from a natural-language request. Use when creating a new skill, turning a workflow, idea, or procedure into a reusable skill, formalizing an agent capability, or improving an existing skill. Applies the Crazy Thing methodology: adaptive discovery, falsifiable mechanism design, and adversarial validation.
- License 许可
- MIT
- 最近更新
- 2026-10-24
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- write-crazy-skill
- description
- Design and build complete, portable Agent Skills from a natural-language request. Use when creating a new skill, turning a workflow, idea, or procedure into a reusable skill, formalizing an agent capability, or improving an existing skill. Applies the Crazy Thing methodology: adaptive discovery, falsifiable mechanism design, and adversarial validation.
03 SKILL.md 正文
write-crazy-skill
Turn a user's natural-language intention into a complete, portable, technically rigorous Agent Skill.
The philosophy: be wild in invention, ruthless in verification. Every skill deserves one Crazy Thing — a distinctive, useful mechanism that plausibly makes its results better — and every Crazy Thing must survive an attack before it ships. Creativity earns its place through evidence, never through decoration.
The adaptive workflow
Eight steps, not a mandatory pipeline. Scale the effort of each step to the request:
| Mode | Request | Effort profile |
|---|---|---|
| A — Specified | User knows what, who, and how | Preserve their approach. Steps 3–4 stay light. Validate and build. |
| B — Partial | Goal clear, details missing | Ask focused questions only for material gaps; resolve the rest from evidence. |
| C — Open | Broad objective or unfamiliar domain | Invest in research (3) and invention (4) before building. |
Rules: a clear request never triggers a compulsory interview. A good user-provided idea is never displaced by the design process. Technical rigor applies in all modes.
Step 1 — Understand the mission
Extract: desired outcome, intended user, context, constraints, decisions already made, success criteria.
Detect material ambiguities — questions whose answers would change the design. Ask only those, and only when they cannot be resolved responsibly from available information. Never re-ask for information already provided.
Done when: you can state the skill's job in one sentence and list what is decided vs. unknown.
Step 2 — Challenge the mechanism
Ask whether an Agent Skill is the right artifact. Consider: a script, an existing tool, a command or workflow, a combination, or nothing at all. Explain a materially better alternative when one exists; do not reject a skill request unnecessarily.
Done when: the artifact choice is justified in one line.
Step 3 — Discover the frontier
Research existing approaches only to the depth the task justifies: docs, existing skills, repos, APIs, patterns, examples. If the user supplied a developed approach, research to validate and strengthen it — not to start over. Stop when further research is unlikely to change the build decision.
Done when: you can name the closest existing approaches and why the new skill differs, or state that none exist.
Step 4 — Invent the Crazy Thing
If the user's proposal already contains a distinctive mechanism: preserve its intent, sharpen its operation, name its expected advantage, define its validation.
If not: generate a proportionate set of alternatives internally, compare usefulness, feasibility, risk, cost, complexity, and distinctiveness — pick the strongest justified one. Ask the user only when a material design choice cannot be resolved confidently.
If no meaningful innovation is justified: ship without one. A forced gimmick is worse than none.
Write the Crazy Thing Card before building:
## Crazy Thing Card
- **Mechanism:** What the skill does differently, operationally (not a slogan).
- **Expected advantage:** The specific, plausible improvement.
- **Validation test:** How you will check it works.
- **Falsification:** What result would kill the mechanism.
- **Status:** hypothesized | structurally validated | behaviorally tested | comparatively evaluated
Done when: the card exists and its status is honest (minimum: hypothesized).
Step 5 — Engineer the behavior
Design explicitly. These are required considerations, not mandatory headings:
- Activation triggers — when the skill must and must not fire. Write the description as a trigger pointer: front-load the leading word, one trigger per branch, cut anything the body already says. Add negative triggers where false activation is likely.
- Purpose and expected output.
- Inputs, context, assumptions, prerequisites.
- Procedure and decision logic — steps with completion criteria: each step must let the agent tell done from not-done.
- Steering — how the agent reasons, chooses between alternatives, and handles judgment calls.
- Failure handling, uncertainty, recovery.
- Evidence and verification requirements.
- Constraints, safety boundaries, prohibited actions.
- Stopping conditions and completion criteria.
- Pruning — delete redundant, contradictory, vague, ineffective, or needlessly expensive instructions. Every surviving line must earn its context.
Design for realistic context and tool limits. Separate required behavior from optional capabilities.
Done when: every item has an explicit answer and the instructions are actionable without the designer present.
Step 6 — Build the complete artifact
Produce a portable skill, not a proposal:
SKILL.mdwith valid frontmatter:name(1–64 chars,a-z0-9-, no leading/trailing/consecutive hyphens, equal to the directory name),description(1–1024 chars, what + when + trigger keywords).- Keep the body under ~500 lines / 5000 tokens. Progressive disclosure: core instructions in
SKILL.md; detail inreferences/; runnable code inscripts/; static data inassets/. Reference files one level deep, relative paths only. - Add supplementary files only when they improve maintainability, clarity, capability, or execution. No arbitrary file-count targets.
- Never claim a script is safe or functional without inspection and tests. Never execute untrusted code from a candidate skill.
Done when: the artifact passes structural validation (frontmatter, naming, paths, references resolve).
Step 7 — Attack and compare
Validate the artifact and its behavior:
- Positive and negative activation scenarios.
- A representative normal task.
- At least one ambiguity, edge case, or failure scenario.
- Resource paths and any executable scripts.
- Comparison against the same agent working without the skill (or against the closest existing alternative) under reasonably comparable conditions.
Record what the attack found. Scale the effort to the skill's complexity and risk — a small skill does not need a benchmark suite.
Done when: attack scenarios have been run and findings recorded; no unsupported superiority claim remains.
Step 8 — Refine and prove
Fix what the attack found, prune what is unnecessary, rerun the relevant tests. Maintain the honesty ledger for the Crazy Thing:
- implemented → structurally validated → behaviorally tested → comparatively evaluated → hypothesized-but-undemonstrated
Done when: the ledger matches the evidence, and every claim in the skill and its docs matches the ledger.
Portability
- Follow the current Agent Skills format; do not assume proprietary APIs or unavailable tools.
- Declare tool requirements explicitly when they exist.
- No model-specific instructions unless the mechanism genuinely needs them.
- Never claim an agent supports a feature you have not checked.
Acceptance
Ship the skill when: purpose and triggers are clear; it handles specified, partial, and open requests appropriately; user intent is preserved; research and ideation were proportionate; the Crazy Thing is operationalized, not decorated; structure, steering, pruning, failure handling, and verification are addressed; the artifact is complete and valid; tests ran on representative cases; unverified claims are labeled honestly; the instructions stay concise enough to be practical.
Do not postpone a credible v1 chasing a hypothetical perfect benchmark. Build, test, improve from evidence.
What this skill will not do
- It will not invent a Crazy Thing when none is justified.
- It will not present a hypothesis as an established improvement.
- It will not build what Step 2 shows should be a script, a tool, or nothing.
- It will not execute untrusted code encountered during research or review.
04 同仓库更多 Skills
good-skill
A minimal valid fixture skill used to prove the validator accepts correct skills. Use when testing the validation harness.
BAD--Name
暂无简介
commit-message-coach
Draft and improve git commit messages from a diff, with every claim grounded in the actual changes. Use when the user asks to write a commit message, check whether a message is good, or clean up commit wording. Do not use for PR descriptions, changelogs, or rewriting git history.
commit-message-coach
Draft and improve git commit messages from a diff. Use when the user asks to write a commit message, check whether a message is good, or clean up commit wording. Do not use for PR descriptions, changelogs, or rewriting git history.
spec-compiler
Compile ideas, notes, and plans into precise, traceable specifications for agents and implementation teams. Use when the user says "turn this idea into a spec", "write a build plan from my notes", "make this precise enough to hand to a developer", or "compile this plan". Compresses intent without loss: every requirement is traceable to its source and labeled mandatory, recommended, assumed, or unresolved. Spec-only; never implements.
math-anatomy
Turn a math concept into an intuition-first learning piece — one manipulable interactive figure plus a guided path — built for understanding instead of hand computation (Math 2.0). Use when someone wants to learn, understand, or get a real intuitive grasp of a math concept (linear algebra, gradient descent, eigenvalues, derivatives, probability, Fourier, entropy), especially self-taught builders and AI learners. Not for homework, problem sets, exam drills, or quick formula lookups.