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 fi…
Install / Use
npx skills add LeoYeAI/openclaw-master-skills --skill agent-teams-simplify-and-hardenInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
SecuritySupported Platforms
Our assessment of agent-teams-simplify-and-harden
agent-teams-simplify-and-harden scores 90/100 on our quality scale, 492nd of 1,111 Security skills we index (top 45%).
Its SKILL.md is 20 KB long, well organised into 27 sections with 13 code examples: a thorough specification that gives an agent plenty to work with.
With 2,149 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-10-30 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
ReviewOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review judged it risky: The skill file instructs the agent to spawn implementation subagents with mode: bypassPermissions, which disables permission prompts and weakens the agent's safeguards.
AI review: risky
- The skill file instructs the agent to spawn implementation subagents with mode: bypassPermissions, which disables permission prompts and weakens the agent's safeguards.
- Because this is a SKILL.md file, the agent is expected to follow these instructions, so the bypassPermissions directive would be applied in practice.
- The rest of the workflow is a legitimate code-review loop, but the explicit permission-bypass mode makes the file meaningfully risky rather than benign.
AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-30. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
agent-teams-simplify-and-harden compared with similar skills
All 4 of these similar skills score higher than agent-teams-simplify-and-harden; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| agent-teams-simplify-and-harden (this skill)by LeoYeAI | 90 | 2.1k | 4mo ago | SKILL.md |
| x402by browser-use | 100 | 121.0k | 3d ago | SKILL.md |
| algorithmic-artby anthropics | 100 | 177.9k | 55d ago | SKILL.md |
| pptxby anthropics | 100 | 177.9k | 55d ago | SKILL.md |
| designby nextlevelbuilder | 100 | 149.0k | 6d ago | SKILL.md |
Frequently asked questions
- How do I install agent-teams-simplify-and-harden?
- Run
npx skills add LeoYeAI/openclaw-master-skills --skill agent-teams-simplify-and-harden. The install tabs above show the steps for each supported agent. - Which AI agents does agent-teams-simplify-and-harden work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is agent-teams-simplify-and-harden safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review judged it risky: The skill file instructs the agent to spawn implementation subagents with mode: bypassPermissions, which disables permission prompts and weakens the agent's safeguards. It is MIT-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is agent-teams-simplify-and-harden still maintained?
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: agent-teams-simplify-and-harden description: "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."
Agent Teams Simplify & Harden
Install
npx skills add pskoett/pskoett-ai-skills/agent-teams-simplify-and-harden
A two-phase team loop that produces production-quality code: implement, then audit using simplify + harden passes, then fix audit findings, then re-audit, repeating until the codebase is solid or the loop cap is reached.
When to Use
- Implementing multiple features from a spec or plan
- Hardening a codebase after a batch of changes
- Fixing a list of issues or gaps identified in a review
- Any task touching 5+ files where quality gates matter
The Pattern
┌──────────────────────────────────────────────────────────┐
│ TEAM LEAD (you) │
│ │
│ Phase 1: IMPLEMENT (+ document pass on fix rounds) │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ impl-1 │ │ impl-2 │ │ impl-3 │ ... │
│ │ (general │ │ (general │ │ (general │ │
│ │ purpose) │ │ purpose) │ │ purpose) │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ Verify: compile + tests │ │
│ └─────────────────────────────────────┘ │
│ │ │
│ Phase 2: SIMPLIFY & HARDEN AUDIT │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ simplify │ │ harden │ │ spec │ ... │
│ │ auditor │ │ auditor │ │ auditor │ │
│ │ (Explore)│ │ (Explore)│ │ (Explore)│ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ Exit conditions met? │
│ YES → Produce summary. Ship it. │
│ NO → back to Phase 1 with findings as tasks │
│ (max 3 audit rounds) │
└──────────────────────────────────────────────────────────┘
Loop Limits and Exit Conditions
The loop exits when ANY of these are true:
- Clean audit: All auditors report zero findings
- Low-only round: All findings in a round are severity
low-- fix them inline (team lead or a single impl agent) and exit without re-auditing - Loop cap reached: 3 audit rounds have completed. After the third round, fix remaining critical/high findings inline and exit. Log any unresolved medium/low findings in the final summary.
Budget guidance: Track the cumulative diff growth across rounds. If fix rounds have added more than 30% on top of the original implementation diff, tighten the scope: skip medium/low simplify findings and focus only on harden patches and spec gaps.
Step-by-Step Procedure
1. Create the Team
TeamCreate:
team_name: "<project>-harden"
description: "Implement and harden <description>"
2. Create Tasks
Break the work into discrete, parallelizable tasks. Each task should be independent enough for one agent to complete without blocking on others.
TaskCreate for each unit of work:
subject: "Implement <specific thing>"
description: "Detailed requirements, file paths, acceptance criteria"
activeForm: "Implementing <thing>"
Set up dependencies if needed:
TaskUpdate: { taskId: "2", addBlockedBy: ["1"] }
3. Spawn Implementation Agents
Spawn general-purpose agents (they can read, write, and edit files). One per task or one per logical group. Run them in parallel.
Task tool (spawn teammate):
subagent_type: general-purpose
team_name: "<project>-harden"
name: "impl-<area>"
mode: bypassPermissions
prompt: |
You are an implementation agent on the <project>-harden team.
Your name is impl-<area>.
Check TaskList for your assigned tasks and complete them.
After completing each task, mark it completed and check for more.
Quality gates:
- Code must compile cleanly (substitute your project's compile
command, e.g. bunx tsc --noEmit, cargo build, go build ./...)
- Tests must pass (substitute your project's test command,
e.g. bun test, pytest, go test ./...)
- Follow existing code patterns and conventions
When all your tasks are done, notify the team lead.
4. Wait for Implementation to Complete
Monitor agent messages. When all implementation agents report done:
- Run compile/type checks to verify clean build
- Run tests to verify all pass
- If either fails, fix or assign fixes before proceeding
Before spawning auditors, collect the list of files modified in this session:
git diff --name-only <base-branch> # or: git diff --name-only HEAD~N
You will pass this file list to each auditor.
5. Spawn Audit Agents
Spawn Explore agents (read-only -- they cannot edit files, which prevents them from "fixing" issues silently). Each auditor covers a different concern using the Simplify & Harden methodology.
Recommended audit dimensions:
| Auditor | Focus | Mindset | |---------|-------|---------| | simplify-auditor | Code clarity and unnecessary complexity | "Is there a simpler way to express this?" | | harden-auditor | Security and resilience gaps | "If someone malicious saw this, what would they try?" | | spec-auditor | Implementation vs spec/plan completeness | "Does the code match what was asked for?" |
Simplify Auditor
Task tool (spawn teammate):
subagent_type: Explore
team_name: "<project>-harden"
name: "simplify-auditor"
prompt: |
You are a simplify auditor on the <project>-harden team.
Your name is simplify-auditor.
Your job is to find unnecessary complexity -- NOT fix it. You are
read-only.
SCOPE: Only review the following files (modified in this session).
Do NOT flag issues in other files, even if you notice them.
Files to review:
<paste file list here>
Fresh-eyes start (mandatory): Before reporting findings, re-read all
listed changed code with "fresh eyes" and actively look for obvious
bugs, errors, confusing logic, brittle assumptions, naming issues,
and missed hardening opportunities.
Review each file and check for:
1. Dead code and scaffolding -- debug logs, commented-out attempts,
unused imports, temporary variables left from iteration
2. Naming clarity -- function names, variables, and parameters that
don't read clearly when seen fresh
3. Control flow -- nested conditionals that could be flattened, early
returns that could replace deep nesting, boolean expressions that
could be simplified
4. API surface -- public methods/functions that should be private,
more exposure than necessary
5. Over-abstraction -- classes, interfaces, or wrapper functions not
justified by current scope. Agents tend to over-engineer.
6. Consolidation -- logic spread across multiple functions/files that
could live in one place
For each finding, categorize as:
- **Cosmetic** (dead code, unused imports, naming, control flow,
visibility reduction) -- low risk, easy fix
- **Refactor** (consolidation, restructuring, abstraction changes)
-- only flag when genuinely necessary, not just "slightly better."
The bar: would a senior engineer say the current state is clearly
wrong, not just imperfect?
For each finding report:
1. File and line number
2. Category (cosmetic or refactor)
3. What's wrong
4. What it should be (specific fix, not vague)
5. Severity: high / medium / low
If you notice issues outside the scoped files, list them separately
under "Out-of-scope observations" at the end.
Be thorough within scope. Check every listed file.
When done, send your complete findings to the team lead.
If you find ZERO in-scope issues, say so explicitly.
Harden Auditor
Task tool (spawn teammate):
subagent_type: Explore
team_name: "<project>-harden"
name: "harden-auditor"
prompt: |
You are a security/harden auditor on the <project>-harden team.
Your name is harden-auditor.
Your job is to find security and resilience gaps -- NOT fix them.
You are read-only.
SCOPE: Only review the following files (modified in this session).
Do NOT flag issues in other files, even if you notice them.
Files to review:
<paste file list here>
Fresh-eyes start (mandatory): Before reporting findings, re-read all
listed changed code with "fresh eyes" and actively look for obvious
bugs, errors, confusing logic, brittle assumptions, naming issues,
and missed hardening opportunities.
Review each file and check for:
1. Input validation -- unvalidated external inputs (user input, API
params, file paths, env vars), type coercion issues, missing
bounds checks, unconstrained string lengths
2. Error handling -- non-specific catch blocks, errors logged without
context, swallowed exceptions, sensitive data in error messages
3. Injection vectors -- SQL injection, XSS, command injection, path
traversal, template injection in string-building code
4. Auth and authorization -- endpoints or functions missing auth,
incorrect permission checks, privilege escalation risks
5. Secrets and credentials -- hardcoded secrets, API keys, tokens,
credentials in log output, unparameterized connection strings
6. Data exposure -- internal state in error output, stack traces in
responses, PII in logs, database schemas leaked
7. Dependency risk -- new dependencies that are unmaintained, poorly
versioned, or have known vulnerabilities
8. Race conditions -- unsynchronized shared resources, TOCTOU
vulnerabilities in concurrent code
For each finding, categorize as:
- **Patch** (adding validation, escaping output, removing a secret)
-- straightforward fix
- **Security refactor** (restructuring auth flow, replacing a
vulnerable pattern) -- requires structural changes
For each finding report:
1. File and line number
2. Category (patch or security refactor)
3. What's wrong
4. Severity: critical / high / medium / low
5. Attack vector (if applicable)
6. Specific fix recommendation
If you notice issues outside the scoped files, list them separately
under "Out-of-scope observations" at the end.
Be thorough within scope. Check every listed file.
When done, send your complete findings to the team lead.
If you find ZERO in-scope issues, say so explicitly.
Spec Auditor
Task tool (spawn teammate):
subagent_type: Explore
team_name: "<project>-harden"
name: "spec-auditor"
prompt: |
You are a spec auditor on the <project>-harden team.
Your name is spec-auditor.
Your job is to find gaps between implementation and spec/plan --
NOT fix them. You are read-only.
SCOPE: Only review the following files (modified in this session).
Do NOT flag issues in other files, even if you notice them.
Files t
Truncated for display — read the full file on GitHub.
Related Skills
x402
121.0kSet up Browser Use Cloud payments with x402 — pay per request from a crypto wallet (USDC on Base mainnet), no signup or API key.
algorithmic-art
177.9kCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems.
pptx
177.9kUse this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an em…
design
149.0kComprehensive design skill: brand identity, design tokens, UI styling, logo generation (55 styles, Gemini, Atlas Cloud, or MuAPI AI), corporate identity program (50 deliverables, CIP mockups), HTML presentations (Chart.js), banner design (22 styles, social/ads/web/print), icon design (15 styles, SVG…
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
