ovid/paad/paad-help

paad — Engineering-driven AI.
Use your engineering excellence — the one thing AI reliably skips.
 
Full tutorial: https://curtispoe.org/paad/
 
Available skills:
 
  /agentic-a11y [path]                  Accessibility audit (web, mobile, desktop, CLI, games)
  /agentic-architecture [path...]       Multi-agent architecture analysis (strengths & flaws)
  /fix-architecture [report]            Fix architectural flaws from an analysis report
  /agentic-review [base-branch] [path]  Multi-agent code review of current branch (bug hunting)
  /alignment [files...]                 Requirements-to-tasks alignment + TDD rewrite
  /makefile                             Create or update a Makefile with standard targets
  /handoff [save|resume]                Hand this session's work to a fresh session, in writing
  /pushback [document]                  Spec/PRD/doc critic (finds issues before you build)
  /rethink [what to re-examine]         Verify the premises under options already on the table
  /test-roadmap                         Plan and build a test suite that catches real regressions
  /vibe [task description]              Safe vibe coding with TDD guardrails
 
Experimental — may change or be withdrawn in any release, including patches:
 
  /backlog [clean|fix]                  Clean or fix the out-of-scope bug backlog
  /agentic-dedup [scope]                Find semantic duplication (same meaning, different code)
  /agentic-owasp [scope]                Security review against the OWASP Top 10:2025
 
Picking between them:
 
  Want structural flaws found?          agentic-architecture (diagnoses, does not fix)
  Want them fixed?                      fix-architecture (needs a report first)
  Want bugs in a branch?                agentic-review (a diff, not the codebase)
  Have a backlog of found bugs?         backlog (experimental; clean stale
                                        entries, or fix the next one —
                                        agentic-review fills it)
  Want accessibility barriers?          agentic-a11y (not general correctness)
  Want duplicated logic found?          agentic-dedup (experimental; reports,
                                        never refactors)
  Worried about security specifically?  agentic-owasp (experimental; the OWASP
                                        Top 10:2025, never exploits or fixes)
  Have no tests, or tests you distrust? test-roadmap (writes tests and commits
                                        them, one commit per phase)
  Have one document, is it any good?    pushback (a spec, a steering file, a
                                        generated report)
  Been handed options, are they sound?  rethink (checks premises, does not
                                        invent alternatives)
  Out of context, work unfinished?      handoff (writes a file for a NEW
                                        session — /compact stays in this one)
  Have a spec AND a plan, do they match? alignment (needs both; does not read code)
  Making a small change?                vibe (1-3 files, same module)
  Change is clearly multi-module?       write a plan, then alignment against it
  Build is broken?                      none of these — makefile manages targets,
                                        it does not debug builds
 
Run /paad-help <skill-name> for detailed help on a specific skill.
 
