derive-dont-declare

Derive explanations and design decisions through forced-question chains instead of asserting conclusions.

Updated Jun 20, 2026
One-click install
npx skills add https://github.com/tiendungchs/PersonalWiki --skill derive-dont-declare-tiendungchs
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: derive-dont-declare
Source: https://github.com/tiendungchs/PersonalWiki/tree/main/.claude/skills/derive-dont-declare
Command: npx skills add https://github.com/tiendungchs/PersonalWiki --skill derive-dont-declare-tiendungchs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Explanations, design docs, and debugging sessions often start from a finished answer, leaving audiences (or yourself) with memorized conclusions that cannot be rebuilt, varied, or stress-tested. This Skill provides a disciplined method for reaching answers by chaining questions whose answers are forced, so every mechanism and design choice is justified by the constraints that produced it. ## Core Features & Use Cases - Sixteen derivation moves: A repertoire covering setup (concrete instances, quantitative failure of naive solutions, well-posedness checks, cross-domain isomorphs), derivation (smallest hard instance, components voiced as questions, running budgets), and stress-testing (breaking points, baseline comparisons, single-assumption perturbations, falsifiable predictions). - Multi-domain application: Applies the same loop to explanation, debugging (test the assumed mechanism, not the symptom), design review (demand the number that killed the simpler alternative), option selection, and learning new topics as deltas from known ones. - Honesty and anti-pattern guardrails: Explicit conventions for labeling invented examples, skipped proofs, and naming collisions, plus a do/don't table that catches assertion-style exposition. - Use Case: When explaining why a system uses a cache, instead of stating it, you open with the 10ms latency requirement and the 300ms database, let the naive approach fail quantitatively, and let the cache emerge as the only surviving answer. ## Quick Start Explain why this system uses a cache by deriving it from the latency constraints rather than stating it as a given.

Frequently Asked Questions about derive-dont-declare

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I explain a technical mechanism without just stating the answer?▼

Open with a concrete instance the audience already understands, then build the naive solution and kill it with a number. The real mechanism emerges as the only option satisfying the constraint, so the audience derives it rather than memorizing it.

How to debug when the system's behavior contradicts my mental model?▼

Name the mechanism you assume is running, then test that assumption instead of the symptom. Most stubborn bugs come from a wrong assumed mechanism, not a wrong value, so check whether the system is even doing what you framed it as doing.

What makes an analogy useful in a technical explanation?▼

An analogy is useful only when converted into a build spec you then satisfy. Match on the shape of the difficulty rather than subject matter, and cash the analogy into concrete deliverables, otherwise it is decoration that transfers nothing.

When should I not use derivation-style explanation?▼

Avoid it when the audience needs a quick reference answer rather than understanding, or when you cannot produce the quantitative constraint that forces the design. Without a number that kills the naive approach, the derivation has no pressure and produces nothing.

How do I stress-test a design explanation before presenting it?▼

Push the mechanism until it breaks and name the failure mode, compare against a dumb baseline on the metric where your claimed mechanism must appear, and ask what falsifiable prediction follows. A derivation that never breaks the thing is unfinished.