bun-ffi
This skill should be used when the user asks about "bun:ffi", "foreign function interface", "calling C from Bun", "native libraries", "dlopen", "shared libraries", "calling native code", or integrating C/C++ libraries with Bun.
74
67%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/bun/skills/bun-ffi/SKILL.mdQuality
Discovery
62%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 excels at trigger terms and distinctiveness, providing comprehensive keywords users would naturally use when needing FFI help with Bun. However, it completely lacks any description of what the skill actually does — it only specifies when to use it, not what capabilities it provides. Adding concrete actions would significantly improve this description.
Suggestions
Add a 'what it does' clause listing specific capabilities, e.g., 'Guides users through loading shared libraries with dlopen, defining FFI symbols, calling native C/C++ functions, handling data types and pointers, and managing memory in Bun's FFI.'
Restructure to lead with capabilities before the 'Use when...' clause, e.g., 'Explains how to use Bun's bun:ffi module to load shared libraries, define native function signatures, and call C/C++ code from JavaScript. Use when...'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description does not describe any concrete actions or capabilities. It only states when the skill should be used, but never explains what it actually does (e.g., 'generates FFI bindings', 'loads shared libraries', 'calls native C functions'). | 1 / 3 |
Completeness | The 'when' is explicitly and thoroughly covered with multiple trigger scenarios, but the 'what' (what the skill actually does) is entirely missing. The description never explains the capabilities or actions the skill performs. | 2 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms: 'bun:ffi', 'foreign function interface', 'calling C from Bun', 'native libraries', 'dlopen', 'shared libraries', 'calling native code', and 'C/C++ libraries with Bun' are all terms users would naturally use. | 3 / 3 |
Distinctiveness Conflict Risk | The description targets a very specific niche — Bun's FFI for calling native C/C++ code — with distinct trigger terms like 'bun:ffi', 'dlopen', and 'calling C from Bun' that are unlikely to conflict with other skills. | 3 / 3 |
Total | 9 / 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, well-structured FFI reference skill with excellent actionability through concrete, executable code examples covering the full range of FFI operations. Its main weaknesses are the lack of validation/error-checking steps in workflows involving pointer manipulation and memory management, and some verbosity in the type mappings section that Claude likely doesn't need spelled out in full.
Suggestions
Add explicit validation checkpoints to the pointer and SQLite examples—check return codes from dlopen (null check), sqlite3_open (SQLITE_OK), and validate pointers before use to create proper feedback loops for error recovery.
Trim the FFI Types section to only show non-obvious mappings or group them more compactly, since Claude can infer standard C-to-FFI type correspondences.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient but includes some redundancy—the full FFI types table maps every type with C equivalents Claude already knows, and some sections like Thread Safety and Memory Management are thin enough to be combined. The cross-platform loading helper function is useful but somewhat verbose. | 2 / 3 |
Actionability | Nearly every section provides fully executable, copy-paste ready TypeScript code with concrete examples covering dlopen, function definitions, strings, pointers, structs, callbacks, and a complete SQLite example. The code is specific and directly usable. | 3 / 3 |
Workflow Clarity | The skill presents individual operations clearly but lacks explicit validation checkpoints. For FFI work involving memory management and pointer operations (destructive/risky), there are no verification steps—e.g., checking return codes from dlopen or sqlite3_open, or validating pointer validity before use. The common errors table helps but doesn't constitute a feedback loop. | 2 / 3 |
Progressive Disclosure | The content is well-structured with a quick start, logically organized sections progressing from simple to complex, and clear references to external files (references/type-mappings.md, references/performance.md) with specific guidance on when to load them. Navigation is straightforward. | 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
88da5ff
- 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.