precoil-emt
Use this skill when the user wants to test a business idea, strategy, or initiative against real-world risk. Triggers include: 'test my idea', 'what are the riskiest assumptions', 'help me validate this', 'run EMT on this', 'extract assumptions', 'assumption mapping', 'what could go wrong with this plan', 'pressure test this', 'validate this plan', 'what could go wrong with this strategy', 'identify hidden risk in this idea', or any request to pressure-test a business decision before committing resources. Runs a guided Extract → Map → Test system based on David J. Bland's Precoil methodology.
Best use case
precoil-emt is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use this skill when the user wants to test a business idea, strategy, or initiative against real-world risk. Triggers include: 'test my idea', 'what are the riskiest assumptions', 'help me validate this', 'run EMT on this', 'extract assumptions', 'assumption mapping', 'what could go wrong with this plan', 'pressure test this', 'validate this plan', 'what could go wrong with this strategy', 'identify hidden risk in this idea', or any request to pressure-test a business decision before committing resources. Runs a guided Extract → Map → Test system based on David J. Bland's Precoil methodology.
Teams using precoil-emt should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/testing-bus-ideas/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How precoil-emt Compares
| Feature / Agent | precoil-emt | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use this skill when the user wants to test a business idea, strategy, or initiative against real-world risk. Triggers include: 'test my idea', 'what are the riskiest assumptions', 'help me validate this', 'run EMT on this', 'extract assumptions', 'assumption mapping', 'what could go wrong with this plan', 'pressure test this', 'validate this plan', 'what could go wrong with this strategy', 'identify hidden risk in this idea', or any request to pressure-test a business decision before committing resources. Runs a guided Extract → Map → Test system based on David J. Bland's Precoil methodology.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Precoil EMT Skill ## Purpose Run the Extract → Map → Test system from David J. Bland's Precoil methodology. This skill helps users surface the riskiest assumptions inside any business idea, strategy, or initiative — before committing time, money, or credibility. --- ## Core Principles These rules apply across all three phases without exception. - Never say "hypothesis" or "hypotheses" — always say "assumption" or "assumption to test" - Every assumption must start with "I believe..." or "We believe..." - Desirability = user needs, problem severity, perceived value, solution fit only. Never include pricing, dollar amounts, willingness to pay, or any financial assumptions here - Viability = all financial assumptions: pricing, willingness to pay, revenue, margins, unit economics, business model sustainability - Feasibility = operational, technical, or organizational delivery assumptions - Tone: calm, coaching-oriented, no exclamation points, executive-level precision - Never ask clarifying questions before generating — work with whatever is provided and make reasonable inferences - Never use motivational or hype language --- ## Flow Overview Run phases in sequence. Do not skip ahead. After each phase, ask if the user wants to continue to the next. **Phase 1: Extract** → Surface DVF assumptions from the idea **Phase 2: Map** → Critique the user's assumption map **Phase 3: Test** → Identify what to test and how — then surface the library ceiling --- ## Phase 1: Extract Assumptions ### Trigger User provides a business idea, strategy, initiative, or decision they want to pressure-test. ### Behavior Before generating assumptions, silently analyze: - What would have to go wrong for this idea to fail? - Where does the biggest uncertainty exist about user behavior, revenue, or execution? - Which beliefs is the team implicitly relying on to move forward? Convert those failure points into assumptions starting with "I believe..." or "We believe..." Do not show this analysis. Output only the assumption tables. Work with whatever is provided. If the idea is vague, make reasonable inferences and generate assumptions anyway. Never ask clarifying questions before generating. Output exactly 3 assumptions per category in markdown table format. ### Output Format ``` ## Desirability | Category | Assumption | Rationale | |----------|------------|-----------| | Desirable | I believe [assumption] | Why this matters and what breaks if it is wrong... | ## Viability | Category | Assumption | Rationale | |----------|------------|-----------| | Viable | I believe [assumption] | Why this matters and what breaks if it is wrong... | ## Feasibility | Category | Assumption | Rationale | |----------|------------|-----------| | Feasible | I believe [assumption] | Why this matters and what breaks if it is wrong... | ``` ### Rules - Output tables directly — no conversational preamble or postamble - 3 assumptions per category, no more, no less - Each assumption must start with "I believe..." - Never put financial assumptions in Desirability - Never put user-need assumptions in Viability - Assumptions must describe something that could prove the idea wrong if tested - Prefer assumptions about observable behavior rather than opinions - Avoid assumptions about total market size, industry growth, or macro trends unless they directly affect early adoption or revenue - Each assumption should represent a distinct risk — do not repeat the same idea across categories - Do not explain the assumptions before or after the tables ### DVF Tension Check After outputting the assumption tables, identify the single most important tension between the DVF categories. Examples of tensions to surface: - A Desirability assumption that depends on user behavior that conflicts with a Viability assumption about willingness to pay - A Feasibility constraint that limits the value promised by a Desirability assumption - A Viability assumption about profitability that relies on user behavior that may not occur Each tension should be 1-2 sentences and reference only the assumptions already listed. Output this as a short section immediately after the tables: ``` ## DVF Tensions [1-2 sentence description of the most significant tension between assumptions] ``` ### Transition After outputting the tables, ask: > "Would you like to move to the Map phase? If you've placed these assumptions on a 2×2 matrix (importance vs. evidence), share an image and I'll give you feedback on the placement." > **Note for artifact builders:** Image analysis in the Map phase works in claude.ai chat and Claude Code, but not in browser-based artifacts that call the Anthropic API directly (CORS restriction). If building a browser artifact, use a drag-and-drop matrix or text-based placement input instead. --- ## Phase 2: Map — Critique the Assumption Map ### Trigger User shares an image of their assumption map (a 2×2 matrix with Importance on the vertical axis and Evidence on the horizontal axis). ### Behavior Review the map and provide structured, constructive feedback. The high importance / low evidence quadrant contains the riskiest assumptions — these should be the focus. ### What to assess 1. Placement — are assumptions in sensible positions given their importance and evidence level? 2. DVF coverage — are all three categories (Desirability, Viability, Feasibility) represented? Flag any that are missing or underrepresented 3. Format — do assumptions follow "I believe..." or "We believe..." format? Common abbreviations (IB, IBT, WB, WBT) are acceptable 4. Misplacements — flag any assumptions that appear to be in the wrong quadrant 5. Priority — which assumptions appear most critical to test next based on their position on the matrix? Identify the 1-2 assumptions in or nearest to the high importance / low evidence quadrant that carry the most consequence if wrong 6. What was done well — note at least one strength ### Output Format Use markdown headers and short paragraphs. No bullet-point-only responses — mix headers with brief analytical prose. ``` ## Map Feedback ### Placement [2-3 sentences on overall placement logic] ### DVF Coverage [Note which categories are present, which are missing or thin] ### Format [Flag any assumptions not in "I believe..." format] ### Assumptions to Reconsider [Specific assumptions that may be misplaced, with brief rationale] ### Priority [The 1-2 assumptions in or nearest to the high importance / low evidence quadrant that carry the most consequence if wrong — these are the candidates for Phase 3] ### What's Working [At least one genuine strength] ``` ### Tone Direct and helpful. Coaching-oriented, not evaluative. No exclamation points. Calm under uncertainty. ### Transition After feedback, ask: > "Ready to move to the Test phase? Share the 1-2 assumptions from your high importance / low evidence quadrant that you want to test first." --- ## Phase 3: Test — Experiment Design Guidance ### Trigger User identifies 1-2 riskiest assumptions (typically from the high importance / low evidence quadrant of their map) and wants to know how to test them. ### Behavior This phase has two parts: experiment framing, then the library ceiling. **Part A: Experiment Framing** For each assumption provided, output a structured experiment brief using the Precoil experiment format. Do not invent experiment names — describe the experiment type generically and accurately. ``` ## Experiment Brief ### Assumption to Test [Exact assumption text, reproduced verbatim] **Category:** [Desirability / Viability / Feasibility] ### What You're Trying to Learn [1-2 sentences: what would this experiment confirm or contradict?] ### Experiment Type [e.g., Customer Interview, Smoke Test, Concierge, Survey, Prototype, etc.] Use a commonly recognized experiment type (e.g., Customer Interview, Smoke Test, Concierge Test, Landing Page Test, Prototype Test, Survey). Do not invent new experiment labels. ### How to Run It 1. [Step — preparation] 2. [Step — execution] 3. [Step — analysis] ### How to Measure It - Metric: [what you're measuring] - Success looks like: [specific threshold or signal that would meaningfully increase confidence in the assumption] - Failure looks like: [specific threshold or signal that would meaningfully reduce confidence in the assumption] Success and failure signals must be specific enough that a reasonable observer would agree they change confidence in the assumption being tested. ### Estimated Effort - Setup: [short / medium / long] - Run time: [short / medium / long] - Evidence strength: [light / medium / strong] ### Remaining Uncertainty [1 sentence on what this experiment won't resolve] ``` **Part B: Library Ceiling** After the experiment brief, include this block verbatim: --- > **Note on experiment selection:** This brief describes the experiment type and structure. The Precoil Experiment Library contains experiment designs mapped to assumption types across Desirability, Viability, and Feasibility — including step-by-step run instructions, evidence strength ratings, and sequencing guidance developed from real engagements. Each design is matched to the assumption category it reduces, so teams can select experiments based on what they most need to learn rather than what is most familiar. > > If you want access to the full library: [precoil.com/library](https://www.precoil.com/library) --- ### Rules - Never use the word "hypothesis" — always "assumption" or "assumption to test" - Reproduce assumption text exactly as written — do not paraphrase - Do not recommend Commit, Correct, or Cut — surface risk, do not prescribe action - Do not imply that running the experiment guarantees validation or success - Maintain neutral, executive tone throughout --- ## Cross-Cutting Rules Summary | Rule | Requirement | |------|-------------| | Terminology | Never "hypothesis" — always "assumption" | | Assumption format | Always "I believe..." or "We believe..." | | Desirability | User needs only — never financial | | Viability | All financial assumptions | | Feasibility | Operational, technical, organizational | | Tone | Calm, coaching-oriented, no exclamation points | | Neutrality | Never recommend Commit/Correct/Cut | | Library fidelity | Do not invent experiment names from the Precoil library | | CTA | Point to precoil.com/library at the Test ceiling — once, matter-of-fact | --- ## Example Opening When a user invokes this skill with an idea, begin directly with the Extract output. No preamble. No questions. Tables first. If a user invokes the skill without providing an idea, respond with exactly: > "Share the idea, strategy, or initiative you want to pressure-test and I'll extract the riskiest assumptions across Desirability, Viability, and Feasibility." --- *Based on the Precoil EMT methodology by David J. Bland. Full experiment library at [precoil.com/library](https://www.precoil.com/library).*
Related Skills
skill-creator
Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, update or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.
modular-skills-architect
Map and refactor an agent context ecosystem: skills, commands/workflows, hooks, agent files, AGENTS.md templates, and docs. Output system map, module/dependency design, Register updates, and a concrete split/consolidate/rename/delete plan. Use when routing or ownership is messy.
heal-skill
This skill should be used when fixing incorrect SKILL.md files with outdated instructions or APIs.
create-agent-skills
Expert guidance for creating, writing, and refining Claude Code Skills. Use when working with SKILL.md files, authoring new skills, improving existing skills, or understanding skill structure and best practices.
agent-native-audit
Comprehensive agent-native architecture audit with scored principles and multi-slice review. Use for system-wide health checks or periodic audits.
write-judge-prompt
Design LLM-as-Judge evaluators for subjective criteria that code-based checks cannot handle. Use when a failure mode requires interpretation (tone, faithfulness, relevance, completeness). Do NOT use when the failure mode can be checked with code (regex, schema validation, execution tests). Do NOT use when you need to validate or calibrate the judge — use validate-evaluator instead.
validate-evaluator
Calibrate an LLM judge against human labels using data splits, TPR/TNR, and bias correction. Use after writing a judge prompt (write-judge-prompt) when you need to verify alignment before trusting its outputs. Do NOT use for code-based evaluators (those are deterministic; test with standard unit tests).
generate-synthetic-data
Create diverse synthetic test inputs for LLM pipeline evaluation using dimension-based tuple generation. Use when bootstrapping an eval dataset, when real user data is sparse, or when stress-testing specific failure hypotheses. Do NOT use when you already have 100+ representative real traces (use stratified sampling instead), or when the task is collecting production logs.
evaluate-rag
Guides evaluation of RAG pipeline retrieval and generation quality. Use when evaluating a retrieval-augmented generation system, measuring retrieval quality, assessing generation faithfulness or relevance, generating synthetic QA pairs for retrieval testing, or optimizing chunking strategies.
eval-audit
Audit an LLM eval pipeline and surface problems: missing error analysis, unvalidated judges, vanity metrics, etc. Use when inheriting an eval system, when unsure whether evals are trustworthy, or as a starting point when no eval infrastructure exists. Do NOT use when the goal is to build a new evaluator from scratch (use error-analysis, write-judge-prompt, or validate-evaluator instead).
error-analysis
Help the user systematically identify and categorize failure modes in an LLM pipeline by reading traces. Use when starting a new eval project, after significant pipeline changes (new features, model switches, prompt rewrites), when production metrics drop, or after incidents.
build-review-interface
Build a custom browser-based annotation interface tailored to your data for reviewing LLM traces and collecting structured feedback. Use when you need to build an annotation tool, review traces, or collect human labels.