filesystem-context

Use for file-based context management, dynamic context discovery, and reducing context window bloat. Offload context to files for just-in-time loading.

Quality

38%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./skills/filesystem-context/SKILL.md

Quality

Content

38%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This skill reads more like a conceptual tutorial or blog post about filesystem-based context engineering than an actionable skill for Claude. It over-explains concepts Claude already knows (context windows, filesystem tools, static vs dynamic context), provides mostly illustrative rather than executable code, and packs everything into a single long document without supporting bundle files. The patterns themselves are useful but would benefit from being more concise, more executable, and better structured across multiple files.

Suggestions

Cut conceptual explanations Claude already knows (what context windows are, how grep works, what static vs dynamic means) and focus on the specific patterns and when to apply them—this could reduce the document by 40-50%.

Make code examples executable: replace undefined helper functions like `extract_summary()` and `load_yaml()` with actual implementations or use real tool calls that Claude can execute.

Split the six patterns into separate files (e.g., patterns/scratch-pad.md, patterns/plan-persistence.md) and keep SKILL.md as a concise overview with clear references to each pattern file.

Add explicit validation steps to patterns involving file writes and self-modification—e.g., verify file exists after write, validate YAML structure after self-modification, implement cleanup verification for scratch files.

Dimension	Reasoning	Score
Conciseness	The skill extensively explains concepts Claude already understands well—what static vs dynamic context is, why context windows are limited, how grep/ls/glob work, what filesystem traversal means. There's significant padding throughout (e.g., 'The core insight is...', explaining the four failure modes abstractly before getting to patterns). The content could be cut by 50%+ without losing actionable value.	2 / 5
Actionability	The skill provides some code examples (Python snippets, YAML structures, directory layouts) but most are pseudocode or illustrative rather than truly executable. The Python examples use undefined functions like `extract_summary()`, `load_yaml()`, `write_yaml()`. The examples section uses a text-diagram format rather than executable code. Guidance is concrete enough to follow but not copy-paste ready.	3 / 5
Workflow Clarity	Each pattern describes a problem/solution structure but lacks explicit validation checkpoints or feedback loops. For example, Pattern 1 (scratch pad) doesn't validate that the file was written successfully or that the summary is adequate. Pattern 6 (self-modification) mentions needing guardrails but doesn't specify them. The guidelines section at the end lists steps but without sequencing or validation. Since filesystem operations can be destructive (cleanup, self-modification), the missing validation caps this at 3.	3 / 5
Progressive Disclosure	The skill is a monolithic ~350-line document with no bundle files to support it. The References and Integration sections mention related skills and resources but none are actual files in the bundle. Content like the six detailed patterns, filesystem search techniques, and practical guidance sections could be split into separate files. Everything is inlined with no actual progressive disclosure structure.	2 / 5
	Total	10 / 20 Passed

Description

37%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

The description relies heavily on abstract, jargon-laden concepts without specifying concrete actions or natural user trigger phrases. While it identifies a domain (context management via files), it fails to enumerate specific operations (e.g., 'save conversation context to a file,' 'load relevant context from stored files') and lacks natural language triggers that users would actually use. The 'Use for' clause provides some structure but the triggers are too abstract to reliably distinguish this skill from related ones.

Suggestions

Replace abstract terms with concrete actions, e.g., 'Saves conversation context to files, loads relevant context on demand, splits large documents into smaller retrievable chunks.'

Add natural trigger terms users would actually say, e.g., 'Use when the conversation is getting too long, when Claude needs to remember information across tasks, or when the user says "save this for later" or "load that context."'

Clarify what distinguishes this from general file management by specifying the unique mechanism, e.g., 'Manages .context files to store and retrieve working memory, preventing token limit issues.'

Dimension	Reasoning	Score
Specificity	Names the domain ('context management') and mentions a few concepts like 'offload context to files' and 'just-in-time loading,' but the actions are abstract and not concrete. Terms like 'dynamic context discovery' and 'reducing context window bloat' are conceptual rather than specific actionable operations.	2 / 5
Completeness	The description starts with 'Use for...' which partially addresses 'when,' but the 'when' triggers are abstract concepts rather than concrete scenarios. The 'what' is weakly implied through phrases like 'offload context to files' but lacks specificity about concrete actions. The 'Use for' clause is present but not explicit enough about real user scenarios.	3 / 5
Trigger Term Quality	Includes some technical terms like 'context window,' 'context management,' and 'just-in-time loading,' but these are jargon-heavy and not natural phrases a user would say. Users are more likely to say things like 'save this for later,' 'remember this,' 'load file,' or 'too much context' rather than 'context window bloat' or 'dynamic context discovery.'	2 / 5
Distinctiveness Conflict Risk	The concept of 'file-based context management' is somewhat specific, but terms like 'context management' and 'reducing context window bloat' are broad enough to overlap with general file management skills, memory/persistence skills, or summarization skills. The niche is identifiable but not sharply delineated.	3 / 5
	Total	10 / 20 Passed

Validation

90%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: administrakt0r/AI-Agents-Safe-Coding-Skills
Path: skills/filesystem-context/SKILL.md
Commit: 57c135b

Reviewed: 3 days ago

Table of Contents

Discovery Implementation Validation

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.