agent-teams-simplify-and-harden

Implementation + audit loop using parallel agent teams with structured simplify, harden, and document passes. Spawns implementation agents to do the work, then audit agents to find complexity, security gaps, and spec deviations, then loops until code compiles cleanly, all tests pass, and auditors find zero issues or the loop cap is reached. Use when: implementing features from a spec or plan, hardening existing code, fixing a batch of issues, or any multi-file task that benefits from a build-verify-fix cycle.

Quality

70%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Advisory

Suggest reviewing before use

Fix and improve this skill with Tessl

tessl review fix ./skills/agent-teams-simplify-and-harden/SKILL.md

Quality

Content

47%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This skill provides a comprehensive and well-structured workflow for team-based implementation and auditing loops, with excellent workflow clarity including validation checkpoints, exit conditions, and drift checks. However, it is significantly over-verbose — repeating pipeline position three times, explaining concepts Claude already knows, and including sections (installation, tips, sizing guide) that inflate token cost without proportional value. The actionability is solid but hampered by deferred auditor prompts to a missing bundle file and pseudocode-style tool invocations.

Suggestions

Cut the content by 40-50%: remove the installation section, collapse the three pipeline position explanations into one, remove the ASCII diagram (the step-by-step procedure already conveys the flow), and trim the tips section to only non-obvious guidance.

Include the auditor prompt templates inline or provide the `references/auditor-prompts.md` bundle file — currently the most actionable part of the audit phase is deferred to a missing file.

Use exact tool invocation syntax rather than pseudocode-style blocks for TeamCreate, TaskCreate, and spawn commands so agents can copy-paste directly.

Move the Agent Sizing Guide, Interoperability section, and Example walkthrough into a separate reference file to keep the main SKILL.md focused on the procedure.

Dimension	Reasoning	Score
Conciseness	The skill is extremely verbose at ~400+ lines. It includes extensive explanations of concepts Claude already understands (what agents are, how parallelism works, what auditing means), redundant sections (pipeline position explained three times, exit conditions repeated), installation instructions, and ASCII diagrams that restate what the text already says. The agent sizing guide, tips section, and interoperability section add significant bulk that could be drastically compressed.	1 / 3
Actionability	The skill provides concrete tool invocation patterns (TeamCreate, TaskCreate, spawn prompts) and a clear step-by-step procedure with specific commands like `git diff --name-only`. However, the tool calls use pseudocode-style syntax rather than exact executable formats, auditor prompt templates are deferred to a referenced file (`references/auditor-prompts.md`) that isn't provided in the bundle, and the compile/test commands are placeholder suggestions rather than concrete examples.	2 / 3
Workflow Clarity	The multi-step workflow is exceptionally well-sequenced with numbered phases (0-9), explicit validation checkpoints (compile + tests between phases), clear exit conditions with three defined paths, a drift check protocol between rounds, a refactor gate for evaluating findings, and budget guidance for scope control. The feedback loop (implement → verify → audit → fix → re-audit) is explicit with clear error recovery paths.	3 / 3
Progressive Disclosure	The skill references `references/auditor-prompts.md` for detailed auditor prompt templates, which is good progressive disclosure in principle, but no bundle files are provided so this reference is unverifiable. The main SKILL.md itself is monolithic — the agent sizing guide, tips, interoperability section, and detailed example walkthrough could be split into reference files. The inline auditor descriptions partially duplicate what the referenced file should contain.	2 / 3
	Total	8 / 12 Passed

Description

92%

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 is a strong description that clearly articulates a sophisticated multi-agent implementation and audit workflow. It excels at explaining both what it does and when to use it, with concrete actions and an explicit 'Use when' clause. The main weakness is that its trigger scenarios are broad enough ('implementing features', 'fixing a batch of issues') that it could potentially conflict with simpler coding or review skills.

Dimension	Reasoning	Score
Specificity	Lists multiple specific concrete actions: spawns implementation agents, audit agents, structured simplify/harden/document passes, loops until code compiles, tests pass, and auditors find zero issues. Very detailed about the mechanics.	3 / 3
Completeness	Clearly answers both 'what' (implementation + audit loop with parallel agent teams, structured passes, looping until clean) and 'when' (explicit 'Use when:' clause listing four specific scenarios: implementing from spec, hardening code, fixing batches, multi-file tasks).	3 / 3
Trigger Term Quality	Includes strong natural trigger terms: 'implementing features', 'spec or plan', 'hardening existing code', 'fixing a batch of issues', 'multi-file task', 'build-verify-fix cycle', 'audit', 'security gaps'. These cover a good range of terms users would naturally use.	3 / 3
Distinctiveness Conflict Risk	While the agent-based audit loop pattern is fairly distinctive, terms like 'implementing features', 'fixing issues', and 'multi-file task' are broad enough to potentially overlap with general coding, refactoring, or code review skills. The parallel agent team aspect helps distinguish it but the trigger scenarios are quite wide.	2 / 3
	Total	11 / 12 Passed

Validation

100%

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 — 11 / 11 Passed

Validation for skill structure

No warnings or errors.

Repository: pskoett/pskoett-ai-skills
Commit: 20e64ce

Reviewed: 15 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.