CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

bun-hono-integration

Use when building APIs with Hono framework on Bun, including routing, middleware, REST APIs, context handling, or web framework features.

58

Quality

73%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

High

Do not use without reviewing

Fix and improve this skill with Tessl

tessl review fix ./plugins/bun/skills/bun-hono-integration/SKILL.md
SKILL.md
Quality
Evals
Security

Quality

Content

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

A well-organized, highly executable Hono reference whose main costs are length and redundancy: it inlines basic API usage Claude already knows, repeats boilerplate across sections, and points to reference files that are missing from the bundle. The reference-signaling pattern is right, but the split between overview and detail is not actually realized.

Suggestions

Create the referenced files (references/middleware-list.md, references/openapi.md) or remove the 'When to Load References' section — currently both paths are dangling, so progressive disclosure is promised but not delivered.

Trim the basic-API sections (HTTP method routes, query/header access, standard c.text/c.json/c.html responses) down to one-liners or move them to a reference file; keep the body focused on what distinguishes Hono-on-Bun (Quick Start, zValidator, RPC mode, typed Context variables) to cut hundreds of tokens of material Claude already knows.

Deduplicate the 'import { Hono}; const app = new Hono(); export default app' boilerplate repeated in nearly every section, and fix the non-executable snippets (undefined authMiddleware/adminMiddleware, c.req.valid() outside a validator) so all code is copy-paste ready.

DimensionReasoningScore

Conciseness

The body is code-dense with almost no prose padding, but ~380 lines largely restate basic Hono API usage (app.get, c.json, query/header access, cors/logger setup) that Claude already knows, and every section repeats the 'import { Hono }; new Hono()' boilerplate. Not a 2 because there is no explanatory verbosity; not a 4 because the basic-API reference material could be cut substantially.

3 / 5

Actionability

Nearly all guidance is executable, copy-paste-ready TypeScript with a concrete quick start ('bun create hono my-app'), complete zValidator examples, and a debugging table with fixes. Not a 5 because 'app.use("/admin/*", authMiddleware, adminMiddleware)' references undefined variables and 'c.req.valid("json")' is shown in a route with no validator attached, so those snippets fail verbatim.

4 / 5

Workflow Clarity

Only the Quick Start forms a sequence (create, install, run dev); the rest of the body is an unordered reference compendium with no guidance on sequencing a real build (routes, then middleware, then validation, then error handling) and no testing or validation checkpoints. It is not a 2 because the quick start is coherent and the Common Errors table gives some error-recovery guidance; not a 4 because no explicit checkpoints or build sequence exist beyond the trivial quick start.

3 / 5

Progressive Disclosure

The 'When to Load References' section explicitly signals when to load each reference with bullet conditions, which is good practice — but both referenced files ('references/middleware-list.md', 'references/openapi.md') do not exist in the bundle, and the full built-in middleware/API reference is inlined in the body rather than split into those files. Not a 4 due to the dangling references and inlined bulk; not a 2 since section structure and reference signaling are genuinely present.

3 / 5

Total

13

/

20

Passed

Description

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

A strong description with an explicit trigger clause, natural technical keywords, and a clearly distinct niche from naming both Hono and Bun. Its main weakness is that the capability statement lives inside the 'when' clause rather than as a standalone 'what this does' statement, and coverage of the body's actual topics (validation, error handling, RPC) is incomplete.

DimensionReasoningScore

Specificity

Names the domain ('building APIs with Hono framework on Bun') and several concrete capability areas ('routing, middleware, REST APIs, context handling'), though it omits covered topics like validation, error handling, and RPC mode, keeping it below comprehensive coverage.

4 / 5

Completeness

An explicit 'Use when...' clause clearly answers when; the 'what' (building APIs with Hono on Bun covering routing, middleware, REST APIs, context handling) is present but embedded inside the when-clause rather than stated independently. Both are present, but the what-portion could be more explicit.

4 / 5

Trigger Term Quality

Includes natural user terms like 'Hono', 'Bun', 'APIs', 'middleware', and 'routing', giving good keyword coverage. A few natural synonyms users might say ('endpoint', 'backend server', 'web server') are missing, so it falls short of comprehensive.

4 / 5

Distinctiveness Conflict Risk

Naming two specific technologies ('Hono framework on Bun') carves a clear niche with distinct triggers and minimal conflict risk with other web-framework or runtime skills.

5 / 5

Total

17

/

20

Passed

Validation

93%

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

CriteriaDescriptionResult

referenced_paths_exist

Referenced path issues: 2 missing

Warning

Total

15

/

16

Passed

Repository

secondsky/claude-skills

Path

plugins/bun/skills/bun-hono-integration/SKILL.md

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.