nguyenthienthanh

agent-detector

CRITICAL: MUST run for EVERY message. Detects agent, complexity, AND model automatically. Without this, tasks route to wrong agents and use wrong models, degrading quality and wasting tokens.

API & Backend Solid

Designs RESTful APIs with endpoint naming, versioning strategies (URL path, header-based), pagination (offset and cursor), error response schemas, and OpenAPI conventions. Use when the user asks about REST API design, creating endpoints, URL structure, API versioning, status codes, Swagger, or OpenAPI specs.

bugfix-quick

Fast bug fixes with root cause investigation + TDD. Enforces 'no fix without root cause' discipline and verification protocol. Without this skill, fixes are applied at symptoms instead of sources, and bugs return.

chain-of-verification

Draft → generate verification questions → answer independently via tools → revise. Catches hallucinated facts in reports and reviews. MANDATORY for Phase 4 security/test claims. Paper: Dhuliawala et al. 2023.

code-reviewer

6-aspect structured code review (security, architecture, error handling, test gaps, type safety, simplification) with calibrated scoring and per-aspect breakdown. Use when the user asks to review code, check a PR, review a pull request, audit changes before merge, or give code feedback.

conflict-detector

L1-L4 conflict detection between a proposed T4 task and pending-confirm sibling tasks. L1 (file overlap) + L2 (function/region overlap) ship in v3.7.0-beta.2 as deterministic bash. L3 (semantic LLM) + L4 (architectural LLM) are stubbed for v3.7.0-rc.1.

deep-debugging

Systematic debugging protocol for bugs that resist quick fixes. Use bisection, hypothesis trees, and scientific method when a bug isn't obvious from the stack trace. Goes beyond bugfix-quick for production-grade root cause analysis.

design-expert

UI/UX design expertise — component design, design system selection, responsive layout. Includes auto-detection from package.json and Context7 integration for library docs.

design-vision-loop

Vision feedback loop for UI — render the running UI, screenshot it across viewports + dark mode, run deterministic gates then a multimodal critique against the design system, and iterate until it passes. Use after building or changing a UI component/page, when asked to 'check the UI', make it 'look right', or verify a build matches a design spec / Stitch screen.

extension-detector

Detects when a new project-level skill / rule / command would reduce friction. Asks the user for confirmation before creating anything. NEVER writes plugin-level files — only `.claude/skills/`, `.claude/rules/`, `.claude/commands/` in the user's project.

failure-classifier

Classifies execution failures into F1-F5 (transient/local-logic/local-design/story-level/architectural). Outputs JSON with class, confidence, evidence, and recommended action. Deterministic rule-based classifier; no LLM call.

lazy-agent-loader

Load agent definitions on-demand to reduce context usage. Only loads full agent when needed.

learning-analyzer

Analyze collected learning data from Supabase to identify success patterns, failure patterns, optimization opportunities, and agent performance trends.

mcp-security-auditor

On-demand audit of MCP usage. Reads .aura/security/mcp-audit.jsonl, surfaces blocked calls, rate-limit hits, suspicious input patterns. Companion to mcp-call-gate hook (which produces the audit log).

migration-helper

Guide safe database and code migrations with zero-downtime strategies.

monorepo

Detect and navigate monorepos correctly. Use when working with repos containing multiple packages (pnpm/yarn/npm workspaces, Turborepo, Nx, Lerna). Ensures commands run in correct package scope, dependencies are routed properly, and cross-package changes are coordinated.

perf-profiling

Systematic performance profiling and optimization. Use when performance issues are reported or suspected. Measure first, optimize second. Applies Pareto principle — find the 20% of code causing 80% of slowness, fix that, not the rest.

performance-optimizer

Identifies and resolves performance bottlenecks across frontend (Core Web Vitals, code splitting, lazy loading), backend (N+1 queries, async processing), and database (EXPLAIN ANALYZE, indexing strategies) layers. Use when the user reports slow code, latency issues, memory leaks, needs to speed up an application, or wants to benchmark and profile performance.

permanent-memory-loader

Loads permanent_memory.md summary lines (≤120 always-loaded tokens, hard cap 200). Surfaces durable wisdom from past Epics into the current session. Silent if .claude/memory/ does not exist.

plan-archivist

Compresses a completed plan-tree branch into .claude/plans/archive/{NODE_ID}.summary.md. Removes the original node files (preserved by checkpoint history). Reduces always-loaded surface area as features ship.

plan-loader

Loads minimum hierarchical plan context (.claude/plans/) for current execution focus. Auto-invokes every session when plans exist. Stays under 800 always-loaded tokens regardless of plan tree size.

Data & Documents Solid

plan-orchestrator

Route hierarchical-planning intents to the correct backing script. Use when the user invokes /aura-frog:plan (with or without subcommand), mentions plan verbs (expand/next/replan/promote/archive/freeze/thaw/undo/status/conflicts), or types a plan-vocabulary bare word with .claude/plans/active.json present. Owns verb table, intent classifier, and 3-stage routing pipeline.

