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.
60
70%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Risky
Do not use without reviewing
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/bun/skills/bun-macros/SKILL.mdQuality
Discovery
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 |
Implementation
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 |
Validation
100%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
Table of Contents
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.