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.
79
73%
Does it follow best practices?
Impact
Pending
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.
The description is well-structured with a clear 'what' and explicit 'when' clause, making it functionally complete. It occupies a distinct niche that minimizes conflict risk. However, it could benefit from more specific concrete actions and broader trigger term coverage to help users who might phrase their needs differently.
Suggestions
Add more specific concrete actions, e.g., 'Evaluates JavaScript expressions at bundle time, embeds file contents as strings, resolves environment variables to static values, and pre-computes constants.'
Expand trigger terms with natural variations users might say, such as 'build-time evaluation', 'static code generation', 'compile-time macros', or specific tool names 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 general. It lists use cases but doesn't enumerate multiple distinct concrete operations like 'extract, fill, merge' would. | 2 / 3 |
Completeness | Clearly answers both 'what' (evaluate JavaScript at bundle time and inline results) and 'when' with an explicit 'Use when...' clause listing four specific trigger scenarios: optimizing compile-time code generation, embedding files, inlining environment variables, or executing code during bundling. | 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', 'Bun macros', or specific tool names. The terms are somewhat technical and may not cover all natural phrasings. | 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 to compile-time/bundle-time code execution. | 3 / 3 |
Total | 10 / 12 Passed |
Implementation
72%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 for Bun macros with good progressive disclosure. Its main weakness is verbosity—too many use case examples that could be consolidated, and the workflow for actually developing/debugging macros could be more explicitly sequenced with validation steps.
Suggestions
Consolidate the many use case examples (env, git, file embedding, constants, directory listing, code generation) into fewer representative examples with brief mentions of other patterns, reducing token count significantly.
Add an explicit step-by-step workflow for creating a new macro: write macro → test as regular function → import with attribute → build → verify output, with validation at each step.
| 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, Parameters section, and some use cases (like Code Generation with placeholder functions) add bulk without proportional value. Several examples could be consolidated. | 2 / 3 |
Actionability | Nearly all examples are fully executable, copy-paste ready TypeScript with clear import syntax, macro file structure, and consumer usage. The build command is explicit, error handling patterns are concrete, and the common errors table provides specific fixes. | 3 / 3 |
Workflow Clarity | The skill clearly explains that macros only run during bundling (with explicit commands), and the error handling section shows build-time validation. However, there's no explicit workflow for creating and testing a macro end-to-end, and no validation checkpoint between writing a macro and building. The debugging section is minimal. | 2 / 3 |
Progressive Disclosure | The content is well-structured with a quick start, common use cases, and advanced topics. References to external files (advanced-patterns.md, debugging.md) are clearly signaled with specific trigger conditions, keeping the main file as an overview with one-level-deep navigation. | 3 / 3 |
Total | 10 / 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
40506e5
- 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.