compiler-verify

Use when you need to run all compiler checks (tests, lint, format) before committing. Detects whether TS or Rust code changed and runs the appropriate checks.

Quality

89%

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

Quality

Content

100%Weight 40%Scale 1-5

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

An exemplary operational skill body: fully executable commands with stop-on-failure sequencing, a Common Mistakes section that captures real pitfalls (running prettier from the wrong directory, forgetting Rust tests), and lean organization with no padding. The only cosmetic flaw is that the first 'Common Mistakes' bullet ('Running yarn snap without -p is fine... slow') describes an optimization tip rather than a mistake, which slightly muddies that section's heading.

Dimension	Reasoning	Score
Conciseness	The body is entirely operational — commands, categorization rules, and pitfalls — with zero explanations of concepts Claude already knows. Matches the 5 anchor ('lean and efficient; every token earns its place'); parentheticals like 'compares Rust vs TS compiler output' are load-bearing, not padding, so it does not drop to 4.	5 / 5
Actionability	Every step is a copy-paste-ready command: 'git diff --name-only HEAD', 'yarn snap -p <pattern>', 'yarn workspace babel-plugin-react-compiler lint', 'bash compiler/scripts/test-babel-ast.sh', 'yarn snap --rust'. Matches the 5 anchor (fully executable, common cases covered); no gaps place it at 4.	5 / 5
Workflow Clarity	Clear numbered sequence with per-track '(stop on failure)' checkpoints, an unconditional format step, plan-doc checks, and an explicit feedback loop: 'On failure, stop and show the error with suggested fixes.' Matches the 5 anchor (explicit validation steps and error-recovery loop); the operations are non-destructive so no cap applies.	5 / 5
Progressive Disclosure	The skill is under 50 lines with no external references needed, and per the rubric's simple-skill guideline well-organized sections suffice. Sections (Instructions, Common Mistakes) are clearly labeled and flat — matching the 5 anchor for this class of skill; there are no buried or nested references.	5 / 5
	Total	20 / 20 Passed

Description

78%Weight 40%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.

A strong description with an explicit 'Use when...' trigger, concrete enumerated capabilities (tests, lint, format), and clear TS/Rust scoping. Its main faults are the second-person 'Use when you need to...' phrasing (penalized under the rubric's third-person voice rule) and missing common synonyms like 'verify' or 'pre-commit'.

Suggestions

Rewrite in third-person imperative voice to avoid the specificity penalty, e.g.: 'Runs all compiler checks (tests, lint, format) before committing. Detects whether TS or Rust code changed and runs the appropriate checks. Use when committing compiler changes or when the user asks to run compiler tests, lint, or formatting checks.'

Add natural trigger synonyms users might say — 'verify compiler changes', 'pre-commit checks', 'CI' — to broaden keyword coverage without adding length.

Make the 'what' more precise by naming the actual commands or suites (e.g., 'yarn snap', 'Rust port tests') to sharpen distinctiveness against generic test-runner skills.

Dimension	Reasoning	Score
Specificity	The description lists several concrete actions — 'run all compiler checks (tests, lint, format)' and 'Detects whether TS or Rust code changed and runs the appropriate checks' — which fits the 4 anchor, but the rubric mandates a 1-point penalty for second-person voice ('Use when you need to...'), bringing it to 3. Not a 2 because the domain and actions are named concretely, unlike 'Names the domain but actions are minimal'.	3 / 5
Completeness	Both parts are explicitly answered: what — 'Detects whether TS or Rust code changed and runs the appropriate checks (tests, lint, format)'; when — 'Use when you need to run all compiler checks... before committing'. Matches the 5 anchor (clear 'what' and 'when' with concrete trigger phrases); not 4 because the 'when' is already explicit and specific rather than improvable.	5 / 5
Trigger Term Quality	Natural trigger terms are present: 'compiler checks', 'tests, lint, format', 'before committing', 'TS or Rust'. Fits anchor 4 ('good keyword coverage; a few natural terms missing') — synonyms like 'verify', 'CI', or 'pre-commit' are absent, so it does not reach 5; it exceeds 3 because the terms users would actually say are included.	4 / 5
Distinctiveness Conflict Risk	The TS/Rust compiler-verification niche ('Detects whether TS or Rust code changed') is distinct with project-specific commands, but the generic framing 'run all compiler checks before committing' could overlap with broader test/CI/verify skills — fitting anchor 4 ('mostly distinct; minor overlap risk') rather than 5.	4 / 5
	Total	16 / 20 Passed

Validation

100%

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 — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository: facebook/react
Path: compiler/.claude/skills/compiler-verify/SKILL.md
Commit: 7c6ac13

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.