super-dev

Perform multi-lens adversarial review to challenge implementation correctness, structural fitness, and necessity

Design architecture and create Architecture Decision Records (ADRs) for complex features

Incrementally fix TypeScript and build errors:

Assess existing codebase for architecture, standards, and framework patterns

Perform specification-aware code review focused on correctness, security, performance, and maintainability

Perform systematic root cause analysis for bugs and errors

Update documentation sequentially after code review and approval

Generate and run end-to-end tests with Playwright. Creates test journeys, runs tests, captures screenshots/videos/traces, and uploads artifacts.

Execute development and QA in parallel using specialized agents

Analyze the current session and extract any patterns worth saving as skills.

Restate requirements, assess risks, and create step-by-step implementation plan. WAIT for user CONFIRM before touching any code.

Safely identify and remove dead code with test verification:

Conduct comprehensive research on best practices, patterns, and documentation

Enforce test-driven development workflow. Scaffold interfaces, generate tests FIRST, then implement minimal code to pass. Ensure 80%+ coverage.

Analyze test coverage and generate missing tests:

Create UI/UX design specifications for features with user interfaces

Analyze the codebase structure and update architecture documentation:

Sync documentation from source-of-truth:

View skill and agent usage statistics for the super-dev plugin

Challenge implementations from distinct critical lenses (Skeptic, Architect, Minimalist) to catch issues standard code review misses. Produces a verdict, NOT code modifications.

Android engineer with modern Kotlin 2.x/K2 compiler, Jetpack Compose (BOM 2025.12, Material 3 1.4), Navigation 3 (type-safe NavDisplay), Hilt DI with KSP, Room 2.8 (KMP), AGP 9.x with built-in Kotlin, Baseline Profiles, Compose screenshot testing, and quality gates (ktlint/detekt, unit/UI tests ≥80% coverage, accessibility).

Software architecture specialist for system design, scalability, and technical decision-making. Use PROACTIVELY when planning new features, refactoring large systems, or making architectural decisions.

Produce concise, implementation-ready architecture: module decomposition, interfaces, ADRs, and validation. Use for complex features that need architectural planning before specs.

Backend engineer with modern, enforceable best practices for Node.js 22 LTS/TypeScript 6.0 (Hono framework, Drizzle ORM) and Python 3.14 (free-threaded, uv package manager, FastAPI 0.135+/Pydantic v2): security hardening (headers, authN/Z, secrets), strict validation (Zod/Pydantic), performance (profiling, caching, pagination, connection pooling), deterministic testing (unit/integration with coverage), observability (structured logging, tracing, metrics), and quality gates (lint/typecheck/OpenAPI, SLOs).

Write BDD behavior scenarios in Gherkin-like markdown from requirements acceptance criteria. Produces traceable Given/When/Then scenarios mapped to acceptance criteria with quality validation.

Build and TypeScript error resolution specialist. Use PROACTIVELY when build fails or type errors occur. Fixes build/type errors only with minimal diffs, no architectural edits. Focuses on getting the build green quickly.

Execute concise, specification-aware assessments of architecture, standards, dependencies, and framework patterns to align future changes with existing conventions.

Execute concise, specification-first code reviews focused on correctness, security, performance, and maintainability. Produce actionable findings with severity and clear evidence.

Team Lead Agent for orchestrating agent team development workflow. Spawns specialized teammates, manages shared task list, coordinates via direct messaging, and ensures complete implementation with no missing tasks or unauthorized stops.

Perform concise, systematic root-cause debugging with evidence collection, reproducible steps, scoped code analysis, hypothesis verification, and actionable fixes. Enforce path-formatted code blocks and quality gates.

Development executor agent for implementing code changes during parallel execution phase. Invokes specialist developer agents and manages build requests.

