implementing-jsc-classes-cpp

Implements JavaScript classes in C++ using JavaScriptCore. Use when creating new JS classes with C++ bindings, prototypes, or constructors.

Quality

88%

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

90%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.

The body is a dense, executable reference for implementing JSC C++ classes with strong actionability and token efficiency. Workflow sequencing is clear and the iso-subspace lint is referenced as a guard, though an explicit validation checkpoint would push it higher.

Suggestions

Add an explicit validation step pointing Claude to run the iso-subspace-creation test (and any build) before declaring the class implementation complete.

Consider moving the full Prototype and Constructor class boilerplate into a reference template file, keeping SKILL.md as an overview with the key variants inline.

Dimension	Reasoning	Score
Conciseness	Lean, code-dense reference that assumes Claude's competence with C++ and JavaScriptCore; prose is minimal and every section earns its place without explaining basics.	5 / 5
Actionability	Provides fully executable, copy-paste-ready C++ covering prototype class, constructor class, getter/function bodies, subspace template, structure caching, and Zig exports using a consistent Foo template.	5 / 5
Workflow Clarity	Sections are sequenced as a buildable recipe (Class Structure → Iso Subspaces → Properties → Prototype → Getter/Function → Constructor → Structure Caching → Expose to Zig), and the iso-subspace lint test is cited as a checkpoint, but there is no explicit validate-then-proceed feedback loop.	4 / 5
Progressive Disclosure	Well-organized into single-purpose sections with one-level-deep file references (DOMIsoSubspaces.h, BunClientData.cpp, the source-lints test); no bundle files exist, so structure is self-contained and navigable, though some inlined full-class blocks could live in references.	4 / 5
	Total	18 / 20 Passed

Description

87%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.

The description cleanly answers both what the skill does and when to invoke it, using third person and natural trigger terms. It is specific and unlikely to conflict with unrelated skills.

Dimension	Reasoning	Score
Specificity	Names the domain ('JavaScript classes in C++ using JavaScriptCore') and several concrete actions ('creating new JS classes with C++ bindings, prototypes, or constructors'), but does not enumerate the full surface (e.g., subspace setup, structure caching) so coverage has minor gaps.	4 / 5
Completeness	Explicitly states both what ('Implements JavaScript classes in C++ using JavaScriptCore') and when ('Use when creating new JS classes with C++ bindings, prototypes, or constructors') with concrete trigger phrases.	5 / 5
Trigger Term Quality	Includes natural developer phrasing ('JS classes', 'C++ bindings', 'prototypes', 'constructors') that users would say, but misses common synonyms like 'JS wrapper' or 'JSC API'.	4 / 5
Distinctiveness Conflict Risk	A clear niche (JavaScriptCore C++ class implementation) with distinct triggers and minimal overlap risk against other skills.	5 / 5
	Total	18 / 20 Passed

Validation

93%

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

Validation for skill structure

Criteria	Description	Result
relative_links	Relative link issues: 1 suspicious	Warning

	Total	15 / 16 Passed

Repository: oven-sh/bun
Path: .claude/skills/implementing-jsc-classes-cpp/SKILL.md
Commit: abe2ad4

Reviewed: 1 day 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.