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

70%

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 ./packages/rust/skills/ax-rust-llm/SKILL.md

Quality

Content

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

The body is a lean, well-structured quick reference with clearly signaled package artifacts and sensible guardrails, and it wastes almost no tokens on background explanation. Its weaknesses are an incomplete core code example, the absence of an ordered usage workflow with any validation step, and an inlined API list that duplicates the referenced API.md.

Suggestions

Replace the two-line Core Pattern with one complete, runnable example (e.g. a main() that constructs options, calls ai(), and runs a minimal ax() generator) so the starting pattern is copy-paste ready.

Add a short ordered workflow — pick example in `examples/` matching the task, adapt signature, run with `no-key` transport for local checks, then switch to a real provider — with an explicit verification step before touching credentials.

Trim the 'Relevant API Surface' list to the handful of entrypoints per area and point to `API.md` for the full surface, converting package file mentions into explicit 'See X' pointers.

Dimension	Reasoning	Score
Conciseness	The body is terse and free of concept explanations Claude already knows ('Package Facts' is a compact bullet list), but the 'Relevant API Surface' section inlines ~50 API names that largely duplicate the referenced `API.md`. Not 5 because that list could be trimmed or pushed to the reference.	4 / 5
Actionability	The Core Pattern snippet ('let llm = ai("openai", options)?;') is a fragment rather than executable Rust — `options` is undefined and `let`/`?` require a function context — and no complete runnable example is inlined; guidance defers to `examples/` instead. Not 4 because the code is not copy-paste ready and key details are missing; not 2 because real API names and a real call shape are provided.	3 / 5
Workflow Clarity	'When To Use' lists tasks and 'Guardrails' gives conditional rules ('Use `provider-api` examples only when the user explicitly has provider credentials'), but there is no ordered sequence or validation checkpoint for going from task to working program. Not 4 because any sequence is only implicit; not 2 because tasks and decision rules are present and coherent.	3 / 5
Progressive Disclosure	Sections are well organized and package references ('API.md and axir-api.json', 'examples/') are clearly signaled one level deep in 'Package Facts', but the long API surface list is inlined rather than split out and references are bare backtick names rather than navigable pointers. Not 5 because of these organization gaps.	4 / 5
	Total	14 / 20 Passed

Description

66%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 highly distinct niche (Rust + axllm), but its capability statement is a list of resources rather than concrete actions, and it omits the functional domain terms (LLM, agents, generators) a user might naturally say. It sits solidly above the midpoint but below the exemplary anchor.

Suggestions

Rewrite the 'what' clause as concrete actions, e.g. 'Build LLM programs in Rust with the generated axllm package: create clients with factory functions, run signature-based generators, agents, flows, and optimizers.'

Add natural functional keywords users would say beyond the package name — 'LLM', 'AI', 'agents', 'prompts/signatures', 'provider routing' — so the skill triggers even when the user describes the task rather than the package.

Keep the 'Use when writing Rust code with `axllm`' trigger clause, which is the strongest part of the description, and mention the package docs/examples/API reference as where details live rather than as the capability list.

Dimension	Reasoning	Score
Specificity	The description names the domain precisely ('writing Rust code with `axllm`') but lists resources ('factory functions, package docs, examples, and API reference') rather than concrete actions — only one clear action (writing Rust code) is stated. Not 4 because it does not list several specific actions; not 2 because the domain is exact rather than generic.	3 / 5
Completeness	Both what ('using the generated Ax package, factory functions, package docs, examples, and API reference') and when ('Use when writing Rust code with `axllm`') are explicitly stated. Not 5 because the 'what' clause is a muddled resource list rather than a crisp capability statement; not 3 because neither element is missing.	4 / 5
Trigger Term Quality	'Rust' and 'axllm' are natural trigger terms, but the functional vocabulary a user would actually say (LLM, AI, agents, signatures, optimizers) is absent, so common variations and synonyms are missing. Not 4 because keyword coverage beyond the package name is thin.	3 / 5
Distinctiveness Conflict Risk	'Rust' plus the exact package name '`axllm`' pins a clear niche with distinct triggers and minimal conflict risk against unrelated skills.	5 / 5
	Total	15 / 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: packages/rust/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.