ax-rust-signature

Use when writing Rust code with `axllm` for string signatures, field descriptors, JSON schema output, validation, and typed tool argument shapes.

Quality

75%

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

Quality

Content

65%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 well-organized, lean reference with concrete Rust patterns and useful guardrails. It falls short on workflow structure — no sequencing or validation checkpoints for moving from pattern selection to a verified running program — and the Typesafe/Jev subsystem detail is inlined rather than split into a reference file.

Suggestions

Add a short ordered workflow (pick pattern -> build signature -> render to_json_schema -> verify with a no-key scripted transport check -> only then call a real provider) so validation checkpoints are explicit rather than implied by the guardrails.

Move the Typesafe/Jev subsystem details (naming variants, trueThreshold policy, probability tolerances, balancer behavior) into a separate reference file (e.g. typesafe.md) and keep a 3-4 line summary with a clear link in SKILL.md.

Make at least the core pattern snippet fully copy-paste runnable (imports, client construction, main) so the primary example executes standalone, or explicitly label snippets as fragments to be completed from the examples/ programs.

Dimension	Reasoning	Score
Conciseness	The body is lean with no basic-concept explanations and concrete snippets throughout, but the Typesafe/Jev section triple-lists naming variants per identifier ('system_one / systemOne / SystemOne') and documents provider trivia that could be trimmed — anchor 4 (efficient, minor over-explanation) rather than 5.	4 / 5
Actionability	Concrete, syntactically specific Rust snippets cover the common cases (string signatures, class outputs, FieldType constraints, JSON schema, program reuse), but they are fragments — missing imports, client construction, and a runnable main — so they are not copy-paste standalone despite the pointer to 'examples/'. Anchor 4, not 5; real executable syntax keeps it above anchor 3's pseudocode level.	4 / 5
Workflow Clarity	Content is organized as a pattern reference with some decision guidance ('Use the string form when field names and types are enough') but there is no sequenced workflow and no validation checkpoints (e.g., running the no-key transport checks or verifying a generated schema before provider calls). Anchor 3 (sequence/checkpoints implicit), not 4 — no checkpoints to speak of; not 2 — structure and selection guidance are present.	3 / 5
Progressive Disclosure	Package references are clearly listed one level deep ('Package API docs: `API.md` and `axir-api.json`', 'Runnable examples: `examples/`'), but the dense ~18-line Typesafe/Jev subsystem section (cross-language naming variants, balancer behavior, probability tolerances) is inlined in SKILL.md where it belongs in a separate reference file, and no bundle files accompany the skill. Anchor 3 (content that should be separate is inline), not 4 — the inlined subsystem detail is more than a minor gap.	3 / 5
	Total	14 / 20 Passed

Description

75%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 solid, concise description with an explicit trigger clause, concrete capability enumeration, and a distinct Rust/axllm niche. Its main limitation is that the 'what' is fused into the 'when' clause and expressed as feature nouns rather than actions, leaving it just short of the top anchors.

Dimension	Reasoning	Score
Specificity	Lists five concrete capability areas ('string signatures, field descriptors, JSON schema output, validation, and typed tool argument shapes') but they are feature nouns rather than distinct actions, and capabilities covered by the body (class outputs, Typesafe scoring) are omitted — matching anchor 4 (several specific items, minor gaps in coverage) rather than 5's comprehensive action list.	4 / 5
Completeness	The explicit 'Use when writing Rust code with `axllm` for...' trigger answers 'when' concretely, and the 'what' is present via the enumerated purposes, but what and when are fused into a single clause rather than stated as separate clear statements — anchor 4, not 5; the explicit Use-when clause keeps it above the anchor-3 cap.	4 / 5
Trigger Term Quality	Good natural keywords a user would say ('Rust code', 'axllm', 'JSON schema', 'validation', 'typed tool argument shapes'), but common variations such as 'Ax', 'structured outputs', or 'type-safe outputs' are missing, fitting anchor 4 rather than 5's synonym-level coverage and clearly above anchor 3's partial coverage.	4 / 5
Distinctiveness Conflict Risk	The specific package + language pairing ('Rust code with `axllm`') creates a clear niche, but broad terms like 'validation' and 'JSON schema output' create minor overlap with general schema/validation skills — anchor 4 rather than 5, and well above anchor 3's generic overlap.	4 / 5
	Total	16 / 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-signature/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.