zoom-out

Tell the agent to zoom out and give broader context or a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how it fits into the bigger picture.

Quality

40%

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 ./.cursor/skills/zoom-out/SKILL.md

Quality

Content

22%Scale 1-3

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

This skill reads as a raw prompt or user instruction rather than a structured skill that teaches Claude a methodology. It lacks any concrete steps, examples of expected output format, or guidance on how to systematically discover and map code architecture. The content would benefit significantly from defining a clear process, specifying what tools to use (e.g., grep, file reading), and showing an example of the desired output format.

Suggestions

Add a concrete workflow with steps: e.g., 1) Identify the current file/function, 2) Search for imports/callers using grep or similar, 3) Map dependencies, 4) Present findings in a specific format

Include an example of the expected output format (e.g., a module map, dependency diagram, or structured summary) so Claude knows what to produce

Specify which tools Claude should use to discover modules and callers (e.g., grep for imports, read directory structures, search for function references)

Add guidance on how to identify and use the project's 'domain glossary vocabulary' — where to find it and how to apply it in the output

Dimension	Reasoning	Score
Conciseness	The content is brief (two sentences), which is good, but it reads more like a prompt/instruction to Claude rather than a skill that teaches Claude how to perform a task. It's lean but doesn't quite earn every token since it's essentially a user-facing prompt rather than structured guidance.	2 / 3
Actionability	The content provides no concrete steps, commands, code examples, or specific methodology for how Claude should actually perform the 'zooming out' task. It's a vague directive with no executable guidance on how to discover modules, callers, or domain glossary vocabulary.	1 / 3
Workflow Clarity	There is no workflow, no sequenced steps, and no validation checkpoints. The skill is a single vague instruction with no process for how to systematically map modules, identify callers, or produce the desired output.	1 / 3
Progressive Disclosure	For a skill this short with no bundle files, the lack of external references is acceptable. However, the content is so minimal that it's essentially unstructured — no sections, no headers, no organization at all. It's not a wall of text, but it's also not well-organized.	2 / 3
	Total	6 / 12 Passed

Description

57%Scale 1-3

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 has good structural completeness with both 'what' and 'when' clauses, but suffers from vague capability specification—it describes a meta-instruction ('tell the agent to zoom out') rather than concrete actions the skill performs. The trigger terms are reasonable but not comprehensive, and the skill's niche could easily overlap with other code comprehension skills.

Suggestions

Replace vague language like 'zoom out' and 'broader context' with specific actions the skill performs, e.g., 'Summarizes module architecture, explains component relationships, and maps code dependencies.'

Add more natural trigger terms users would say, such as 'explain this codebase', 'architecture overview', 'what does this module do', 'how does this file relate to the rest of the project'.

Avoid describing the skill as an instruction to the agent ('Tell the agent to...') and instead use third person voice describing what the skill does ('Provides broader context and higher-level perspective on code sections').

Dimension	Reasoning	Score
Specificity	The description uses vague language like 'zoom out' and 'broader context' without listing concrete actions. It doesn't specify what the skill actually does—no mention of specific outputs like generating architecture diagrams, summarizing module dependencies, or explaining call hierarchies.	1 / 3
Completeness	It does answer both 'what' (tell the agent to zoom out and give broader context) and 'when' (when unfamiliar with code or need to understand how it fits into the bigger picture) with explicit trigger guidance via a 'Use when' clause.	3 / 3
Trigger Term Quality	Contains some relevant terms like 'broader context', 'higher-level perspective', 'bigger picture', and 'unfamiliar with a section of code', which users might naturally say. However, it misses common variations like 'explain this codebase', 'architecture overview', 'how does this work', or 'what does this module do'.	2 / 3
Distinctiveness Conflict Risk	The concept of 'broader context' and 'higher-level perspective' on code is somewhat specific but could overlap with skills related to code explanation, documentation generation, or code review. The triggers are not sharply distinct from general code understanding skills.	2 / 3
	Total	8 / 12 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: SnowingFox/ai-skills
Path: .cursor/skills/zoom-out/SKILL.md
Commit: d6882ad

Reviewed: ~14 hours 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.