epistemic-context-grounding

Verify implementation assumptions against canonical domain documentation.

104|31|Updated Dec 10, 2025
One-click install
npx skills add https://github.com/jacob-dietle/context-os --skill epistemic-context-grounding
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: epistemic-context-grounding
Source: https://github.com/jacob-dietle/context-os/tree/main/.claude/skills/epistemic-context-grounding
Command: npx skills add https://github.com/jacob-dietle/context-os --skill epistemic-context-grounding

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill ensures that implementation decisions are grounded in domain knowledge, preventing over-engineering and wasted effort by verifying assumptions and documentation against canonical sources.

Core Features & Use Cases

  • Domain Knowledge Query: Search for relevant documentation and specs in the context OS to understand the domain and requirements.

  • Assumption Enumeration: Explicitly list and verify assumptions to prevent mistakes based on unknowns.

  • Falsifiability Check: Grade the verifiability of assumptions and grounding to ensure design decisions are solid.

  • Use Case: When you start a new implementation on an unfamiliar domain, this Skill helps you identify what documentation exists, make assumptions explicit, and verify them against canonical sources before proceeding with design.

Quick Start

Run the epistemic-context-grounding skill to begin the grounding process for your implementation task.

Frequently Asked Questions about epistemic-context-grounding

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

FAQPage Schema
How do I verify implementation assumptions against canonical sources before coding?

To verify implementation assumptions, you must enumerate them explicitly and perform a falsifiability check against canonical source documentation. This grounding process prevents over-engineering by ensuring design decisions are validated by domain knowledge before development proceeds.

What is the best way to ground design decisions when entering a new domain?

Grounding design decisions in a new domain requires querying relevant documentation to understand context, listing all assumptions, and grading their verifiability. This ensures implementation choices are solid and based on canonical sources rather than unknowns.

How do I prevent over-engineering when parsing unfamiliar data formats?

Preventing over-engineering when parsing data formats requires assessing context sensitivity and verifying assumptions against canonical specifications. By making assumptions explicit and checking them against domain knowledge, you avoid wasted implementation effort.

Why does integrating with external systems require an assumption enumeration process?

Integrating with external systems requires assumption enumeration because unknowns can cause severe implementation mistakes. Explicitly listing and grading the falsifiability of assumptions against canonical sources ensures your design decisions are solid before external integration.

When do I need to run a context sensitivity assessment for development tasks?

You need a context sensitivity assessment when starting development tasks involving new domain entry, parsing data formats, or integrating with external systems. This assessment identifies existing documentation and grounds your implementation decisions in canonical sources.

Can I check domain knowledge specs automatically when starting an unfamiliar implementation?

Yes, you can check domain knowledge by searching for relevant documentation and specs within your context environment. This automated grounding process identifies existing canonical sources and verifies your assumptions before you proceed with implementation design.