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

79%

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 ./website/static/cpp/.well-known/agent-skills/ax-cpp-playbook/SKILL.md

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 tight, well-structured reference skill: excellent token efficiency, clean sectioning, and concrete API pointers with real code shapes. Its main weakness is workflow clarity — the guardrails reference validation (no-key checks, verified rollback) but never assemble these into an ordered, checkpointed workflow the agent can follow.

Suggestions

Add a short ordered workflow, e.g.: 1. Pick the closest example from examples/; 2. Run it with the no-key transport to verify locally; 3. Adapt the code; 4. Re-run before touching provider credentials.

Bind the Core Pattern placeholders (define or comment what llm, examples, and metric_fn are, or point to the specific example file that defines them) so the snippet is copy-paste runnable.

Promote the validation guidance from Guardrails into an explicit checkpoint in the workflow: 'verify deterministic no-key run passes before evolving with a live provider'.

Dimension	Reasoning	Score
Conciseness	The ~45-line body is lean and efficient throughout: terse fact lines ('Language: C++.', 'Package: `axllm`.'), a minimal code snippet, and guardrails stated as one-line rules, with no explanation of concepts Claude already knows. Every token earns its place, matching the top anchor.	5 / 5
Actionability	The Core Pattern shows real call shapes (axllm::ax, axllm::playbook(program, llm), pb.evolve(...)) and the API Surface lists concrete symbols, but the snippet's llm, examples, and metric_fn are unbound placeholders rather than copy-paste executable code. This is mostly executable guidance with minor gaps (anchor 4), not anchor 3, because the syntax is concrete and the guardrail directs to runnable package examples.	4 / 5
Workflow Clarity	'When To Use' enumerates five capability bullets but provides no ordered sequence with checkpoints (e.g., pick an example, run the no-key transport for deterministic checks, then evolve against the real provider). Guardrails mention validation ('deterministic local checks', 'verification and exact rollback') but never sequence these steps, matching anchor 3 (steps listed, checkpoints missing or implicit) rather than 4.	3 / 5
Progressive Disclosure	The skill is under 50 lines, needs no external reference files, and is organized into clearly signaled sections; external package resources (API.md, axir-api.json, examples/) are consolidated under Package Facts as one-level-deep pointers. Per the simple-skill guideline, this matches the top anchor for well-organized content.	5 / 5
	Total	17 / 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.

A reasonably strong description with an explicit use-when trigger, concrete capability enumeration, and excellent distinctiveness, held back by heavy package-internal jargon ('context-engineering surface', 'run-end learning') that weakens natural trigger-term coverage and keeps the what-clause from being fully concrete.

Suggestions

Rewrite the capability list in user-facing verbs, e.g., 'Grow, evolve, and render agent playbooks with the axllm C++ package' so the what-clause is concrete rather than jargon-based.

Add natural trigger phrases users would actually say, such as 'optimize an agent', 'evolve a prompt program', or 'learn from run failures', to broaden keyword coverage beyond 'playbook' and 'axllm'.

Split the sentence into a what-clause and a when-clause ('... rendering a playbook into a program. Use when writing C++ with axllm or evolving agent playbooks.') to make both parts explicit.

Dimension	Reasoning	Score
Specificity	The description lists several concrete actions ('agent-bound verified evolution, run-end learning, online updates, and rendering a playbook into a program'), matching the anchor for several specific actions with minor gaps. It falls short of a 5 because 'context-engineering surface' is abstract jargon rather than a concrete capability, and above a 3 because more than 1-2 concrete actions are named.	4 / 5
Completeness	Both what and when are present, with an explicit 'Use when writing C++ code with `axllm`' trigger, satisfying the completeness floor. It is not a 5 because the what and when are fused into a single jargon-heavy sentence, so the capability description lacks the concrete, cleanly separated trigger phrasing of the top anchor.	4 / 5
Trigger Term Quality	It includes some relevant keywords ('C++ code', 'axllm', 'playbook', 'online updates') but phrases like 'run-end learning' and 'context-engineering surface' are package-internal jargon rather than natural user phrasings, and common variations users would actually say (e.g., 'optimize an agent', 'evolve a prompt program') are missing. Not a 4 because keyword coverage relies heavily on terms users outside the package would not naturally say.	3 / 5
Distinctiveness Conflict Risk	The description carves out a clear niche (C++ development with the generated `axllm` package for playbook workflows) with distinct triggers, so conflict risk with other skills is minimal.	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: website/static/cpp/.well-known/agent-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.