skills/expert-knowledge-elicitation/SKILL.md
Structured interview and observation techniques for extracting tacit knowledge from domain experts
npx skillsauth add curiositech/windags-skills expert-knowledge-elicitationInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
license: Apache-2.0
Load this skill when facing:
Anti-use cases: Simple procedural tasks, well-documented routine work, contexts where expertise doesn't exist yet (pure innovation vs. refined practice)
Expert knowledge exists at three distinct levels, each requiring different methods and serving different purposes:
Level 1: Work Domain Structure (What the world contains)
Level 2: Conceptual Knowledge (What experts know about the domain)
Level 3: Reasoning Strategies (How experts think through problems)
Critical insight: Most failed systems conflate these levels—they capture concepts (L2) but miss reasoning strategies (L3), or document procedures without understanding functional constraints (L1). Effective systems require all three.
The "tacit knowledge problem" is a methodological failure, not a fundamental barrier:
The myth: Experts possess inexpressible, unconscious knowledge that resists articulation The reality: Poor elicitation methods fail to provide adequate cognitive scaffolding
Effective scaffolding principles:
Diagnostic marker: When experts say "I've never thought about it this way, but..." you've achieved good scaffolding—they're discovering their own knowledge through the elicitation process.
Critical expertise exists outside official procedures—adaptive heuristics, workarounds, "naughty" departures:
Why procedures miss expertise:
What's missing from documentation:
Implication for system design: Systems built only from documented procedures will be brittle, inefficient, and miss the actual intelligence that makes work succeed.
Methods differ in what they're useful for, not what knowledge types they can "access":
Failed hypothesis: Different methods tap different knowledge types (declarative vs. procedural, conscious vs. unconscious) Validated finding: All methods can elicit all knowledge types given sufficient effort, but efficiency and naturalness differ dramatically
Method-to-purpose matching:
Selection principle: Match method to project goals and expert's natural articulation style, not to assumed "knowledge type."
Shift from one-time extraction project to continuous organizational capability:
Traditional model (limited): KE as discrete phase in system development—identify need → extract knowledge → build system → done
Mature model (sustainable): KE as ongoing practice integrated into organizational culture:
Organizational contexts requiring ongoing KE:
IF you need to understand expert reasoning during challenging decisions
THEN use Critical Decision Method with concrete past incidents
BECAUSE abstract hypotheticals miss context-dependent factors experts actually use
IF building shared vocabulary or knowledge bases
THEN start with concept mapping sessions
BECAUSE visual representation scaffolds articulation and reveals organizational knowledge gaps
IF designing systems for complex domains with multiple goals
THEN conduct Work Domain Analysis first
BECAUSE understanding functional structure prevents brittle procedural automation
IF experts struggle to articulate knowledge in interviews
THEN switch to case-based or simulation methods
BECAUSE performance reveals knowledge that introspection misses
IF documented procedures exist but systems still fail
THEN investigate the gap between "work-as-imagined" and "work-as-done"
BECAUSE critical adaptive expertise lives in undocumented practice
IF the system must handle non-routine situations
THEN capture Level 3 reasoning strategies, not just Level 2 concepts
BECAUSE brittle rule-following fails when conditions change
IF building human-agent collaboration
THEN design bidirectional scaffolding interfaces
BECAUSE collaboration is knowledge co-construction, not information transfer
IF experts will work alongside the system
THEN capture expert perceptual cues and decision triggers
BECAUSE agents need to understand what experts monitor and why
IF domain knowledge evolves rapidly
THEN build continuous learning mechanisms, not static deployment
BECAUSE one-time capture creates frozen knowledge that decays
IF critical expert is retiring
THEN conduct CDM sessions on their most challenging past cases
BECAUSE difficult cases reveal strategic knowledge that routine work doesn't
IF team needs shared understanding
THEN create collaborative concept maps, not individual interviews
BECAUSE shared artifact construction reveals and resolves conceptual conflicts
IF investigating system failure
THEN use multi-pass retrospection with involved practitioners
BECAUSE single-pass incident reports miss evolving understanding and contextual factors
IF knowledge exists across distributed specialists
THEN use contrasting cases to elicit discrimination criteria
BECAUSE specialists best articulate expertise by comparing domains
| File | When to Load | Contents |
|------|-------------|----------|
| three-level-knowledge-architecture.md | Designing knowledge representation schemas; deciding what to capture; structuring knowledge bases | Detailed explanation of domain structure vs. conceptual knowledge vs. reasoning strategies; why conflating levels causes system brittleness; mapping methods to levels |
| scaffolding-over-extraction.md | Elicitation sessions producing shallow results; experts saying "I just know"; designing interview protocols | Why "tacit knowledge" is methodological failure; principles of effective cognitive scaffolding; collaborative discovery techniques; diagnostic markers of good scaffolding |
| the-gold-not-in-documents.md | Systems failing despite procedure compliance; understanding expert workarounds; investigating work-as-done vs. work-as-imagined | Why critical expertise doesn't appear in documentation; types of undocumented knowledge; methods for surfacing adaptive practices; handling "naughty" but productive rule-bending |
| differential-utility-method-selection.md | Choosing elicitation methods; comparing method trade-offs; planning elicitation strategy | Why differential access hypothesis failed; utility-based method selection; strengths/weaknesses of CDM, concept mapping, WDA, simulations; matching methods to goals |
| expertise-beyond-procedures.md | Designing training; understanding expert vs. novice performance; building systems that support expertise | The procedure paradox; what experts know that procedures don't capture; perceptual learning and cue recognition; contextual adaptation strategies |
| proactive-knowledge-preservation.md | Building organizational KE capability; knowledge management strategy; addressing expert turnover; learning from rare events | Shifting from project-based to ongoing practice; integrating KE into workflow; lightweight capture mechanisms; building living knowledge bases; organizational adoption strategies |
| elicitation-as-collaborative-discovery.md | Designing elicitation sessions; training knowledge engineers; understanding interviewer-expert dynamics | Paradigm shift from extraction to co-construction; collaborative session design; role of respectful challenge; knowledge creation during elicitation; expert-as-partner principles |
1. Checklist Reductionism
2. The Documentation Delusion
3. Single-Method Monogamy
4. Abstract Hypothetical Questioning
5. One-and-Done Extraction
6. The Tacit Knowledge Excuse
7. Conflating Knowledge Levels
1. Immediately ask "Which level?"
2. Recognize productive rule-bending
3. Diagnose elicitation problems methodologically
4. Match methods to purposes, not knowledge types
5. Spot documentation gaps automatically
6. Think in terms of continuous practice, not one-time extraction
7. Use the transactional view of knowledge
Deep understanding: "We need to understand not just what experts know about power grids (L2 concepts), but also how the grid itself functions (L1 domain structure) and how experts reason when standard operating conditions break down (L3 strategies). We'll use WDA for functional relationships, concept mapping for terminology and models, and CDM on the blackout incident for decision-making under uncertainty. And we'll build this as ongoing practice, not one-time capture."
Surface understanding: "We should interview the senior engineers to document their knowledge of power grid operations, then build a knowledge base from the transcripts."
The difference is immediate, structural, and reveals whether someone grasps the fundamental architecture of expert knowledge or is still operating in the failed extraction paradigm.
tools
Building resilient distributed systems with circuit breakers, retries with full-jitter exponential backoff, retry budgets (per-request 3-attempt + per-client 10% ratio per Google SRE), deadline propagation, and the cascading-failure math (4 layers × 3 retries = 64x amplification). Grounded in Resilience4j, Microsoft Cloud Patterns, AWS Architecture Blog (Marc Brooker), and Google SRE Book.
testing
Designing HTTP cache headers that work correctly across browsers, CDNs, and shared proxies — `Cache-Control` directives per RFC 9111, `stale-while-revalidate` and `stale-if-error` per RFC 5861, the Vary header for varying responses, and surrogate keys for tag-based purging. Grounded in IETF RFCs and Cloudflare/Fastly docs.
development
Use when designing or fixing a Content Security Policy on a real site, choosing between nonce-based and hash-based CSP, adding strict-dynamic, debugging "Refused to execute inline script" errors, deploying CSP in report-only mode first, configuring report-to / report-uri, or auditing an existing policy for unsafe-inline / unsafe-eval / wildcards. Triggers: "CSP blocks legitimate inline script", strict-dynamic, nonce-{RANDOM}, sha256-{HASH}, object-src none, base-uri none, frame-ancestors, Trusted Types, X-Content-Security-Policy obsolete, report-only vs enforced. NOT for general HTTP security headers (HSTS, COOP/COEP), Trusted Types deep dive, CORS configuration, or building a WAF.
tools
Choosing and operating an HTTP API versioning strategy that doesn't break clients — Stripe's date-based pinned versions, the Deprecation/Sunset header pair (RFC 9745 + RFC 8594), URI vs header vs media-type approaches, and the version-transformer pattern. Grounded in Stripe's published architecture and IETF RFCs.