plan-validator

On-demand plan-tree validator. Runs all 8 invariants from spec §6.7 (parent existence, children integrity, no orphans, valid status, monotonic revision, test_ref existence, DAG no-cycles, freeze_reason). Refuses commits on violations.

preflight-validator

On-demand wrapper over scripts/preflight/run-all.sh. Runs Tier 1 bash linters against a file, command, or arbitrary content. Returns 0 pass / 1 warn / 2 fail. Used by /aura-frog:preflight check and contributors authoring custom hooks.

project-context-loader

Load project conventions and generate session context. Use EXPLICITLY when needed, not automatically.

prompt-evaluator

Evaluate how you use Claude Code — analyze prompt patterns, feature utilization, and get improvement suggestions. Trigger: /prompts:evaluate, prompt analysis, usage evaluation, how am I using Claude

reasoning-trace-recorder

Auto-invokes for every Claude turn during active T4 task execution. Emits append-only trace events (file_read, output_claim, tool_call, decision) to .claude/plans/traces/{TASK_ID}.jsonl. Source of grounding-discipline checks. Disable: AF_TRACE_DISABLED=true.

refactor-expert

Guide safe, incremental refactoring that improves code quality without changing behavior.

run-orchestrator

Execute 5-phase TDD workflow for complex features. Use when the user invokes /run, asks to build/create/implement a feature, requests a complex multi-file change, or types 'fasttrack:'. Enforces phase gates, sprint contracts, and builder!=reviewer discipline.

scalable-thinking

Design for scale while keeping implementation simple (KISS).

angular-expert

Angular 17+ gotchas and decision criteria. Covers signals vs observables, standalone patterns, and common pitfalls Claude gets wrong.

code-simplifier

Detect and simplify overly complex code. Apply KISS principle - less is more.

documentation

Create Architecture Decision Records (ADRs) and Runbooks for operational documentation.

flutter-expert

Flutter/Dart gotchas and decision criteria. Covers Riverpod vs BLoC, widget optimization, and platform-specific pitfalls.

framework-expert

Unified framework expertise bundle. Lazy-loads relevant framework patterns (React, Vue, Angular, Next.js, Node.js, Python, Laravel, Go, Flutter, Godot) based on detected tech stack.

git-workflow

Token-efficient git operations with security scanning and auto-split commits

git-worktree

Auto-create git worktrees for workflows. Isolate changes, merge on success, discard on failure.

go-expert

Go gotchas and decision criteria. Covers error handling patterns, concurrency pitfalls, and interface design.

laravel-expert

Laravel/PHP gotchas and decision criteria. Covers N+1 prevention, Eloquent traps, and migration safety.

nextjs-expert

Next.js 14+ gotchas and decision criteria. Covers server/client boundary, caching strategy, and data fetching patterns Claude commonly gets wrong.

nodejs-expert

Node.js gotchas and decision criteria. Covers async pitfalls, Express/NestJS patterns, and common mistakes.

phase1-lite

Ultra-compact Phase 1 requirements output. HARD CAP: 500 tokens.

problem-solving

5 techniques for different problem types. Use when stuck or facing complex challenges.

python-expert

Python gotchas and decision criteria. Covers async pitfalls, FastAPI/Django patterns, and type hint traps.

react-expert

React gotchas and decision criteria covering stale closure bugs in useEffect, conditional rendering traps (falsy 0/empty string), state management selection (useState vs Context vs Zustand vs TanStack Query), and hooks rules. Use when writing React components, debugging re-renders, choosing state management, or encountering useEffect infinite loops.

react-native-expert

React Native gotchas and decision criteria. Covers FlatList optimization, storage hierarchy, and platform-specific pitfalls.

response-analyzer

MCP Response Analyzer pattern - Write large responses to temp files, load summaries into context

design-tokens

Generate a cohesive color-token system from ONE OKLCH brand hue — primary/secondary/background/foreground/muted/border with semantic light + dark, emitted as a Tailwind v4 @theme block or a CSS-variables fallback. Use when starting a design system, defining brand colors, setting up theming/dark-mode, or replacing scattered hardcoded colors with a derived palette.

frontend-aesthetics

Anti-AI-slop taste layer for UI output — distinctive typography, dominant+accent color hierarchy, and implementation-matched polish. Use when building or restyling a UI/landing/component that should look designed rather than defaulted, or when the user asks for something 'beautiful', 'distinctive', 'less generic', or 'not another Tailwind template'.

motion-design

Restrained, accessible web motion — Framer Motion declarative patterns and CSS-only staggered reveals for high-impact moments, always bundle-aware and reduced-motion-safe. Use when adding animation/transitions to a UI (entrance reveals, list stagger, page/route transitions, micro-interactions) or when motion feels janky, heavy, or gratuitous.