ax-python-playbook

Use when writing Python 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

82%

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

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 lean, well-organized body with exact API call shapes and actionable guardrails, appropriately deferring detail to package docs. The main gap is workflow clarity: the evolve/optimize flow is presented as a code sketch with no validation checkpoints or rollback steps despite the skill promising verified evolution with exact rollback.

Suggestions

Add a short explicit sequence for the core workflow (create program -> attach playbook -> evolve -> verify -> persist/render) with a validation step after evolve, e.g. 'check the evolution report and roll back via the documented revert path before persisting the playbook'.

Make the Core Pattern closer to runnable by defining or sourcing the placeholders, e.g. noting where llm, examples, and metric_fn come from (a no-key example in examples/) so the snippet can be executed directly.

Include one concrete no-key example invocation (per the 'Scripted no-key transport support' fact) so agents can verify their call shape deterministically before touching real providers.

Dimension	Reasoning	Score
Conciseness	Lean throughout: Package Facts is a flat bullet list, the Core Pattern code block is 5 lines, and guardrails are one-line directives ('Start from package examples for exact native syntax'). No explanations of concepts Claude already knows and no padding — every token earns its place.	5 / 5
Actionability	The Core Pattern gives exact call shapes — ax("question:string -> answer:string"), playbook(program, {"studentAI": llm}), pb.evolve(examples, metric_fn) — plus concrete guardrails like 'Use `no-key` examples for deterministic local checks'. Not 5 because llm, examples, and metric_fn are undefined placeholders, so the code is not copy-paste runnable.	4 / 5
Workflow Clarity	The Core Pattern implies a sequence (create program -> build playbook -> evolve) and 'When To Use' enumerates tasks, but there is no explicit step sequence and no validation checkpoints — e.g., nothing on verifying evolution results or performing the 'exact rollback' the description promises. Fits anchor 3 (sequence present but checkpoints missing or implicit); not 4 because the validation gap is material rather than minor.	3 / 5
Progressive Disclosure	Under 50 lines with well-organized sections (When To Use, Package Facts, Core Pattern, Relevant API Surface, Guardrails); bulk detail is correctly deferred to package docs ('API.md', 'examples/') rather than inlined, and there are no nested references. Meets the simple-skill exception for a clean overview.	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: explicit and specific trigger guidance tied to a named package, with several concrete capabilities enumerated. The main weakness is that capabilities are woven into the 'Use when' clause as jargon-heavy trigger objects rather than stated as declarative 'what it does' statements.

Dimension	Reasoning	Score
Specificity	Lists several concrete capabilities — 'playbook() context-engineering surface', 'agent-bound verified evolution', 'run-end learning', 'online updates', 'rendering a playbook into a program' — anchored to the named package 'axllm'. Not 5 because the actions are framed as trigger objects rather than direct capability statements and 'context-engineering surface' is abstract jargon; not 3 because coverage clearly exceeds 1-2 actions.	4 / 5
Completeness	'Use when writing Python code with `axllm`' is an explicit and specific trigger clause, and the what is present via the enumerated capabilities. Not 5 because the what is embedded inside the when-clause rather than stated as standalone declarative capability statements; not 3 because both what and when are explicitly present.	4 / 5
Trigger Term Quality	Includes natural terms a user of this package would say — 'Python', 'axllm', 'playbook()', 'evolution', 'online updates'. Not 5 because phrases like 'run-end learning' and 'agent-bound verified evolution' are internal jargon rather than natural user synonyms; well above anchor 3's 'some relevant keywords but missing common variations'.	4 / 5
Distinctiveness Conflict Risk	Names a specific package ('axllm') and specific methods ('playbook()'), forming a clear niche with distinct triggers and minimal conflict risk with any other skill.	5 / 5
	Total	17 / 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/python/.well-known/agent-skills/ax-python-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.