ax-cpp-playbook

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

Quality

75%

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

Fix and improve this skill with Tessl

tessl review fix ./packages/cpp/skills/ax-cpp-playbook/SKILL.md

Quality

Content

68%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 an exemplarily lean, well-structured overview with clearly signaled references, but its guidance stops short of being executable: the core code example has undefined operands and the multi-step evolve/refine lifecycle lacks explicit sequencing and validation checkpoints. It works as a pointer document to the package's own examples rather than as standalone instruction.

Suggestions

Make the Core Pattern copy-paste ready by defining the missing operands (e.g., how to construct the `llm` service, load `examples`, and declare `metric_fn`), or explicitly label it as a shape sketch and show where the runnable version lives in `examples/`.

Add an explicit validation checkpoint to the evolve workflow (e.g., verify mined weaknesses pass before committing, and how to trigger the 'exact rollback' mentioned in When To Use) so the risky evolve step has a feedback loop.

Move the 'Relevant API Surface' symbol list into the referenced API docs (or summarize only the 2-3 entry points) and ensure the referenced files (`API.md`, `axir-api.json`, `axir-capabilities.json`, `examples/`) actually exist in the skill bundle.

Dimension	Reasoning	Score
Conciseness	The ~40-line body is lean and factual: Package Facts, a 3-line Core Pattern, an API surface list, and guardrails, with no padding and no explanation of concepts Claude already knows. Every token earns its place, matching anchor 5.	5 / 5
Actionability	The Core Pattern shows real call shapes ('auto program = axllm::ax("question:string -> answer:string")', 'axllm::playbook(program, *llm)', 'pb.evolve(examples, metric_fn)') but llm, examples, and metric_fn are undefined, so the snippet cannot run without key details; the skill defers exact syntax to the external examples/ directory. Matches anchor 3 ('missing key details'); not 4 because the gaps are more than minor.	3 / 5
Workflow Clarity	'When To Use' implies a lifecycle (grow -> attach/evolve -> refine -> render/inject) and the Core Pattern gives a rough three-step sequence, but steps are not explicitly ordered and validation is only implicit ('mine grounded weaknesses with verification and exact rollback'). Matches anchor 3 (sequence present, checkpoints missing or implicit); not 4 because no explicit validation checkpoint appears in the body.	3 / 5
Progressive Disclosure	A well-organized under-50-line overview with clearly signaled one-level-deep references ('Package API docs: `API.md` and `axir-api.json`', 'Runnable examples: `examples/`', 'Capability manifest: `axir-capabilities.json`'). Not 5 because none of the referenced files are present in the bundle, and the 'Relevant API Surface' section inlines symbol lists that belong in the referenced API docs. Matches anchor 4.	4 / 5
	Total	15 / 20 Passed

Description

71%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 is distinct and reasonably complete with an explicit trigger clause, but its capability list is written in dense internal jargon that weakens natural trigger-term matching and makes the 'what' less explicit than it could be. It is a solid but not exemplary description.

Suggestions

Rewrite the capability list with plain, verb-led actions (e.g., 'Build, evolve, and refine a context playbook...') so the 'what' reads explicitly instead of as jargon noun phrases.

Add natural user-facing synonyms alongside the internal terminology (e.g., 'playbook', 'evolve', 'optimize', 'C++', 'axllm') and drop or gloss terms like 'context-engineering surface' and 'run-end learning' that users would not naturally say.

Dimension	Reasoning	Score
Specificity	Lists several specific capability areas ('playbook() context-engineering surface, agent-bound verified evolution, run-end learning, online updates, and rendering a playbook into a program') within the named C++/axllm domain, though they are jargon-heavy noun phrases rather than plain concrete actions. Not 5 because the items are not comprehensive plain-action coverage; not 3 because more than 1-2 specific items are named.	4 / 5
Completeness	An explicit and concrete 'when' is present ('Use when writing C++ code with `axllm` for...') and the 'what' is conveyed through the enumerated capabilities, but the 'what' is embedded as a jargon capability list rather than explicitly stated as actions the skill performs. Matches anchor 4; not 5 because the 'what' is less explicit than a verb-led capability statement.	4 / 5
Trigger Term Quality	Contains some relevant keywords users would say ('C++ code', 'axllm', 'playbook', 'online updates') but is dominated by internal jargon ('context-engineering surface', 'agent-bound verified evolution', 'run-end learning') rather than natural user phrasing, and common synonyms or variations are missing. Matches anchor 3; not 4 because keyword coverage is uneven and jargon-dominant.	3 / 5
Distinctiveness Conflict Risk	The description is pinned to a specific package ('axllm'), language (C++), and feature surface (playbook()), giving it a clear niche with distinct triggers and minimal conflict risk with other skills. Matches anchor 5.	5 / 5
	Total	16 / 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
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/cpp/skills/ax-cpp-playbook/SKILL.md
Commit: 3f630a0

Reviewed: 3 days 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.