bun-macros

Evaluate JavaScript at bundle time and inline results. Use when optimizing compile-time code generation, embedding files, inlining environment variables, or executing code during the bundling process.

Quality

70%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Risky

Do not use without reviewing

Fix and improve this skill with Tessl

tessl review fix ./plugins/bun/skills/bun-macros/SKILL.md

Quality

Content

64%

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

This is a solid, example-rich skill that provides highly actionable guidance on Bun macros with executable code throughout. Its main weaknesses are verbosity—too many use cases are inlined rather than referenced—and a lack of explicit workflow validation steps for catching macro evaluation failures. The progressive disclosure structure is partially implemented but the body carries too much weight.

Suggestions

Move 3-4 of the less common use cases (Directory Listing, Code Generation, Conditional Code, Parameters) into a referenced file like `references/advanced-patterns.md` to reduce the main body length.

Add an explicit workflow section with validation: e.g., '1. Create macro file → 2. Import with attribute → 3. Build with `bun build` → 4. Verify output contains inlined values → 5. If not inlined, check import attribute syntax'.

Remove the 'Return Types' primitives listing (getString, getNumber, getBoolean, getNull) as Claude already knows these; keep only the non-obvious ones like Response.

Dimension	Reasoning	Score
Conciseness	The skill is mostly efficient with good code examples, but is overly exhaustive in listing use cases. The 'Return Types' section enumerates obvious primitives Claude already knows, and several use case sections (Code Generation, Conditional Code) add marginal value. The content could be tightened by ~30% without losing actionability.	2 / 3
Actionability	Nearly every section provides fully executable, copy-paste-ready TypeScript code with clear import syntax, macro file structure, and consumer usage. The common errors table and the bundle-only execution note with exact CLI commands are highly concrete and actionable.	3 / 3
Workflow Clarity	The skill clearly explains the two-file pattern (macro file + consumer) and notes that macros only run during bundling, but there's no explicit step-by-step workflow for creating and validating macros. The error handling section exists but there's no feedback loop (e.g., build → check output → fix → rebuild). For a process that can silently fail to inline, validation checkpoints would be valuable.	2 / 3
Progressive Disclosure	The skill references `references/advanced-patterns.md` and `references/debugging.md` with clear loading criteria, which is good. However, the main body is quite long (~200+ lines) with many use case sections that could be offloaded to a reference file, and no bundle files were provided to verify the references exist. The inline content is heavy for what should be an overview.	2 / 3
	Total	9 / 12 Passed

Description

75%

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 is a solid description that clearly communicates both what the skill does and when to use it, with an explicit 'Use when' clause. Its main weakness is that the capability description could be more concrete with specific discrete actions, and the trigger terms could include more natural variations that users might employ. Overall it performs well for skill selection purposes.

Suggestions

Add more specific concrete actions, e.g., 'Evaluates JavaScript expressions at bundle time, embeds file contents as strings, replaces environment variable references with their values, and pre-computes static expressions.'

Include additional natural trigger terms users might say, such as 'build-time evaluation', 'static code generation', 'macro expansion', or specific tool references like 'Bun macros' if applicable.

Dimension	Reasoning	Score
Specificity	Names the domain (JavaScript bundle-time evaluation) and some actions (embedding files, inlining environment variables, executing code during bundling), but the primary action 'evaluate JavaScript at bundle time and inline results' is somewhat abstract. It lists use cases rather than concrete discrete actions like 'extract', 'fill', 'merge'.	2 / 3
Completeness	Clearly answers both 'what' (evaluate JavaScript at bundle time and inline results) and 'when' (Use when optimizing compile-time code generation, embedding files, inlining environment variables, or executing code during the bundling process) with an explicit 'Use when...' clause.	3 / 3
Trigger Term Quality	Includes relevant terms like 'compile-time code generation', 'inlining environment variables', 'bundling process', but misses common natural variations users might say such as 'macros', 'build-time evaluation', 'static evaluation', or specific tool names. The terms lean slightly technical but are reasonable for the domain.	2 / 3
Distinctiveness Conflict Risk	This is a very specific niche — bundle-time JavaScript evaluation — that is unlikely to conflict with general JavaScript skills, build tools, or other bundler-related skills. The triggers are distinct and narrowly scoped.	3 / 3
	Total	10 / 12 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 — 11 / 11 Passed

Validation for skill structure

No warnings or errors.

Repository: secondsky/claude-skills
Commit: 5e92b71

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