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

Passed

No known issues

Optimize this skill with Tessl

npx tessl skill review --optimize ./skills/agent-teams-simplify-and-harden/SKILL.md

Quality

Discovery

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 the skill does and when to use it, with concrete details about the loop mechanics and exit conditions. The main weakness is that some trigger scenarios ('implementing features', 'fixing a batch of issues') are broad enough to potentially conflict with simpler coding 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 parallel agent team architecture and audit loop are distinctive, terms like 'implementing features', 'fixing a batch of issues', and 'multi-file task' are broad enough to potentially overlap with simpler coding or task-management skills. The agent-based loop pattern helps differentiate but the trigger scenarios are fairly general.	2 / 3
	Total	11 / 12 Passed

Implementation

47%

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

This skill demonstrates excellent workflow design with clear sequencing, validation gates, exit conditions, and drift checks — it's a well-thought-out orchestration pattern. However, it is significantly over-verbose, explaining concepts Claude already knows and repeating information across sections (e.g., the example walkthrough restates the procedure). The actionability is hampered by pseudo-syntax for tool invocations and a missing bundle file for auditor prompts.

Suggestions

Cut the content by 40-50%: remove the install section, collapse the pipeline integration and interoperability sections into 2-3 lines each, remove the ASCII pipeline diagram (the procedure already explains the flow), and eliminate the example walkthrough that restates the procedure.

Provide the referenced `references/auditor-prompts.md` bundle file, or inline the essential auditor prompt content — currently the auditor section describes what each auditor does but defers the actual prompts to a missing file.

Clarify the exact tool invocation syntax for TeamCreate, TaskCreate, TaskUpdate, and agent spawning — are these CLI commands, API calls, or Claude tool-use schemas? Provide one complete, copy-paste-ready example.

Move the Agent Sizing Guide, Tips section, and Interoperability section 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 explains concepts Claude already understands (what parallel agents are, what auditing means, how to break work into tasks), includes extensive ASCII diagrams, redundant examples that restate the procedure, and a full pipeline integration section that repeats information. The install section, pipeline diagrams, and interoperability sections add significant token overhead without proportional value.	1 / 3
Actionability	The skill provides structured steps and pseudo-code for team/task creation, but the code blocks are not truly executable — they use placeholder syntax (e.g., `TeamCreate:`, `TaskCreate`, `Task tool (spawn teammate)`) that isn't real CLI or API syntax. The auditor prompts reference `references/auditor-prompts.md` which is not provided. The procedure is detailed but relies on tools and APIs whose exact invocation syntax is unclear.	2 / 3
Workflow Clarity	The multi-step workflow is exceptionally well-sequenced with numbered steps, explicit validation checkpoints (compile + test between phases), clear exit conditions with three defined paths, drift checks between rounds, a refactor gate for evaluating findings, and budget guidance for scope control. The loop limits and feedback loops are explicit and well-defined.	3 / 3
Progressive Disclosure	The skill references `references/auditor-prompts.md` for detailed auditor prompt templates, which is good progressive disclosure design, but no bundle files are provided so this reference is broken. The main SKILL.md itself is monolithic — the agent sizing guide, tips, example walkthrough, interoperability section, and detailed auditor descriptions could be split into reference files. The inline content is too long for a single overview file.	2 / 3
	Total	8 / 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: f6c5d7b

Reviewed: about 2 hours 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.