Invoking: the names above are slash commands on Claude Code. If your
assistant does not take them, ask for the skill by name ("run the pushback
skill"). If another plugin ships a skill with the same name, disambiguate with
the paad: prefix — /paad:vibe rather than /vibe.
 
Configuration (experimental): put instructions in paad/config/paad.md to
steer every skill, or paad/config/<skill-name>.md to steer one. A skill that
finds a file follows it and opens its final answer with "Config: <path>".
Details and the caveats: https://github.com/Ovid/paad/blob/main/CONFIG.md
 
Security findings: any finding that would help an attacker is written only
under paad/security/, which carries its own .gitignore, and the ordinary
report gets a count and a pointer. Add paad/security/ to your root
.gitignore too. The directory is local scratch — git clean -x deletes it.
Reports from older releases in paad/owasp-reviews/ move under it by hand:
if git tracks them, git rm -r --cached paad/owasp-reviews/ first, then move
them and remove the old directory. Bug class: Security entries in
paad/code-reviews/backlog.md are copied across by /agentic-review; delete
the committed copies (/backlog clean does it). History keeps what was
committed either way, so rotate whatever it exposed.

/agentic-a11y [path]
 
Comprehensive multi-agent accessibility audit of user-facing code.
 
Supports: web, iOS, Android, React Native, Flutter, desktop, CLI, and games.
Target:   WCAG 2.2 AA baseline, AAA flagged as bonus recommendations.
Output:   paad/a11y-reviews/
 
Arguments:
  /agentic-a11y                    Audit all user-facing code in the repo
  /agentic-a11y src/components/    Scope to a directory
  /agentic-a11y Modal.tsx          Scope to a file
 
What it does:
  1. Detects the platform(s) automatically
  2. Dispatches 5 specialist agents in parallel:
     - Screen Reader & Assistive Tech
     - Visual & Color
     - Keyboard & Motor
     - Cognitive & Learning
     - Multimedia & Temporal
  3. Dispatches a Platform-Specific agent if a framework is detected
  4. Verifies findings (filters false positives from component libraries)
  5. Writes a report with:
     - Impact summary by user group
     - Issues ranked by severity (Critical/Serious/Moderate/Minor)
     - WCAG conformance checklist
     - Quick wins (top 5 highest-impact, lowest-effort fixes)
 
Best used in a fresh session — consumes significant context.

/agentic-architecture [path...]
 
Multi-agent architecture analysis. Diagnosis only — finds strengths and
flaws with evidence but does not propose fixes.
 
Output: paad/architecture-reviews/
        paad/security/agentic-architecture-<date>-<repo>.md (security findings, ignored)
 
Arguments:
  /agentic-architecture                          Full repo
  /agentic-architecture src/                     Scope to a directory
  /agentic-architecture packages/api/ packages/shared/  Multiple dirs
 
What it does:
  1. Reconnaissance: repo overview, dependency snapshot, steering files
  2. Dispatches 5 specialist agents in parallel:
     - Structure & Boundaries (god objects, cohesion, domain modeling)
     - Coupling & Dependencies (tight coupling, circular deps, abstractions)
     - Integration & Data (API contracts, data ownership, resilience)
     - Error Handling & Observability (error strategy, logging, config)
     - Security & Code Quality (auth, secrets, dead code, test coverage)
  3. Verifies findings (reads actual code, checks git history)
  4. Writes a report with:
     - 14 strength categories assessed
     - 34 flaw/risk types assessed
     - Coverage checklist (every category: observed / not observed / N/A)
     - Hotspots (top 3 files/directories to review)
     - Next questions (max 5, no solutions)
 
Best used in a fresh session — consumes significant context.

/fix-architecture [report]
 
Guided fixing of architectural flaws from an agentic-architecture report.
Test-first workflow with developer approval at every step.
 
Output: Updates the report in paad/architecture-reviews/ with fix status
        Also loads and updates the matching paad/security/ file, where
        agentic-architecture puts flaws that would help an attacker; their
        commit messages never name the flaw or the file
 
Arguments:
  /fix-architecture                         Find most recent report
  /fix-architecture path/to/report.md       Use a specific report
 
Requirements:
  - Must be on a feature branch (not main/master/trunk)
  - An architecture report must exist (run /agentic-architecture first)
 
What it does:
  1. Pre-flight: branch check, report staleness, test infrastructure,
     baseline test run
  2. Developer conversation:
     - Solo or team? (affects batch size recommendations)
     - Auto-commit or manual review?
     - Flaw triage: high-impact, quick wins, or specific F-IDs
     - Plan confirmation before any code is touched
  3. For each selected flaw:
     - Validates the flaw still exists (checks code and git history)
     - Assesses test coverage, writes safety-net tests if needed
     - Proposes fix options with tradeoffs (recommended option first)
     - Executes with red/green/refactor
     - Handles test failures (distinguishes structural vs behavioral)
     - Commits (one per fix) and updates the report
     - Checks if the fix resolved other flaws too
  4. Post-session summary with remaining flaw count
 
Status tracking in the report:
  Fixed | Won't fix | Partially fixed | Skipped |
  Fixed (pre-existing) | Attempted, reverted
 
Best used in a fresh session — consumes significant context.

/agentic-review [base-branch] [path]
 
Multi-agent bug-hunting code review of the current branch.
 
Output:   paad/code-reviews/<branch>-<timestamp>-<short-sha>.md (per-review)
          paad/code-reviews/backlog.md (project-wide, persistent)
          paad/security/code-review-<branch>-<timestamp>-<sha>.md and
          paad/security/backlog.md (security findings, ignored)
 
Arguments:
  /agentic-review                    Diff against the default branch
  /agentic-review develop            Diff against a different branch
  /agentic-review main src/auth/     Scope to a directory
 
  One argument is read as a base branch if git can resolve it, otherwise
  as a path if it exists on disk. If it is both -- "docs", "release",
  "test" and "api" are ordinary names for either -- the skill stops and
  asks rather than guessing.