audit-context-building

Enables ultra-granular, line-by-line code analysis to build deep architectural context before vulnerability or bug finding.

Quality

33%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Risky

Do not use without reviewing

Optimize this skill with Tessl

npx tessl skill review --optimize ./skills/audit-context-building/SKILL.md

Quality

Discovery

32%

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 conveys a general sense of purpose—deep code analysis for security and bug finding—but lacks concrete action verbs, explicit trigger guidance, and natural user-facing keywords. The use of marketing-style language ('ultra-granular,' 'deep architectural context') adds fluff without improving selectability. It would benefit significantly from a 'Use when...' clause and more specific capability listing.

Suggestions

Add an explicit 'Use when...' clause with natural trigger terms, e.g., 'Use when the user asks for a security audit, code review for vulnerabilities, bug hunting, or wants to understand code architecture before identifying issues.'

List specific concrete actions instead of abstract descriptions, e.g., 'Performs line-by-line code analysis, maps function call graphs, identifies security vulnerabilities (injection, XSS, buffer overflow), and traces data flow for bug detection.'

Remove marketing fluff like 'ultra-granular' and 'deep' in favor of precise, user-facing terminology such as 'static analysis,' 'security review,' or 'code audit.'

Dimension	Reasoning	Score
Specificity	Names the domain (code analysis, vulnerability/bug finding) and mentions 'line-by-line code analysis' and 'build deep architectural context,' but doesn't list multiple concrete actions—it's more of a high-level description of an approach than specific capabilities.	2 / 3
Completeness	Describes what it does (line-by-line code analysis for architectural context before vulnerability/bug finding) but has no explicit 'Use when...' clause or equivalent trigger guidance, which per the rubric caps completeness at 2, and even the 'what' is vague enough that this falls to 1.	1 / 3
Trigger Term Quality	Includes some relevant terms like 'code analysis,' 'vulnerability,' 'bug finding,' and 'architectural context,' but misses common user-facing variations like 'security audit,' 'code review,' 'static analysis,' 'CVE,' or 'security scan.' The phrase 'ultra-granular' is jargon unlikely to appear in user requests.	2 / 3
Distinctiveness Conflict Risk	The combination of 'line-by-line code analysis' with 'vulnerability or bug finding' provides some distinctiveness, but it could easily overlap with general code review skills, security scanning skills, or static analysis skills without clearer boundaries.	2 / 3
	Total	7 / 12 Passed

Implementation

35%

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

This skill is well-structured in concept with clear phases and checklists, but suffers significantly from verbosity—it explains many concepts Claude already knows and repeats its constraints multiple times. The lack of concrete, executable examples (code snippets, actual analysis output) weakens actionability, and the referenced bundle files are missing, undermining the progressive disclosure strategy.

Suggestions

Cut at least 50% of the content by removing explanations of concepts Claude already knows (First Principles, 5 Whys, anti-hallucination principles) and consolidating repeated 'non-goals' and 'do not' sections into a single brief constraint block.

Add a concrete, inline mini-example showing actual analysis output for a small code snippet (3-5 lines of code → structured analysis output), rather than deferring entirely to FUNCTION_MICRO_ANALYSIS_EXAMPLE.md.

Define explicit transition criteria between phases (e.g., 'Move to Phase 2 when all entrypoints and state variables are catalogued') to strengthen workflow clarity.

Provide the referenced bundle files (FUNCTION_MICRO_ANALYSIS_EXAMPLE.md, OUTPUT_REQUIREMENTS.md, COMPLETENESS_CHECKLIST.md) or inline their essential content to make the skill self-contained.

Dimension	Reasoning	Score
Conciseness	The skill is extremely verbose at ~300+ lines, with extensive explanation of concepts Claude already understands (First Principles, 5 Whys, anti-hallucination). The 'Rationalizations' table, lengthy phase descriptions, and repeated emphasis on 'do not find vulnerabilities' are padded. Much of this could be condensed to a fraction of its size while preserving all actionable content.	1 / 3
Actionability	The skill provides structured checklists and clear enumeration of steps (Phase 1-3, per-function checklist), which is somewhat concrete. However, there is no executable code, no specific commands, and the guidance remains largely procedural/conceptual rather than copy-paste ready. The 'quality thresholds' (minimum 3 invariants, etc.) add some concreteness but are arbitrary without examples.	2 / 3
Workflow Clarity	The three-phase workflow (Orientation → Granular Analysis → Global Understanding) is clearly sequenced, and the completeness checklist provides a validation checkpoint. However, there are no explicit feedback loops for error recovery, and the transitions between phases lack concrete triggers or criteria for when to move forward. The validation is deferred to an external checklist file.	2 / 3
Progressive Disclosure	The skill references three external files (FUNCTION_MICRO_ANALYSIS_EXAMPLE.md, OUTPUT_REQUIREMENTS.md, COMPLETENESS_CHECKLIST.md) which is good progressive disclosure design. However, no bundle files are provided, so these references are unverifiable. The main SKILL.md itself is still a wall of text that could benefit from moving more detail into referenced files rather than inlining so much content.	2 / 3
	Total	7 / 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: sickn33/antigravity-awesome-skills
Commit: 96e6849

Reviewed: about 19 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.