| name | adversarial-performance |
| description | Multi-pass adversarial performance audit for entire repositories. Combines
structured profiling (Agent A) with adversarial stress-testing critique
(Agent B) through iterative passes. Optimize repo/backend performance, hot-paths, build size, and server throughput. Do NOT use for frontend page load metrics
or Lighthouse audits (use web-perf). NOT for frontend Core Web Vitals (use web-perf).
|
Adversarial Performance
A multi-pass performance auditing system that produces high-confidence
optimization assessments by introducing structured adversarial critique
stages. Audits pass through an iterative pipeline of profiling,
stress-testing critique, optimization planning, and optional external
validation — producing output optimized for measurable impact, effort
efficiency, and regression safety.
When to Load
Load this skill when any of these apply:
- Running a performance audit against an entire repository
- Profiling build times, runtime hot paths, or bundle size
- The user asks for an adversarial performance review or stress-test analysis
- The user says "perf audit", "performance review", "find bottlenecks",
"adversarial performance", "optimize this repo", "make this faster",
"why is this slow", or "speed up my code"
- Preparing a performance baseline report before a major release
- You want to reduce blind spots in your own performance assessment
Auto-Detection
Before starting, auto-detect the project profile by scanning the repository:
| Signal | Project Profile | Extra Categories |
|---|
MCP SDK imports, tool handlers, tools/list | mcp-server | Token & Context Efficiency (Category 7) — full depth |
Express/Hono/Fastify, HTTP handlers, listen() | web-app | Runtime Performance (Category 4) — extra API latency focus |
bin field, CLI arg parsing | cli-tool | Startup Cost analysis in Category 4 |
| Vitest/Jest/Playwright config | tested | Test Suite Performance (Category 5) — full depth |
| Dockerfile present | containerized | Build Performance (Category 1) — Docker layer analysis |
| Database imports (better-sqlite3, pg, mysql2) | data-layer | Database & I/O (Category 6) — full depth |
Profiles stack. A typical MCP server might be mcp-server + cli-tool + tested + containerized + data-layer.
Adversarial Protocol
This skill follows the standard dual-agent adversarial pattern (Agent A: The Profiler, Agent B: The Stress Tester).
For the core pipeline rules, phase definitions, and agent switching protocols, read:
../adversarial-security/references/adversarial-base-protocol.md
For the performance-specific protocol with review dimensions, scoring weights, and output templates, read:
references/multi-pass-performance-protocol.md
Audit Categories
The 7 performance categories audited during Phase 1 (Profiling) and
challenged during Phase 2 (Stress Test) are:
- Build Performance
- Bundle & Output Analysis
- Dependency Weight
- Runtime Performance
- Test Suite Performance
- Database & I/O Performance
- Token & Context Efficiency (MCP servers — graceful degradation)
For the full checklist with measurement methods, anti-patterns, and
optimization patterns, read
references/audit-categories.md.
External Validation (Phase 4)
Phase 4 triggers an independent validation pass using the GitHub CLI (gh copilot).
This provides a fundamentally different model's perspective on the audit,
catching performance patterns that internal review normalizes.
For Copilot-specific prompt templates, read
references/copilot-performance-prompts.md.
Prerequisites: gh CLI v2.x+ with gh auth status passing. If gh copilot
is not available, skip Phase 4 gracefully and note the skip in the journal entry.
Read references/copilot-usage.md for critical non-interactive execution requirements.
Feedback Loop & Documentation
Every phase creates a journal entry with structured tags and entry types.
This builds a searchable audit trail that tracks performance evolution
across releases.
For journal templates, tag conventions, and retrospective templates, read
references/feedback-loop.md.
Journal Opt-Out
See references/journal-opt-out.md for instructions on how to handle explicit opt-outs from journaling.
Consolidated Report
The final deliverable is a single consolidated artifact merging all four
phases into one document. Do NOT produce separate artifacts per phase — the user should receive one
comprehensive document with all findings, optimizations, and external
validation results. Before sharing output outside the audit context, redact or generalize sensitive query patterns, specific API payloads, and avoid including live credentials or internal hostnames.
Configuration
| Variable | Default | Description |
|---|
MAX_AUDIT_PASSES | 2 | Maximum stress-test cycles (phases 2–3 repeat) |
AUDIT_DEPTH | standard | Depth: scan, standard, or intensive |
COPILOT_VALIDATION | true | Enable/disable the Copilot extension validation phase |
PROJECT_PROFILE | auto | Auto-detect or explicit profile list |
RUN_COMMANDS | false | Whether to execute measurement commands (tsc --diagnostics, npm test, etc.) or perform static analysis only |
Audit Depth Profiles
- Scan: Quick triage — Categories 1, 3, 4 only. Focus on the most
impactful bottlenecks. Best for small repos or time-constrained reviews.
- Standard: Full 7-category audit with all review dimensions. Default
for most repositories.
- Intensive: Extended audit with additional focus on:
- Algorithmic complexity analysis (Big-O) on hot paths
- Memory allocation profiling patterns
- Cold start vs. warm path divergence
- Concurrency bottleneck analysis (event loop blocking, worker saturation)
- Historical regression tracking (compare against prior audit baselines)
Synergies
| Skill/Workflow | Relationship |
|---|
adversarial-security | Sibling skill — applies adversarial pattern to security; this applies it to performance |
adversarial-planner | Parent pattern — plan-level adversarial review; this and security extend it to audits |
autonomous-dev | Generator/Evaluator pipeline at code level; use after this skill to implement optimizations |
/perf-audit workflow | Provides the category checklist; this skill adds adversarial methodology on top |
web-perf | Web-specific performance skill; use alongside for frontend-heavy projects |
