ax-java-refine

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

Quality

86%

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

80%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 lean, well-organized reference skill with a concrete core code pattern and useful guardrails. The main weaknesses are the absence of any sequenced workflow with validation checkpoints — notable for an iterative-refinement skill — and a core code example that is not executable as written.

Suggestions

Add a short numbered workflow, e.g.: 1) consult `examples/` for exact native syntax, 2) construct the engine and evaluator, 3) run `engine.optimize(request, evaluator)`, 4) verify behavior with the no-key transport before using real credentials.

Make the Core Pattern snippet complete and executable (imports plus construction of `reflectionClient`, `request`, and `evaluator`), or explicitly label it as a shape sketch and point to the specific example file that contains the full flow.

Turn the implicit no-key/real-network distinction into an explicit validation checkpoint: run no-key examples as a deterministic local check, and only proceed to `provider-api` examples once those pass.

Dimension	Reasoning	Score
Conciseness	Roughly 40 lean lines with no padding and no explanation of concepts Claude already knows (e.g., "This skill helps an agent write Java code with the generated Ax package `dev.axllm:ax`. Use the generated package API, examples, and manifests; do not import TypeScript-only APIs..."). Every section carries non-obvious, package-specific information.	5 / 5
Actionability	The Core Pattern is real Java code ("AxGEPA engine = new AxGEPA(reflectionClient, java.util.Map.of()); var result = engine.optimize(request, evaluator);") with a concrete API-surface listing, but the snippet depends on undefined inputs (reflectionClient, request, evaluator). Not 3 because it is concrete code rather than pseudocode and the guardrail "Start from package examples for exact native syntax before inventing a new call shape" explicitly routes to complete runnable examples; not 5 because the one inline example is not copy-paste executable.	4 / 5
Workflow Clarity	No numbered sequence exists; the implied process (consult examples, construct engine, run optimize, verify) is implicit, and the "deterministic local checks" mention via no-key examples is not framed as a validation checkpoint. For a skill whose purpose is iterative refinement with evaluator feedback, no validate-and-retry loop is described — matching the anchor 'sequence present but checkpoints missing or implicit' rather than the level-4 anchor with 'most checkpoints present'.	3 / 5
Progressive Disclosure	Under 50 lines with clear sections (When To Use, Package Facts, Core Pattern, Relevant API Surface, Guardrails) and no need for skill-bundle reference files; package artifacts (`API.md`, `axir-api.json`, `examples/`) are one-level pointers appropriately kept in the Package Facts section.	5 / 5
	Total	17 / 20 Passed

Description

87%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 description: it combines an explicit 'Use when' trigger with a concrete list of capabilities, all scoped to a specific language and package. Keyword coverage is good but could add a few more natural synonyms.

Dimension	Reasoning	Score
Specificity	Names several concrete capabilities ("reward-scored generation, iterative candidate improvement, evaluator feedback, and optimizer-backed refinement patterns") anchored to a specific package. Not 5 because coverage has minor gaps versus what the skill body actually supports (e.g., porting TypeScript refinement intent, consulting manifests).	4 / 5
Completeness	Explicitly answers both questions in one sentence: "Use when writing Java code with `dev.axllm:ax` for reward-scored generation, iterative candidate improvement, evaluator feedback, and optimizer-backed refinement patterns" — a concrete 'when' trigger clause plus a concrete 'what' capability list.	5 / 5
Trigger Term Quality	Includes natural triggers a user of this package would say: "Java code", "`dev.axllm:ax`", "evaluator", "optimizer", "refinement". Not 5 because common synonyms and variations (e.g., "improve output quality", "iterate on generations", "Ax") are missing; not 3 because coverage goes beyond a few generic keywords.	4 / 5
Distinctiveness Conflict Risk	Scoped to one language (Java) and one named package (`dev.axllm:ax`), giving it a clear niche with distinct triggers and minimal overlap risk with other skills.	5 / 5
	Total	18 / 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/java/.well-known/agent-skills/ax-java-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.