ax-rust-llm

Use when writing Rust code with `axllm` for using the generated Ax package, factory functions, package docs, examples, and API reference.

Quality

63%

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-llm/SKILL.md

Quality

Content

57%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 genuinely lean, well-sectioned quick reference that correctly orients the agent to the generated package, but its single code pattern is not executable Rust, its API surface is a symbol dump without call shapes, and every detailed reference it cites is missing from the bundle. It works as a pointer document whose targets are absent, which caps actionability and navigation.

Suggestions

Make the Core Pattern a complete, runnable snippet inside a `fn main()` with a concrete `options` value (or explicitly label it as a shape sketch), and show one full example of constructing a client and making a call.

Ship the referenced bundle files (`API.md`, `axir-api.json`, `axir-capabilities.json`, `examples/`) or remove the dangling references — currently every deep-detail pointer resolves to nothing, and the inlined symbol list could then collapse to a link.

Trim the ~50-symbol flat dump to the handful of entry points an agent needs first (`ai`, `ax`, `flow`, `optimize`), moving the full inventory to `API.md`, and give the "language-specific AI skill" reference an explicit path or name.

Dimension	Reasoning	Score
Conciseness	The body is lean with no explanations of concepts Claude already knows, and sections like "Package Facts" are pure signal. It falls short of 5 because the opening sentence duplicates the frontmatter description and the ~50-symbol flat dump in "Relevant API Surface" is bulky token spend that the skill's own Package Facts say lives in `API.md`/`axir-api.json`.	4 / 5
Actionability	The Core Pattern (`let llm = ai("openai", options)?;`) is not executable as written — a top-level `let` with an undefined `options` — and "Relevant API Surface" lists symbol names without signatures or call shapes, while the referenced `examples/` directory is absent from the bundle. This matches 'some concrete guidance but incomplete; pseudocode instead of executable code', not 4, which requires mostly executable, copy-paste-ready guidance.	3 / 5
Workflow Clarity	"When To Use" and "Guardrails" provide rough decision guidance (start from examples; use no-key vs provider-api examples depending on credentials), but nothing is sequenced into a workflow — there is no ordered path from task to working code and no checkpoints. It is a well-organized reference catalog rather than an incoherent one, so it sits at 'steps/structure present but checkpoints missing' rather than 2.	3 / 5
Progressive Disclosure	Sections are well-organized, but the body names bundle files (`API.md`, `axir-api.json`, `axir-capabilities.json`, `examples/`) that do not exist in the skill directory — dangling references — and it inlines a large API-surface list that, per its own Package Facts, belongs in those separate files. It also points vaguely to "the language-specific AI skill" without a path. This fits 'references present but not clearly signaled; content that should be separate is inline' better than the good-structure anchor.	3 / 5
	Total	13 / 20 Passed

Description

53%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 has an explicit 'Use when' trigger and a clearly named, distinctive niche (Rust + axllm), but its 'what' is buried in an ungrammatical resource list instead of concrete actions, and it misses natural trigger variations. It is serviceable but mid-range across all dimensions.

Suggestions

Rewrite as action-first, third-person statements before the trigger, e.g. "Write Rust code against the generated `axllm` package: call the `ai`/`ax`/`flow` factory functions, follow runnable examples, and consult the API reference. Use when writing Rust with axllm or the Ax LLM package."

Add natural trigger synonyms users would actually say — "Ax", "AxLLM", "ax crate", "LLM providers in Rust" — to improve keyword coverage beyond the current jargon-heavy phrasing.

Move the resource enumeration ("factory functions, package docs, examples, and API reference") into a capability statement so the 'what' reads as actions rather than a list of artifacts.

Dimension	Reasoning	Score
Specificity	The description names the domain ("Rust code with `axllm`", "the generated Ax package") and one action ("writing Rust code"), but "factory functions, package docs, examples, and API reference" are resources referenced rather than actions performed. It matches 'names domain and 1-2 concrete actions, but not comprehensive' — not 4, since it lacks a list of several specific actions, and not 2, since it goes beyond a bare domain label.	3 / 5
Completeness	The when is explicit ("Use when writing Rust code with `axllm`"), but the what is only weakly implied by the garbled clause "for using the generated Ax package, factory functions, package docs, examples, and API reference" — it states resources to consult, not what the skill does. This fits 'clear what is missing or only weakly implied'; it is not 4 because the what-portion is grammatically incoherent and action-free.	3 / 5
Trigger Term Quality	Relevant keywords exist ("Rust", "axllm", "package docs", "examples", "API reference"), but common variations are missing ("Ax", "AxLLM", "crate", "LLM providers") and the phrasing leans on jargon ("the generated Ax package"). It sits at 'some relevant keywords but missing common variations or synonyms' rather than the good-coverage anchor.	3 / 5
Distinctiveness Conflict Risk	"Rust" plus the package name "`axllm`" forms a clear niche unlikely to trigger unrelated skills, matching 'mostly distinct; minor overlap risk with closely related skills'. Not 5: the shared "Ax package" terminology implies sibling skills for other languages (the body itself warns about TypeScript-only APIs), leaving minor conflict risk with that closely related skill.	4 / 5
	Total	13 / 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-llm/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.