ax-cpp-refine

Use when writing C++ code with `axllm` for reward-scored generation, iterative candidate improvement, evaluator feedback, and optimizer-backed refinement patterns.

Quality

84%

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

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

An exceptionally lean, well-organized overview with clean one-level-deep disclosure to package artifacts and unambiguous single-purpose guidance. The notable gap is actionability: the only code block is a placeholder template and the API surface is a symbol inventory, so an agent cannot execute anything without leaving the skill for the package examples.

Suggestions

Add one complete, runnable example (e.g. a no-key deterministic refine run with the reflection client, request, and evaluator constructed inline) so the Core Pattern becomes copy-paste executable rather than a placeholder template.

Annotate 1-2 of the listed API symbols with minimal usage or argument shapes (e.g. what `axllm::optimize` takes and returns) so 'Relevant API Surface' guides calls, not just name lookups.

Make explicit where the referenced artifacts live (e.g. 'inside the generated `axllm` package directory') so paths like `API.md` and `examples/` are unambiguous to an agent encountering the skill standalone.

Dimension	Reasoning	Score
Conciseness	The ~40-line body is lean and list-driven with no padding and no explanation of concepts Claude already knows; every section (Package Facts, Core Pattern, API Surface, Guardrails) earns its tokens, matching the 5 anchor.	5 / 5
Actionability	The Core Pattern is a call-shape template with undefined placeholders ('axllm::AxGEPA engine(reflection_client, options)' with no construction of the client, options, request, or evaluator) and 'Relevant API Surface' lists bare symbols with no usage — concrete guidance exists, but it is pseudocode-level with missing key details rather than executable code.	3 / 5
Workflow Clarity	This is a single-purpose, under-50-line skill with no multi-step process to sequence, so the simple-skill exception applies: the single action (consult package facts and examples, apply the core pattern, follow guardrails) is unambiguous, and no destructive or batch operation exists that would impose a validation cap.	5 / 5
Progressive Disclosure	No bundle files are provided or needed; the body is a well-organized overview that delegates deep material one level deep to clearly labeled package artifacts ('Package API docs: `API.md`', 'Capability manifest: `axir-capabilities.json`', 'Runnable examples: `examples/`'), satisfying the under-50-lines exception for a 5.	5 / 5
	Total	18 / 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, lean description with an explicit 'Use when' trigger, several named capability areas, and a clearly distinct niche. Its main weakness is that the 'what' is expressed only as purposes/patterns rather than stating what the skill concretely offers, and it lacks natural trigger synonyms.

Suggestions

State the 'what' explicitly alongside the trigger, e.g. 'Documents the axllm optimizer API surface (AxGEPA, AxBootstrapFewShot, optimize) and refinement patterns. Use when...' so the skill's deliverables are named, not just its purposes.

Add natural trigger synonyms such as 'cpp', 'improve generated candidates', or 'evaluator feedback loops' to broaden keyword coverage for users who phrase the need differently.

Dimension	Reasoning	Score
Specificity	Enumerates several concrete capability areas ('reward-scored generation', 'iterative candidate improvement', 'evaluator feedback', 'optimizer-backed refinement patterns') rather than vague filler, but these are abstract pattern names rather than concrete operations, so it falls short of the comprehensive 5 anchor.	4 / 5
Completeness	Both elements are present — 'Use when writing C++ code with `axllm`' states the when explicitly, and the purpose list conveys the what — but what the skill actually provides (API surface, examples, guidance) is never stated directly, so it does not fully match the explicit two-part 5 anchor.	4 / 5
Trigger Term Quality	'C++ code', 'axllm', 'evaluator feedback', 'optimizer', and 'refinement' are terms a user of this package would naturally say, giving good keyword coverage; common variations and synonyms (e.g. 'cpp', 'improve', 'tune') are missing, keeping it below the 5 anchor.	4 / 5
Distinctiveness Conflict Risk	'C++ code with `axllm`' combined with refinement-specific vocabulary (optimizer, evaluator, reward-scored generation) carves a clear niche with minimal overlap risk against any other skill, matching the 5 anchor.	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/cpp/.well-known/agent-skills/ax-cpp-refine/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.