Documentation and codemap specialist. Use PROACTIVELY for updating codemaps and documentation. Runs /update-codemaps and /update-docs, generates docs/CODEMAPS/*, updates READMEs and guides.

Concise, executable documentation agent for sequential documentation updates after code review. Enforces quality gates, tracks task list, implementation summary, spec deviations, and coordinates commits with code.

End-to-end testing specialist using Playwright. Use PROACTIVELY for generating, maintaining, and running E2E tests. Manages test journeys, quarantines flaky tests, uploads artifacts (screenshots, videos, traces), and ensures critical user flows work.

Modern frontend engineer with React 19 and Next.js 16 App Router discipline (server-first, "use cache"/tag/revalidation, Cache Components), React Compiler 1.0 (auto-memoization), TypeScript 6.0 strict, Tailwind v4 (CSS-first config, Rust engine), Auth.js v5, Prisma 7.1+, Vitest 4.1, Playwright 1.58, and executable quality gates (unit/E2E ≥80% coverage, Core Web Vitals, WCAG AA).

Go engineer enforcing modern Go 1.24+ best practices: range-over-func iterators (iter.Seq), enhanced ServeMux routing, generic type aliases, os.Root path-traversal safety, Swiss Table maps, structured logging (slog), observability (metrics, tracing), performance (pprof, b.Loop benchmarks), testing (synctest, t.Context), and executable quality gates (golangci-lint v2 with modernize, tests ≥80% coverage).

Generate structured session handoff documents for seamless AI agent continuity. Synthesizes all spec artifacts, review results, and workflow context into a 7-section handoff written FOR the next AI agent.

Systematic root-cause investigation agent for mid-development unknowns. Spawned by any phase agent (dev-executor, qa-agent, code-reviewer) when they hit unexpected behavior, missing information, or repeated failures. Follows a bounded 4-phase protocol: Gather, Search, Hypothesize, Resolve. Iron Law: no fix without root cause. Budget: 120 seconds max, 5 tool calls max.

iOS engineer enforcing Swift 6.x best practices: strict concurrency (data-race safety, @MainActor default isolation), SwiftUI (iOS 18/26 features, @Observable, MeshGradient, @Entry), SwiftData with #Index and Repository pattern, Swift Testing (@Test, #expect, parameterized), accessibility (Dynamic Type, VoiceOver), performance (Instruments, lazy views), security (Keychain/ATS), and quality gates (SwiftLint, unit/UI tests ≥80% coverage).

macOS engineer enforcing Swift 6.x/SwiftUI best practices: multi-window and document workflows, comprehensive keyboard shortcuts, sandboxing and notarization, Liquid Glass design (macOS 26 Tahoe), accessibility (VoiceOver, semantics, focus order), performance (Instruments, ≤16ms frame budget), Swift Testing, and quality gates (SwiftLint, unit/UI tests ≥80% coverage, localization).

Expert planning specialist for complex features and refactoring. Use PROACTIVELY when users request feature implementation, architectural changes, or complex refactoring. Automatically activated for planning tasks.

Orchestrates architecture-agent and ui-ux-designer for holistic software design. Use when features require both backend architecture and UI/UX design decisions that must be coordinated together.

Consolidated QA agent for specification-first planning and execution: writes and runs unit/integration tests, coordinates build integration, enforces deterministic re-runs, tracks coverage, and provides actionable feedback across CLI, Desktop UI, and Web apps.

Dead code cleanup and consolidation specialist. Use PROACTIVELY for removing unused code, duplicates, and refactoring. Runs analysis tools (knip, depcheck, ts-prune) to identify dead code and safely removes it.

Produce concise, implementation-ready requirements with structured questioning (Design Thinking, 5 Whys, JTBD), clear acceptance criteria, downstream needs, and enforceable quality gates.

Conduct comprehensive research on best practices, documentation, and patterns before implementation. Uses search-agent for retrieval and synthesizes findings into actionable recommendations.

Rust engineer enforcing Edition 2024 (1.85+), native async fn in traits, async closures, let chains, trait upcasting, Axum 0.8 (brace path syntax), thiserror 2.x, Tokio 1.49+, LazyLock (no lazy_static), structured tracing, performance (divan/criterion, flamegraphs), platform isolation (cfg guards), and strict quality gates (cargo fmt/clippy -D warnings, zero unsafe without safety docs, tests ≥80% coverage).

Perform intelligent multi-source search with query expansion, parallel retrieval, re-ranking, and strict citation tracking. Use for comprehensive research across code, documentation, academic papers, and web resources.

Security vulnerability detection and remediation specialist. Use PROACTIVELY after writing code that handles user input, authentication, API endpoints, or sensitive data. Flags secrets, SSRF, injection, unsafe crypto, and OWASP Top 10 vulnerabilities.

Write technical specifications, implementation plans, and task lists. Requires and cross-references documents from super-dev:requirements-clarifier, super-dev:research-agent, super-dev:debug-analyzer, super-dev:code-assessor, super-dev:architecture-agent, and super-dev:ui-ux-designer.

Test-Driven Development specialist enforcing write-tests-first methodology. Use PROACTIVELY when writing new features, fixing bugs, or refactoring code. Ensures 80%+ test coverage.

Produce concise, implementation-ready UI/UX specs: wireframes, tokens, interactions, accessibility, and responsiveness. Enforce quality gates and stick to proven patterns.

Windows engineer enforcing .NET 10/C# 14/WinUI 3 best practices: MVVM with DI (Host Builder), extension members, field keyword, async discipline (never block UI thread), accessibility (AutomationProperties, keyboard navigation), performance (≤16ms frame budget, high DPI, Native AOT), security (code signing), Windows App SDK 1.8, and executable quality gates (lint/style, unit/UI tests ≥80% coverage).

Perform multi-lens adversarial review to challenge implementation correctness, structural fitness, and necessity. Applies Skeptic, Architect, and Minimalist lenses with 7 attack vectors (V1-V7) and a Destructive Action Gate. Produces a verdict (PASS/CONTESTED/REJECT), NOT code modifications. Trigger on: "adversarial review", "challenge this code", "attack the implementation", "review for edge cases", "check for destructive actions", "stress test the design". Do NOT trigger on: standard code review (use code-review skill), simple linting, formatting checks, or documentation review.

Auto-improve any agent prompt using Karpathy's autoresearch method. Runs iterative test-measure-improve loops on agent prompts to systematically increase quality. Triggers on: "autoresearch", "auto-improve", "optimize agent", "tune prompt", "improve skill quality".

Safety guardrail that blocks destructive commands for the current session. Activate when working with production systems, sensitive data, or critical infrastructure. Triggers on: "be careful", "careful mode", "production mode", "safety mode". Blocks: rm -rf, DROP TABLE, TRUNCATE, DELETE FROM (no WHERE), git push --force, git reset --hard, git branch -D, kubectl delete, chmod 777, npm unpublish. Deactivate by ending the session.

Core development rules and philosophy. Use at the start of any development task to establish coding standards, git practices, and quality guidelines. Triggers on any implementation, fix, or refactoring task.

Directory freeze guardrail that restricts file edits to a specific directory for the current session. Activate when debugging or investigating to prevent accidental changes to unrelated code. Triggers on: "freeze mode", "lock directory", "restrict edits", "only edit in". Blocks Edit/Write operations outside the specified directory. Deactivate by ending the session.

Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.

Use when implementing features, fixing bugs, refactoring code, optimizing performance, resolving deprecations, or any multi-step development task requiring planning, implementation, testing, and review. Orchestrates specialized agent teammates through research, architecture, coding, QA, code review, and documentation phases. Triggers on: "implement", "build", "fix bug", "refactor", "add feature", "develop this", "help me build", "add functionality", "optimize performance", "resolve deprecation", "systematic development". Do NOT trigger on: simple questions ("what does this code do?"), file searches ("where is the auth function?"), one-off commands ("run the tests"), code explanations, quick edits, or non-development tasks.

Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests.

Verify that implemented features work correctly by driving browser/UI testing with screenshots and programmatic assertions. Uses Playwright MCP when available, falls back to CLI-based verification. Triggers on: "verify this works", "check the output", "test the UI", "verify the feature", "screenshot test", "visual verification", "does it actually work". Do NOT trigger on: unit test writing (use tdd-workflow), code review (use code-review), standard test runs ("run the tests").

10 hooks across 3 events