home / skills / shipshitdev / library / workspace-performance-audit

workspace-performance-audit skill

needs review

/bundles/session/skills/workspace-performance-audit

This skill orchestrates a comprehensive workspace performance audit across monorepos, coordinating specialized experts to analyze frontend, backend, database,

npx playbooks add skill shipshitdev/library --skill workspace-performance-audit

Review the files below or copy the command above to add this skill to your agents.

Files (3)

SKILL.md

2.4 KB

---
name: workspace-performance-audit
description: Orchestrates comprehensive performance audits across full-stack monorepos. Coordinates performance-expert, design-consistency-auditor, accessibility, security-expert, and qa-reviewer skills to audit frontend, backend, database, browser extensions, and shared packages.
---

# Workspace Performance Audit

## Overview

Orchestrates comprehensive performance audits across entire monorepo workspaces. Coordinates multiple specialized skills to analyze frontend (Next.js), backend (NestJS), database (MongoDB), browser extensions (Plasmo), and shared packages—delivering consolidated reports with prioritized recommendations.

## When to Use

- Full workspace performance review
- Audit a monorepo
- "audit performance", "check workspace performance"
- Identify bottlenecks across frontend, backend, extensions
- Consolidated performance metrics needed

## Skills Orchestrated

| Skill | Focus Area | Phase |
|-------|------------|-------|
| `performance-expert` | Performance metrics & optimization | 1-4 |
| `design-consistency-auditor` | UI/UX consistency & design debt | 1 |
| `accessibility` | WCAG 2.1 AA compliance | 1 |
| `security-expert` | Security validation | 2 |
| `qa-reviewer` | Validation & prioritization | 5 |

## Orchestration Flow

```
Phase 0: Workspace Discovery
    → Identify apps, packages, tech stacks

Phase 1: Frontend Audit (Next.js)
    → Core Web Vitals, Bundle Analysis, Design, A11y

Phase 2: Backend Audit (NestJS)
    → API Response Times, N+1 Queries, Security

Phase 3: Database Audit (MongoDB)
    → Query Performance, Index Analysis

Phase 4: Extension & Packages
    → Bundle Sizes, Memory, Dependencies

Phase 5: Consolidation
    → Aggregate, Score, Prioritize, Report
```

## Key Metrics by Domain

| Domain | Key Metrics | Targets |
|--------|-------------|---------|
| Frontend | LCP, FID, CLS | <2.5s, <100ms, <0.1 |
| Backend | p50, p95 response | <100ms, <200ms |
| Database | Query p95, Index hit | <50ms, >95% |
| Extension | Content script size | <50KB |

## Usage Modes

**Quick Audit:** Essential checks only → 1-page summary
**Full Audit:** All phases → Complete report
**Domain-Specific:** Single domain focus

## Integration

Produces reports for `.agents/AUDITS/YYYY-MM-DD-performance.md`

---

**For detailed phase execution, metric collection commands, report templates, best practices, and example interactions, see:** `references/full-guide.md`

Overview

This skill orchestrates comprehensive performance audits across full-stack monorepos, coordinating specialized analyzers for frontend, backend, database, extensions, and shared packages. It consolidates findings into prioritized, actionable reports and assigns scores and remediation steps to help teams reduce latency, bundle weight, and architectural bottlenecks. Use it to get a single source of truth for workspace-wide performance health.

How this skill works

The skill performs workspace discovery to identify apps, packages, and tech stacks, then runs domain-specific phases: frontend (Core Web Vitals and bundle analysis), backend (API latency and query patterns), database (query p95 and index coverage), and extensions/packages (bundle size and memory). It consolidates results, scores domains against target metrics, and produces a prioritized report with remediation recommendations and validation checks. Orchestration calls out to dedicated expert skills for design consistency, accessibility, security, and QA validation to ensure holistic guidance.

When to use it

Before a major release to validate performance across the entire monorepo
When migrating or refactoring shared packages that could impact multiple apps
To find cross-cutting bottlenecks affecting frontend, backend, and database
When you need a consolidated, prioritized remediation plan for engineering teams
To audit browser extensions or other non-web components tied to the workspace

Best practices

Run Quick Audit during CI for fast regressions and Full Audit on release branches
Establish baseline targets (Core Web Vitals, p95 response, query p95) and track regressions over time
Use the consolidated report to assign fixes by domain owner and track verification
Prioritize fixes by impact and cost: high-impact, low-effort items first
Include accessibility and security checks during audits to prevent performance/security trade-offs

Example use cases

Full monorepo performance review before a high-traffic product launch
Targeted backend audit to address p95 API latency spikes and N+1 queries
Frontend bundle analysis to reduce LCP and lower initial download size
Database index and query audit after noticing slow page loads tied to DB reads
Extension package audit to reduce content script size and memory usage

FAQ

How long does a full audit take?

Duration depends on repo size and test depth: Quick Audits finish in minutes, Full Audits can take from tens of minutes to a few hours for large monorepos.

Can I run only one domain audit?

Yes. You can run domain-specific audits (frontend, backend, database, extensions) without executing the full flow.

What output formats are produced?

The skill produces a consolidated markdown report with scores and prioritized recommendations suitable for CI artifacts and team review.