filesystem-context
This skill should be used when the user asks to "offload context to files", "implement dynamic context discovery", "use filesystem for agent memory", "reduce context window bloat", or mentions file-based context management, tool output persistence, agent scratch pads, or just-in-time context loading.
52
40%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/filesystem-context/SKILL.mdQuality
Discovery
22%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This description is heavily imbalanced: it provides extensive 'when to use' trigger phrases but completely omits what the skill actually does. The trigger terms lean toward technical jargon that most users wouldn't naturally use. Without any concrete actions or capabilities listed, Claude cannot make an informed decision about whether this skill is appropriate for a given task.
Suggestions
Add concrete capability descriptions explaining what the skill does, e.g., 'Creates and manages scratch pad files for storing intermediate results, writes tool outputs to disk, and loads relevant context from files on demand to minimize context window usage.'
Replace jargon-heavy triggers with more natural user language, e.g., 'save results to files', 'keep track of progress in files', 'store intermediate work', alongside the technical terms.
Restructure to lead with 'what it does' followed by a 'Use when...' clause, following the pattern: '[capabilities]. Use when [triggers].'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description lists no concrete actions or capabilities. It only describes when to use the skill using abstract concepts like 'offload context to files' and 'dynamic context discovery' without explaining what the skill actually does (e.g., creates files, reads summaries, manages directories). | 1 / 3 |
Completeness | The description answers 'when' extensively but completely fails to answer 'what does this do'. There is no explanation of the skill's actual capabilities or concrete actions, making it impossible to understand what the skill produces or how it works. | 1 / 3 |
Trigger Term Quality | It includes several trigger phrases like 'offload context to files', 'agent memory', 'context window bloat', and 'scratch pads', which are somewhat relevant but lean heavily toward technical jargon rather than natural user language. A typical user is unlikely to say 'implement dynamic context discovery' or 'tool output persistence'. | 2 / 3 |
Distinctiveness Conflict Risk | The trigger terms are fairly niche (file-based context management, agent scratch pads), which reduces conflict risk somewhat. However, terms like 'filesystem' and 'agent memory' could overlap with general file management or memory-related skills, and the lack of concrete capability description makes it harder to distinguish. | 2 / 3 |
Total | 6 / 12 Passed |
Implementation
57%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a comprehensive skill covering filesystem-based context engineering with good structure and progressive disclosure. Its main weaknesses are verbosity (could be 40% shorter by trimming rationale clauses and explanations of concepts Claude knows) and actionability gaps where code examples are illustrative rather than executable. The workflow patterns would benefit from explicit validation steps, especially for the self-modification and multi-agent patterns which involve potentially destructive operations.
Suggestions
Trim 'because...' rationale clauses throughout — Claude doesn't need explanations of why context windows are limited or why summarization loses information. This could reduce the skill by ~30%.
Make code examples executable: replace undefined functions like `extract_summary()`, `write_file()`, `load_yaml()` with actual implementations or specify the exact libraries/APIs to use.
Add explicit validation steps to workflows — e.g., after writing a scratch file, verify it exists and is readable; after self-modification, validate the YAML/JSON schema before committing.
Remove the 'Core Concepts' four-modes section or compress it to a 4-line bullet list — the detailed explanations of missing/under-retrieved/over-retrieved/buried context are conceptual rather than actionable.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is quite long (~300+ lines) and includes some explanatory content that Claude would already know (e.g., explaining why context windows are limited, what glob/grep do). The four context failure modes section and trade-off discussions add value but could be tighter. Several patterns repeat the rationale ('because...') in ways that feel redundant. | 2 / 3 |
Actionability | The skill provides code examples but many are pseudocode or illustrative rather than truly executable (e.g., `extract_summary`, `write_file`, `load_yaml` are undefined functions). The directory structures and YAML examples are concrete and useful, but the Python snippets would need significant adaptation to actually run. The examples section uses a descriptive 'Before/After' format rather than executable code. | 2 / 3 |
Workflow Clarity | The skill presents patterns clearly but lacks explicit validation checkpoints and feedback loops. For example, Pattern 1 (scratch pad) doesn't include verification that the file was written successfully or that the summary is accurate. Pattern 6 (self-modification) mentions 'guard with validation' but doesn't specify how. The gotchas section partially compensates by identifying failure modes, but the workflows themselves don't embed error recovery steps. | 2 / 3 |
Progressive Disclosure | The skill is well-structured with clear sections, a references section pointing to one-level-deep external files (implementation-patterns.md, related skills), and a logical progression from concepts to patterns to practical guidance. The Integration and References sections provide clear navigation to related content without nesting deeply. | 3 / 3 |
Total | 9 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Commit
7a95d94
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.