CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

ax-java-playbook

Use when writing Java code with `dev.axllm:ax` for the playbook() context-engineering surface, agent-bound verified evolution, run-end learning, online updates, and rendering a playbook into a program.

Quality

82%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

SKILL.md
Quality
Evals
Security

Quality

Content

80%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 compact, well-organized body that is token-efficient and rich in non-obvious package facts. Its main gap is workflow clarity: tasks are listed as bullets without sequenced steps or explicit validation checkpoints for the evolve/refine operations, and the single code snippet has undefined variables.

Suggestions

Add a short numbered workflow for the core evolve loop (create program -> attach playbook -> run evolve -> check verification -> rollback on failure) with an explicit validation checkpoint, so the verified-evolution and online-refinement tasks have sequenced steps.

Make the Core Pattern snippet executable by showing how llm, examples, and metricFn are constructed (e.g., a minimal no-key example from the package), or explicitly point to the specific example file in examples/ that demonstrates the full call shape.

Briefly sequence the render/persist path (render playbook -> persist -> inject into program context) the way the other 'When To Use' bullets are framed, since it is currently only named, never shown.

DimensionReasoningScore

Conciseness

Lean and efficient: every line carries non-obvious facts Claude cannot know (runtime profiles, no-key transport, AxIR as source of truth, guardrails against copying maintainer skills). No padding or explanation of known concepts, so it sits at the top anchor rather than 4.

5 / 5

Actionability

The Core Pattern gives real Java syntax ('AxPlaybook pb = Ax.playbook(program, java.util.Map.of("studentAI", llm)); pb.evolve(examples, metricFn, java.util.Map.of());') but depends on undefined variables (llm, examples, metricFn) and offers no code for refine-online or render/persist. Above 3 because it is genuine syntax rather than pseudocode; below 5 because it is not copy-paste ready and common cases lack examples.

4 / 5

Workflow Clarity

'When To Use' enumerates distinct tasks rather than a sequenced workflow, and multi-step operations like verified evolution (with rollback) and online refinement lack explicit validate->fix->retry checkpoints. Above 2 because tasks are clearly delineated and the Core Pattern implies a create->attach->evolve sequence; below 4 because checkpoints are missing or only implicit.

3 / 5

Progressive Disclosure

The body is under 50 lines, requires no external bundle files (references/, scripts/, assets/ are absent), and is cleanly organized into well-labeled sections (When To Use, Package Facts, Core Pattern, Relevant API Surface, Guardrails). Per the rubric's simple-skill note, this earns the top anchor on organization alone.

5 / 5

Total

17

/

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 'Use when' clause, a specific package anchor, and a concrete enumeration of capabilities. Its main weaknesses are jargon-heavy phrasing ('context-engineering surface') that users would not naturally say and slight coverage gaps in the capability list.

DimensionReasoningScore

Specificity

Lists several specific capability areas ('playbook() context-engineering surface', 'agent-bound verified evolution', 'run-end learning', 'online updates', 'rendering a playbook into a program'), though they read more as feature labels than fully concrete actions. Below 5 because coverage has gaps (e.g., offline refinement from labeled examples is omitted); above 3 because it names well more than 1-2 concrete actions.

4 / 5

Completeness

Explicitly answers both: 'Use when writing Java code with dev.axllm:ax' (when) and the enumerated capability list (what). Not 5 because the merged single-sentence form leaves the trigger guidance less explicit and natural than a dedicated concrete trigger phrase; clearly above 3 since the 'when' is explicit rather than implied.

4 / 5

Trigger Term Quality

Includes natural, user-sayable terms like 'writing Java code', 'playbook', 'evolution', 'learning', and the package coordinate 'dev.axllm:ax'. Not 5 because phrases like 'context-engineering surface' are jargon users would not naturally say and synonyms (optimize, examples) are missing; above 3 since keyword coverage is genuinely good.

4 / 5

Distinctiveness Conflict Risk

Anchored to a specific generated package coordinate ('dev.axllm:ax') and a niche feature set (playbook evolution, run-end learning), giving it a clear niche with distinct triggers and minimal conflict risk with other 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

frontmatter_unknown_keys

Unknown frontmatter key(s) found; consider removing or moving to metadata

Warning

Total

15

/

16

Passed

Repository

ax-llm/ax

Path

packages/java/skills/ax-java-playbook/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.