ax-java-flow

Use when writing Java code with `dev.axllm:ax` for flows, nodes, program graphs, nested programs, dynamic options, caching, and optimizer components.

Quality

79%

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/java/.well-known/agent-skills/ax-java-flow/SKILL.md

Quality

Content

71%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 strong pattern-catalog body with executable Java examples and a sensible progression, undermined by a long inlined advanced section and pointers to example/reference files that are not present in the skill bundle. Splitting the session-work material into a reference file and shipping (or removing) the referenced artifacts would lift both actionability and organization.

Suggestions

Move the "Astra Session Work" section into a separate reference file (e.g., references/astra-sessions.md) and keep a one-line summary with a clearly signaled link in SKILL.md.

Either include the referenced artifacts (`API.md`, `axir-api.json`, `axir-capabilities.json`, example programs) in the bundle or drop/redirect the pointers, since "start from the complete programs under examples/" currently directs the agent to files that do not exist.

Add at least one small executable snippet to the Astra section (e.g., selecting `gpt-6-astra` via the OpenAI factory) so its rules have a concrete anchor.

Dimension	Reasoning	Score
Conciseness	Nearly every sentence carries package-specific detail with no generic-concept padding, and the code examples are lean. However, the ~26 lines of dense prose in "Astra Session Work" (with repeated "as in TypeScript" qualifiers) form a wall of text that could be tightened or trimmed.	4 / 5
Actionability	The flow patterns are copy-paste-ready executable Java (core, branching, fan-out/join, refinement, forward, caching). It falls short of anchor 5 because "start from the complete programs under `examples/`" and `src/examples/java/...` point at paths absent from the bundle, and the long Astra section is rules-prose with no code.	4 / 5
Workflow Clarity	A clear basic-to-advanced progression (Package Facts, Core Pattern, More Patterns, session work) exists, and the Guardrails section supplies checkpoints ("start from package examples for exact native syntax before inventing a new call shape"). Not a destructive or batch workflow, so no validation cap applies; it is not anchor 5 because no explicit validate-verify loop appears anywhere.	4 / 5
Progressive Disclosure	Section headers are clear, but the dense Astra session material is inlined where a separate reference file would serve better, and the referenced files (`API.md`, `axir-api.json`, `axir-capabilities.json`, `examples/`) have no counterpart in the bundle (no references/, scripts/, or assets/ directories exist), so navigation targets cannot be verified.	3 / 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 well-formed description with an explicit trigger clause, a named package, and a concrete subsystem list. Its main weakness is that the what and when largely overlap and several enumerated terms favor jargon over the natural phrases a user would say.

Suggestions

State the what and when as distinct clauses, e.g., "Compose generators, agents, and nested flows into Java workflow graphs with `dev.axllm:ax`. Use when writing Java code with dev.axllm:ax or when the user mentions AxFlow, workflow graphs, or flow nodes."

Swap one or two jargon terms (e.g., "program graphs", "dynamic options") for natural synonyms users would say, such as "workflow graphs" or "agents".

Dimension	Reasoning	Score
Specificity	The description lists several concrete subsystems ("flows, nodes, program graphs, nested programs, dynamic options, caching, and optimizer components") tied to a named package. It stops short of anchor 5 because it enumerates feature nouns rather than concrete actions (e.g., "compose generators, agents, and nested flows into a workflow graph" appears only in the body).	4 / 5
Completeness	An explicit "Use when writing Java code with `dev.axllm:ax`" trigger satisfies the when; the what (writing code with this package for the listed subsystems) is present but largely collapses into the same clause. It fits anchor 4 (both present, what could be more distinct) rather than anchor 5's clearly separate what-and-when with concrete trigger phrases.	4 / 5
Trigger Term Quality	Natural phrases like "writing Java code", "flows", "nodes", and "caching" are present alongside the package identifier `dev.axllm:ax`. Not anchor 5: terms like "program graphs", "dynamic options", and "optimizer components" are jargon-heavy, and common variations such as "workflow", "AxFlow", or "agents" are missing.	4 / 5
Distinctiveness Conflict Risk	Naming the exact package `dev.axllm:ax`, the Java language, and package-specific subsystem terms creates a clear niche with minimal overlap risk against any generic coding skill.	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/java/.well-known/agent-skills/ax-java-flow/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.