Ponytail Lazy Developer Mode
DietrichGebert/ponytail
Makes the agent pick the laziest solution that works: skip unneeded work, reuse what exists, prefer the standard library and platform features, and keep diffs small.
Ground implementation decisions in domain knowledge before designing solutions.
$ npx skills add jacob-dietle/context-os --skill epistemic-context-grounding -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install jacob-dietle/context-os epistemic-context-grounding --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/jacob-dietle/context-os.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/epistemic-context-grounding .claude/skills/epistemic-context-grounding && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "epistemic-context-grounding" agent skill from https://github.com/jacob-dietle/context-os/tree/main/.claude/skills/epistemic-context-grounding into .claude/skills/epistemic-context-grounding/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "epistemic-context-grounding", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/jacob-dietle/context-os/tree/main/.claude/skills/epistemic-context-groundingType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add jacob-dietle/context-os --skill epistemic-context-grounding -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install jacob-dietle/context-os epistemic-context-grounding --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jacob-dietle/context-os.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.claude/skills/epistemic-context-grounding .agents/skills/epistemic-context-grounding && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "epistemic-context-grounding" agent skill from https://github.com/jacob-dietle/context-os/tree/main/.claude/skills/epistemic-context-grounding into .agents/skills/epistemic-context-grounding/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "epistemic-context-grounding", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add jacob-dietle/context-os --skill epistemic-context-grounding -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install jacob-dietle/context-os epistemic-context-grounding --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jacob-dietle/context-os.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.claude/skills/epistemic-context-grounding .cursor/skills/epistemic-context-grounding && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "epistemic-context-grounding" agent skill from https://github.com/jacob-dietle/context-os/tree/main/.claude/skills/epistemic-context-grounding into .cursor/skills/epistemic-context-grounding/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "epistemic-context-grounding", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/jacob-dietle/context-os.git --path .claude/skills/epistemic-context-grounding--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add jacob-dietle/context-os --skill epistemic-context-grounding -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install jacob-dietle/context-os epistemic-context-grounding --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jacob-dietle/context-os.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.claude/skills/epistemic-context-grounding .gemini/skills/epistemic-context-grounding && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "epistemic-context-grounding" agent skill from https://github.com/jacob-dietle/context-os/tree/main/.claude/skills/epistemic-context-grounding into .gemini/skills/epistemic-context-grounding/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "epistemic-context-grounding", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install jacob-dietle/context-os epistemic-context-groundingInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add jacob-dietle/context-os --skill epistemic-context-grounding -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/jacob-dietle/context-os.git skills-src && mkdir -p .github/skills && cp -r skills-src/.claude/skills/epistemic-context-grounding .github/skills/epistemic-context-grounding && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "epistemic-context-grounding" agent skill from https://github.com/jacob-dietle/context-os/tree/main/.claude/skills/epistemic-context-grounding into .github/skills/epistemic-context-grounding/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "epistemic-context-grounding", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add jacob-dietle/context-os --skill epistemic-context-grounding -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install jacob-dietle/context-os epistemic-context-grounding --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jacob-dietle/context-os.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.claude/skills/epistemic-context-grounding .opencode/skills/epistemic-context-grounding && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "epistemic-context-grounding" agent skill from https://github.com/jacob-dietle/context-os/tree/main/.claude/skills/epistemic-context-grounding into .opencode/skills/epistemic-context-grounding/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "epistemic-context-grounding", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
epistemic-context-groundingGround implementation decisions in domain knowledge before designing solutions.
Epistemic Context Grounding is an agent skill from jacob-dietle/context-os. Ground implementation decisions in domain knowledge before designing solutions. Prevents over-engineering by checking what documentation exists, making assumptions explicit, and verifying them against canonical sources. Core principle - know what you don't know before designing.
Its SKILL.md is about 3.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `references/context-sensitivity-model.md`, `references/domain-query-patterns.md` and `references/falsifiability-spectrum.md`).
It sits in Development, covering Code simplification. The licence is MIT.
10 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit 1027e3f. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown and bash).
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Epistemic Context Grounding loads about 3.7k tokens when it runs, and up to ~9.3k if it reads all its reference files. Until then it costs about 77 tokens; SKILL.md has 807 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from jacob-dietle/context-os at commit 1027e3f, republished under its MIT licence (© jacob-dietle). 807 words, ~3,695 tokens.
.claude/skills/epistemic-context-grounding/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.Methodology for grounding implementation decisions in domain knowledge through context sensitivity assessment, assumption enumeration, and falsifiability checking.
The most common cause of wasted effort in AI-assisted work isn't bad code - it's building the wrong thing because you didn't check what documentation already describes the domain. A 2-5 minute grounding check prevents hours of rework.
Apply this skill when:
Do NOT use for:
Classify task before designing:
LOW CONTEXT SENSITIVITY:
- Task is bounded, clear outcome
- Domain well-known (basic CRUD, standard patterns)
- Example: "Add a button to the UI"
HIGH CONTEXT SENSITIVITY:
- Task involves parsing, data formats, integrations
- Domain has canonical specs/docs
- Example: "Fix data pipeline" -> needs format knowledgeThe formula: (Model : Scenario) * Context -> Output
Where:
For HIGH context sensitivity tasks, missing context dramatically reduces output quality. For LOW context sensitivity tasks, context has minimal impact.
See references/context-sensitivity-model.md for full framework.
Search for specs, not just code:
SEARCH ORDER (adapt to your context OS structure):
1. specs/canonical/*.md - Blessed architecture docs
2. specs/{project}/*.md - Project-specific specs
3. **/CLAUDE.md - Navigation guides
4. **/README.md - Component documentation
5. knowledge_base/**/*.md - Knowledge graph nodesYour context OS contains interconnected domain knowledge. Linear session context preserves state; graph-based context (specs, knowledge nodes) provides domain understanding.
See references/domain-query-patterns.md for search patterns.
Before designing, explicitly list what is being assumed:
## Assumptions Audit
| # | Assumption | Can Verify? | Source |
|---|------------|-------------|--------|
| 1 | DB contains the field I need | YES | Query DB schema |
| 2 | Current data source is sufficient | MAYBE | Check if richer data exists |
| 3 | No canonical spec exists | NO | MUST SEARCH FIRST |Categories of assumptions:
The goal: Make implicit assumptions explicit so they can be verified.
Grade the verifiability of your assumptions:
STRONG FALSIFIABILITY (preferred):
- Solution grounded in specific spec citation
- Claims verifiable against canonical source
- Example: "API uses OAuth 2.0" [GROUNDED: provider docs, auth section]
WEAK FALSIFIABILITY (warning):
- Solution based on assumptions about data
- Claims not verifiable without checking
- Example: "This field should be enough" [UNVERIFIABLE]Grading scale:
| Grade | Meaning | Action |
|---|---|---|
| STRONG | Verifiable against canonical source | Proceed |
| WEAK | Based on assumptions, could be wrong | Flag in design |
| UNVERIFIED | Haven't checked if better approach exists | MUST SEARCH |
See references/falsifiability-spectrum.md for framework details.
Every design decision must cite a source:
[GROUNDED: spec:line] - Solution based on canonical spec
[INFERRED: from X + Y] - Deduced from multiple sources
[UNGROUNDED] - Assumption, needs verificationQuality standard: If a design decision cannot cite a source, flag it as [UNGROUNDED] and verify before proceeding.
## Context Sensitivity Check
**Task:** [What user asked for]
**Classification:** [LOW | HIGH]
**Reasoning:**
- Does task involve data formats? [Y/N]
- Does task involve parsing/serialization? [Y/N]
- Does task involve external integrations? [Y/N]
- Is domain knowledge critical to solution? [Y/N]
If 2+ YES -> HIGH context sensitivity -> Continue to Step 2
If 0-1 YES -> LOW context sensitivity -> Skip to context-gap-analysisDecision tree:
Task received
|
+-- Data formats involved? --YES--+
+-- Parsing/serialization? --YES--+
+-- External integrations? --YES--+-- HIGH -> Continue
+-- Domain knowledge critical? ---+
|
+-- None of above -----------------> LOW -> Skip to context-gap-analysisSearch for existing documentation before designing:
# 1. Find canonical specs (adapt paths to your system)
Glob: "specs/canonical/*.md"
Glob: "**/*DATA_MODEL*.md"
Glob: "**/*SPEC*.md"
# 2. Search for domain terms
Grep: pattern="[domain-term]" path="specs/"
Grep: pattern="[key-concept]" path="knowledge_base/"
# 3. Check navigation guides
Read: relevant CLAUDE.md files
Read: relevant README.md files
# 4. Knowledge graph
Glob: "knowledge_base/**/*.md"
Grep: pattern="[domain-term]" path="knowledge_base/"Output from Step 2:
## Domain Knowledge Found
| Document | Relevance | Key Information |
|----------|-----------|-----------------|
| [[data-model.md]] | HIGH | Documents record types and schemas |
| [[CLAUDE.md]] | MEDIUM | Navigation to specs |
| None found | - | Need to explore further |List all assumptions before designing:
## Assumptions Audit
### Data Assumptions
1. [ ] I assume [X] is the data source
2. [ ] I assume [Y] field exists
3. [ ] I assume [Z] contains what I need
### Domain Assumptions
4. [ ] I assume no spec exists for this
5. [ ] I assume current approach is best
### Solution Assumptions
6. [ ] I assume [approach] will work
7. [ ] I assume no simpler solution exists
**Verification Plan:**
- Assumption 1: Check by [specific action]
- Assumption 4: Search specs/ firstCommon assumption traps:
Grade each assumption:
## Falsifiability Assessment
| Assumption | Grade | Evidence |
|------------|-------|----------|
| DB has needed field | STRONG | Can query schema |
| Field data is sufficient | WEAK | Haven't checked what else exists |
| No spec exists | UNVERIFIED | MUST SEARCH BEFORE DESIGNING |
**Verdict:**
- If any UNVERIFIED assumptions -> Search first
- If WEAK assumptions -> Flag in design
- If all STRONG -> Proceed to implementationBlocking conditions:
## Epistemic Grounding Report
**Task:** [Original request]
**Context Sensitivity:** [LOW | HIGH]
**Domain Knowledge Found:**
- [[spec-file-1]] - [Relevance]
- [[spec-file-2]] - [Relevance]
**Assumptions Verified:**
- [X] Assumption 1 [GROUNDED: source]
- [ ] Assumption 2 [UNGROUNDED - needs checking]
**Falsifiability:**
- Solution grounding: [STRONG | WEAK | UNVERIFIED]
- Recommendation: [Proceed | Read specs first | Verify assumptions]
**Next Step:**
[Specific action - "Read data-model.md" or "Proceed to context-gap-analysis"]1. context-os-basics -> Understand system patterns
2. epistemic-context-grounding -> Ground in domain knowledge (THIS SKILL)
3. context-gap-analysis -> Check if code/content existsAfter epistemic grounding:
## For context-gap-analysis
**Epistemic Grounding Complete:**
- Domain specs read: [[list]]
- Assumptions verified: [X/Y]
- Solution grounding: [STRONG | WEAK]
**Proceed to check if code/content implementation exists.**Task characteristics show:
- LOW context sensitivity
- Domain already loaded in context
- Simple bug fix with obvious root cause
-> Skip directly to context-gap-analysis## Epistemic Grounding Report
**Task:** Fix data pipeline - records not processing correctly
**Context Sensitivity:** HIGH
- Does task involve data formats? YES (JSON/JSONL)
- Does task involve parsing/serialization? YES
- Does task involve external integrations? YES (data service)
- Is domain knowledge critical to solution? YES
**Classification:** HIGH -> Continue to Step 2
**Domain Knowledge Query:**
Glob: "**/*DATA_MODEL*.md" -> Found: specs/canonical/data_model.md
Read: data_model.md -> Documents 16+ record types
**Key Discovery:**
- Data source contains full message content
- Not just aggregated counts
- Richer signal available than initially assumed
**Assumptions Audit:**
| Assumption | Grade | Evidence |
|------------|-------|----------|
| DB is only data source | WEAK | Spec shows raw files have full content |
| Aggregated counts are best signal | DISPROVEN | Raw messages are richer |
| No richer data exists | DISPROVEN | Spec documents message content |
**Falsifiability:** WEAK (original approach) -> STRONG (after reading spec)
**Verdict:** Solution should use raw data directly, not aggregated counts.
**Next Step:** Read data_model.md fully, then redesign approach.## Context Sensitivity Check
**Task:** Fix typo in error message "Connot connect" -> "Cannot connect"
**Classification:** LOW
- Data formats? NO
- Parsing? NO
- Integrations? NO
- Domain knowledge critical? NO
**Verdict:** Skip to context-gap-analysis## Context Sensitivity Check
**Task:** Add HubSpot integration for contact sync
**Classification:** HIGH
- Data formats? YES (HubSpot API response)
- Parsing? YES (JSON transformation)
- Integrations? YES (HubSpot API)
- Domain knowledge critical? YES
**Domain Knowledge Query:**
Glob: "**/hubspot*.md" -> None found
Glob: "**/integration*.md" -> Found: specs/canonical/integrations.md
WebSearch: "HubSpot API contacts documentation 2026"
**Assumptions Audit:**
| Assumption | Grade | Evidence |
|------------|-------|----------|
| HubSpot uses REST API | STRONG | Verified via docs |
| Contact schema matches ours | UNVERIFIED | Need to check both schemas |
| Auth is OAuth | WEAK | Multiple auth methods exist |
**Next Step:** Verify contact schema compatibility before designing sync logic.1. HIGH context sensitivity? (data/parsing/integration)
- YES -> Do full workflow
- NO -> Skip to context-gap-analysis
2. Searched specs/?
- NO -> Search first
3. Listed assumptions?
- NO -> List them
4. Any UNVERIFIED assumptions?
- YES -> Verify before designing[GROUNDED: spec:line] - Canonical source
[INFERRED: from X + Y] - Deduced
[UNGROUNDED] - Assumption, needs verification# Canonical specs
Glob: "specs/canonical/*.md"
# Data models
Glob: "**/*DATA_MODEL*.md"
# Domain terms
Grep: pattern="[term]" path="specs/"
# Knowledge graph
Grep: pattern="[term]" path="knowledge_base/"On first use of this skill in a new context OS, ask the user:
"This skill works best when customized to your system. Would you like me to learn your context OS structure? I can:
- Discover where your specs and canonical docs live
- Identify your knowledge graph search patterns
- Map your domain-specific terminology
This takes ~2 minutes and makes future grounding checks much faster."
If the user agrees, explore their codebase to identify:
Then update your working knowledge for that session.
During customization, offer to remove the attribution line below if the user wants to fully own this skill in their system.
Origin: Chain naming quality fix in a context intelligence system (2026-01-28)
Framework source: Context Engineering (applied epistemology for AI systems)
Pattern extracted: Check domain specs BEFORE designing solutions.
Created by Jacob Dietle @ www.taste.systems
© jacob-dietle, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 3 other files (references) in .claude/skills/epistemic-context-grounding of jacob-dietle/context-os.
Open the folder on GitHubat commit 1027e3f
Epistemic Context Grounding next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Epistemic Context Grounding this skilljacob-dietle/context-os | 111 | — | ~3.7k | Automated safety check: Pass | MIT | |
| Ponytail Lazy Developer ModeDietrichGebert/ponytail | 160k | 1 repos | ~873 | Automated safety check: Pass | MIT | |
| Ponytail Reviewkortix-ai/suna | 20k | 4 repos | ~593 | Automated safety check: Pass | Custom licence | |
| PonytailDavidObando/gsharp | 565 | 7 repos | ~1.7k | Automated safety check: Pass | MIT | |
| Code Simplification for ego-litecitrolabs/ego-lite | 17k | — | ~1.2k | Automated safety check: Pass | MIT | |
| Refactor Pass for Simplicitystar-history/star-history | 9.6k | 1 repos | ~168 | Automated safety check: Pass | MIT |
DietrichGebert/ponytail
Makes the agent pick the laziest solution that works: skip unneeded work, reuse what exists, prefer the standard library and platform features, and keep diffs small.
kortix-ai/suna
Code review focused exclusively on over-engineering. An agent skill from kortix-ai/suna.
DavidObando/gsharp
Forces the laziest solution that actually works, simplest, shortest, most minimal.
citrolabs/ego-lite
Finds and implements evidence-backed simplifications in the ego-lite repository, such as dead code, duplicated state and speculative abstractions, without hiding behavior changes.
star-history/star-history
Perform a refactor pass focused on simplicity after recent changes. Use when the user asks for a refactor/cleanup pass, simplification, or dead-code removal…
rtk-ai/rtk
Reviews RTK's Rust code for over-engineering and verbose patterns, applying idioms like iterator chains and early returns while protecting a specific list of constraints from being simplified away.
jacob-dietle/context-os
A skill your agent uses when deciding what to work on next, when progress is stuck, or when the reflex is to build or automate before proving the current bottleneck.
jacob-dietle/context-os
This skill should be used to periodically defragment a multi-app/multi-service codebase — both CODE (duplicate deploy targets, colliding bindings, stale forks) and CONTEXT (parallel spec…
jacob-dietle/context-os
This skill should be used when producing content (newsletter posts, blog posts, LinkedIn posts) from existing corpus material.
jacob-dietle/context-os
This skill should be used when users ask about their work context, what they're working on, recent activity, file relationships, or knowledge graph structure.
jacob-dietle/context-os
This skill should be used when making architectural decisions, writing specs, or reviewing decisions that contain "future work", "v2", "simpler for now", "out of scope", or complexity claims.
jacob-dietle/context-os
This skill should be used when decomposing a spec into a multi-agent implementation plan with dependency ordering, parallelism decisions, contract testing, and verification strategy.
Categories
Ground implementation decisions in domain knowledge before designing solutions. Epistemic Context Grounding is an agent skill from jacob-dietle/context-os. Ground implementation decisions in domain knowledge before designing solutions.
Epistemic Context Grounding fits situations like: tasks that involve Code simplification.
Run `npx skills add jacob-dietle/context-os --skill epistemic-context-grounding -a claude-code`. Or copy the skill folder (.claude/skills/epistemic-context-grounding in jacob-dietle/context-os) into .claude/skills/epistemic-context-grounding in your project. Claude Code loads it when a task matches its description.
Run `npx skills add jacob-dietle/context-os --skill epistemic-context-grounding -a codex`. Or copy the skill folder (.claude/skills/epistemic-context-grounding in jacob-dietle/context-os) into .agents/skills/epistemic-context-grounding in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jacob-dietle/context-os --skill epistemic-context-grounding -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/epistemic-context-grounding, .gemini/skills/epistemic-context-grounding, .github/skills/epistemic-context-grounding and .opencode/skills/epistemic-context-grounding in your project.
SKILL.md names no scripts, command-line tools or credentials: Epistemic Context Grounding is instructions for the agent only.
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Epistemic Context Grounding is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 3.7k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5.6k tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Epistemic Context Grounding: Ponytail Lazy Developer Mode (DietrichGebert/ponytail, 160k stars), Ponytail Review (kortix-ai/suna, 20k stars), Ponytail (DavidObando/gsharp, 565 stars) and Code Simplification for ego-lite (citrolabs/ego-lite, 17k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
jacob-dietle (a GitHub user) maintains it in jacob-dietle/context-os, which has 111 GitHub stars. The repository holds 11 skills in this directory. The repository was last updated on August 13, 2026.
Source: jacob-dietle/context-os on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.