autonomous-agents
Autonomous agents are AI systems that can independently decompose goals, plan actions, execute tools, and self-correct without constant human guidance. The challenge isn't making them capable - it's making them reliable. Every extra decision multiplies failure probability.
30
24%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/antigravity-autonomous-agents/SKILL.mdQuality
Discovery
22%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This description reads more like an introductory paragraph from a blog post or essay about autonomous agents than a skill description. It defines what autonomous agents are and highlights a philosophical challenge (reliability vs. capability) but fails to specify what concrete actions the skill enables or when Claude should select it. It lacks actionable trigger guidance entirely.
Suggestions
Add explicit capability statements describing what the skill does, e.g., 'Guides design and implementation of autonomous agent architectures, including goal decomposition, tool orchestration, error handling, and retry logic.'
Add a 'Use when...' clause with natural trigger terms, e.g., 'Use when the user asks about building agents, agentic workflows, tool-use loops, agent reliability, or multi-step autonomous systems.'
Rewrite in third person describing skill actions rather than defining concepts — replace the essay-style prose with concrete, scannable capability descriptions.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description discusses autonomous agents conceptually but does not list any concrete actions the skill performs. Phrases like 'decompose goals, plan actions, execute tools, and self-correct' describe what autonomous agents are, not what this skill does. There are no actionable capabilities stated. | 1 / 3 |
Completeness | The description provides a conceptual overview of what autonomous agents are but never explicitly states what the skill does or when Claude should use it. There is no 'Use when...' clause or equivalent trigger guidance, and the 'what' is essentially a definition rather than a capability statement. | 1 / 3 |
Trigger Term Quality | It includes some relevant keywords like 'autonomous agents', 'AI systems', 'plan actions', 'execute tools', and 'self-correct' that a user interested in agent design might use. However, it misses common variations and practical trigger terms like 'build an agent', 'agent framework', 'tool use', 'agentic workflow', etc. | 2 / 3 |
Distinctiveness Conflict Risk | The focus on 'autonomous agents' and reliability gives it some distinctiveness, but the broad language about AI systems, goals, planning, and tools could overlap with many other AI/coding/architecture skills. It's not specific enough to carve out a clear niche. | 2 / 3 |
Total | 6 / 12 Passed |
Implementation
27%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is comprehensive in coverage but severely over-engineered for a SKILL.md file. It reads more like a tutorial or reference book chapter than a concise skill instruction, with extensive explanations of concepts Claude already understands, redundant sections, and metadata that belongs in frontmatter. The code examples provide some actionability but are often incomplete with undefined dependencies, and the monolithic structure with no supporting bundle files makes it difficult to navigate.
Suggestions
Reduce content by 60-70%: remove concept explanations (what ReAct is, why errors compound), move metadata sections (Capabilities, Scope, When to Use, Limitations) to YAML frontmatter, and eliminate redundant coverage of cost control and context management.
Split into bundle files: move Sharp Edges to a SHARP_EDGES.md, individual patterns to separate files (REACT.md, PLAN_EXECUTE.md, REFLECTION.md), and validation checks to VALIDATION.md, with the main SKILL.md serving as a concise overview with links.
Make code examples fully executable: define all imports, provide complete class definitions, and specify concrete values for placeholder variables like 'tools', 'llm', and 'planner_llm'.
Add a clear decision workflow at the top: a simple flowchart or numbered sequence for 'which pattern to use when' with explicit validation checkpoints before deploying to production.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at 500+ lines. Explains concepts Claude already knows (what autonomous agents are, what ReAct is, how error probability compounds). Includes extensive 'Sharp Edges' sections that read like blog posts rather than actionable instructions. The 'Capabilities', 'Scope', 'When to Use', and 'Limitations' sections are metadata that belong in frontmatter, not body content. Massive amounts of redundancy (cost control appears in multiple sections). | 1 / 3 |
Actionability | Contains concrete code examples (LangGraph ReAct, Plan-Execute, GuardedAgent class, etc.) that are mostly executable, but many are pseudocode-like with undefined imports, missing class definitions (e.g., ReflectionState, AgentState), and placeholder functions (summarize, verify_restaurant_exists). The code mixes frameworks inconsistently and some examples reference undefined variables like 'tools', 'llm', 'planner_llm'. | 2 / 3 |
Workflow Clarity | The ReAct and Plan-Execute patterns describe clear sequences, and the guardrails section includes validation checkpoints. However, there's no overarching workflow for 'how to build an agent from scratch' with explicit validation steps. The Sharp Edges section lists problems and fixes but doesn't provide a clear decision tree or sequenced workflow for choosing and implementing patterns. Missing explicit feedback loops in several multi-step processes. | 2 / 3 |
Progressive Disclosure | Monolithic wall of text with no bundle files to reference. Everything is inlined in a single massive document — the patterns, sharp edges, validation checks, collaboration notes, and metadata. References to other skills (agent-memory-systems, multi-agent-orchestration) are mentioned but not linked to actual files. Content that should be in separate files (e.g., detailed sharp edges, validation rules, individual pattern guides) is all crammed into one document. | 1 / 3 |
Total | 6 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (1085 lines); consider splitting into references/ and linking | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
- Repository
- boisenoise/skills-collections
- Commit
cfced3a
- Reviewed
Table of Contents
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.