ax-rust-agent-context

Use when writing Rust code with `axllm` for deciding between context maps, trajectory context policy, offline optimization (ACE/GEPA), and memory recall for long-context agents.

Quality

78%

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/rust/.well-known/agent-skills/ax-rust-agent-context/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.

An efficient, well-organized overview that respects the token budget and clearly scopes the skill to the generated Rust package. Its weaknesses are incomplete executable guidance (a code shape with undefined variables, name-only API listings) and the absence of a decision procedure for the skill's core task of choosing among the four features.

Suggestions

Make the Core Pattern snippet runnable or explicitly flag placeholders, e.g. show how `llm` and `inputs` are constructed (or annotate them as 'see examples/ for construction'), so the pattern is executable rather than a shape illustration.

Add brief selection criteria or a decision rule under 'When To Use' for choosing between contextMap, contextPolicy, optimization, and recall (e.g., one line per feature stating when it is the right choice), since routing is the skill's stated purpose.

Clarify where `API.md`, `axir-api.json`, and `examples/` live relative to the skill (package root vs. skill bundle), or include the most decision-relevant excerpts as one-level-deep reference files in the skill.

Dimension	Reasoning	Score
Conciseness	The body is lean and efficient: terse fact bullets ('Language: Rust.', 'Real network support: yes.'), a minimal code snippet, and no explanations of concepts Claude already knows. Every section earns its place, matching the top anchor for token efficiency.	5 / 5
Actionability	The 'Core Pattern' snippet references undefined variables (`llm`, `inputs`), making it a call-shape illustration rather than executable code, and the 'Relevant API Surface' section lists bare names without signatures or usage. This matches the anchor for some concrete guidance that is incomplete with missing key details, rather than the mostly-executable anchor above.	3 / 5
Workflow Clarity	'When To Use' names the routing task ('Choose between contextMap, contextPolicy, optimization, and recall') but provides no decision sequence or criteria for how to choose, leaving the core workflow implicit. No validation checkpoints appear, though none are strictly required since the skill involves no destructive or batch operations, so this sits at the anchor for steps present but checkpoints/sequence missing rather than lower.	3 / 5
Progressive Disclosure	The body is a well-sectioned ~40-line overview with clear headers, fitting the good-structure anchor. It falls short of 5 because the referenced paths (`API.md`, `axir-api.json`, `examples/`) point into the generated package rather than being present as skill-bundle reference files, so navigation to details relies on files not shipped with the skill.	4 / 5
	Total	15 / 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, concise description with an explicit 'Use when' trigger, third-person framing, and a well-defined niche around the axllm Rust package's context-selection features. The main weakness is that the 'what' (what the skill actually does when invoked) is weakly stated and only implied through the when clause.

Dimension	Reasoning	Score
Specificity	The description lists several concrete capability areas ('context maps, trajectory context policy, offline optimization (ACE/GEPA), and memory recall for long-context agents'), matching the anchor for several specific actions with minor gaps. It stops short of a 5 because the actual action the skill performs (guiding selection/routing among these features) is only implied by 'deciding between' rather than stated as specific actions.	4 / 5
Completeness	The 'when' is explicitly answered by 'Use when writing Rust code with `axllm` for deciding between...', and the 'what' (choosing among four named features) is present but embedded in the when clause. This matches the anchor where both what and when exist but one could be more explicit; a 5 would require a clearly separate, concrete statement of what the skill does.	4 / 5
Trigger Term Quality	Terms like 'Rust', 'axllm', 'offline optimization (ACE/GEPA)', 'memory recall', and 'long-context agents' cover the natural vocabulary a user of this package would say, which fits good keyword coverage with a few natural terms missing. It is not a 5 because common variations and synonyms (e.g., 'context window', 'contextMap', plain 'context policy') are absent, and some phrasing leans technical-jargon.	4 / 5
Distinctiveness Conflict Risk	The trigger set is highly niche ('axllm', 'trajectory context policy', 'ACE/GEPA', 'long-context agents'), giving it a clear, distinct domain with minimal conflict risk against generic Rust or context-management skills. It clearly matches the top anchor for a distinct niche with distinct triggers.	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/rust/.well-known/agent-skills/ax-rust-agent-context/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.