johnkozaris

peekaboo

Drive, observe, and critique a running native macOS app (SwiftUI/AppKit) end-to-end via Peekaboo — the macOS-native equivalent of Playwright + visual-regression review. Use when the user mentions the Mac app's UI, screens, screenshots, appearance, layout, accessibility identifiers, clicking, typing, or menus — or says 'see what it looks like', 'show me the UI', 'click X', 'take a screenshot of the app', 'critique the design', 'drive the app'. Use after a SwiftUI/AppKit edit or rebuild, and before claiming a UI feature done. NOT for Electron or web apps (use the electron-playwright validator), NOT for iOS simulators (use the Maestro validator), NOT for purely backend work. Screenshots go to disk and each one is read by a separate same-model sub-agent, so the driver's context never fills with pixels; no external AI keys are used.

seam-probe

Use this skill to test, validate, fuzz, or debug a process boundary ("seam") that exposes itself as an FFI dynamic library or a Unix-domain socket — for example probing a Rust runtime hosted in a Swift or Electron app via its C ABI, or sending crafted length-prefixed frames to a daemon's UDS endpoint. The skill teaches how to drive the probe from the CLI, capture both the probe's NDJSON output AND the system- under-test's stderr/logs, and triage failures by correlating the two streams. Reach for it when the user asks to "probe", "fuzz", "exercise", "test the FFI surface", "test the socket protocol", "send raw frames", "discover what a dylib exports", "find a bug in the runtime", "reproduce a crash", or "see why the seam panics or hangs".

API & Backend Solid

backend-validation

Use this skill when validating a backend API or WebSocket endpoint end-to-end, including acquiring an OIDC bearer token for authenticated calls. Trigger whenever the user asks to test/validate/smoke-check a backend, write a Hurl test, hit a WebSocket, acquire an access token, exercise an OIDC flow, debug a 401, or verify an endpoint works with real auth. Applies to projects that use Hurl for HTTP tests, websocat for WebSocket probes, and oauth2c or curl-based flows for token acquisition (Authentik, Keycloak, Okta, Auth0, any RFC 6749 / OIDC Core provider). Prefer this skill over ad-hoc curl + bash when the user has more than one endpoint to check, chained auth flows, or anything resembling a regression test — because the Hurl + cached-refresh-token pattern is 10× less code and survives the next session.

AI & Automation Solid

claude-mastery-expert

This skill should be activated when the user wants to build an agent, design tools for an agent, write skills, structure a CLAUDE.md, optimize prompt caching, set up worktrees, use subagents, design verification loops, write hooks, structure a project for Claude Code, or improve their Claude Code workflow. Relevant when the user says "how should I structure this", "write a skill for", "design this agent", "optimize for caching", "set up verification", "use subagents", "parallel development", "write a CLAUDE.md", "improve my workflow", "design tools", "build an agent", "context engineering", or "autonomous research".

dead-code-expert

This skill should be used when the user wants to find, audit, or remove dead code, unused imports, unused functions, unused variables, duplicate implementations, parallel/split-brain implementations across architectural boundaries, dead assets/configuration/infrastructure, or simplify a codebase. Works across all programming languages and stacks (SwiftUI, Rust, TypeScript/React, .NET, Python, C++, Go, Java). Relevant when the user says "find dead code", "remove dead code", "remove unused imports", "find duplicate code", "split brain", "parallel implementations", "client server validation drift", "dead config", "orphan assets", "unused environment variables", "simplify this codebase", "find unused functions", "find unused code", "remove commented out code", "what code is unused", "find orphaned files", "detect duplicate implementations", "find unreachable code", "clean up this codebase", or "audit for unused code".

API & Backend Solid

dotnet-backend-expert

This skill should be used when the user is writing, reviewing, debugging, or architecting pure .NET backend code for Kestrel-hosted services. It provides expert critique for REST endpoints, real-time transports (SignalR, raw WebSockets, Server-Sent Events), TypeScript/React client integration shape, pragmatic Rust interop, application services, project structure, EF Core and database boundaries, dependency injection lifetimes, OOP and SOLID quality, concurrency, and distributed-architecture tradeoffs. Use when the user asks "critique my .NET backend", "review my ASP.NET Core API", "review this service", "should this be singleton or scoped", "structure my solution", "review my SignalR hub", "should I use SignalR or WebSockets or SSE", "is this clean architecture", "should I use repositories", "fix my DbContext usage", "design my REST endpoints", "review my concurrency", or "should this be microservices".

Testing & QA Solid

electron-playwright-validator

Validate Electron desktop app UI using Playwright automation via the e-cli tool. Use when testing Electron app UI, validating after code changes, checking if tabs render, clicking through UI flows, taking screenshots for visual review, or debugging runtime import errors that typecheck doesn't catch. Works with any Electron project that has @playwright/test and electron in devDependencies. Use when the user asks "validate the electron app", "check the UI", "click through the app", "take a screenshot", "does the app render", "test the electron UI", "launch the app and check", "verify the app works", "is the app broken", or "debug a runtime error". NOT for native macOS (SwiftUI/AppKit) apps — use the peekaboo macOS validator — and NOT for mobile apps (use the Maestro validator).

esp32-expert

This skill should be used when the user is writing, reviewing, debugging, or architecting C++ firmware for ESP32 and variants (ESP32-S2, S3, C3, C5, C6, H2, P4) using ESP-IDF or PlatformIO. Provides expert critique covering FreeRTOS task design, memory management (IRAM/DRAM/PSRAM), peripheral drivers (I2C/SPI/UART/GPIO), build systems (CMake/platformio.ini), power management, OTA updates, and embedded C++ best practices. Use when the user asks "review my ESP32 code", "fix FreeRTOS crash", "optimize memory usage", "debug I2C issue", "set up PlatformIO project", "review my CMakeLists", "search datasheet for this chip", "why is my task crashing", "configure deep sleep", or "help with ESP-IDF component structure".

Testing & QA Solid

mobile-flows-maestro

Use this skill when writing or running Maestro flows for iOS or Android apps, driving the Maestro MCP server, diagnosing flaky mobile UI tests, or onboarding a new team to mobile e2e testing. Trigger whenever the user mentions Maestro, mobile e2e testing, iOS Simulator flows, Android emulator flows, "test my iOS app", "test my Android app", YAML test flows, GraalJS test scripting, assertVisible / tapOn / launchApp, deep links from tests, or "why is my Maestro test flaky". NOT for web, desktop, or backend testing — those have their own validators. Applies to Swift/SwiftUI, React Native, Flutter, Kotlin, Java, .NET MAUI, Ionic, and Capacitor apps. Prefer this skill over letting Claude write Maestro flows from scratch — Maestro YAML looks deceptively simple but has many platform-specific gotchas (GraalJS constraints, iOS Keychain persistence, ASWebAuthenticationSession system sheets, permission timing) that first-drafts get wrong.

python-backend-expert

This skill should be used when the user is writing, reviewing, debugging, or architecting Python backend services (FastAPI + SQLAlchemy 2.0 async + Pydantic v2) or long-running runtime processes (workers, ETL, daemons, CLI tools). Assumes Python 3.13+/3.14; detects installed libraries from pyproject.toml/uv.lock and adapts. Covers async correctness, dependency injection with Annotated[T, Depends], N+1 and MissingGreenlet, lifecycle and graceful shutdown, signals/subprocess/atomic writes, project structure, validation, testing, and AI-generated anti-patterns. Trigger phrases include "critique my FastAPI backend", "why am I getting MissingGreenlet", "is this blocking the event loop", "fix N+1 query", "structure my FastAPI project", "review my Pydantic models", "write a Python worker", "subprocess deadlock", and "process keeps growing in memory". Not for Django or Flask apps, notebooks, or data-science scripts — those stacks have different idioms this skill would misapply.

rust-expert

This skill should be used when the user is writing, reviewing, debugging, or architecting Rust code. Detects edition and toolchain from the project. Provides expert critique covering ownership, error handling, unsafe review, async correctness, trait design, type system patterns, performance, SOLID principles, and Cargo/workspace practices. Use when the user asks "critique my Rust code", "review this module", "fix borrow checker error", "is this unsafe sound", "design error types", "optimize this function", "review async code", "structure my workspace", "why is the borrow checker complaining", "help with lifetimes", "make this more idiomatic", or "review my Cargo.toml".

swiftui-expert

This skill should be used when the user is building, reviewing, or debugging SwiftUI/Swift code for iOS, macOS, or visionOS apps. It detects the project's iOS and Swift version and covers MV architecture (no per-screen ViewModels by default), @Observable state, NavigationStack typed routes, view lifecycle, Approachable Concurrency, persistence (SwiftData / Core Data / SQLiteData / GRDB), design tokens, selective Liquid Glass adoption, iOS and macOS platform capabilities, accessibility, performance with Instruments SwiftUI, and Swift Testing. Trigger phrases include "review my SwiftUI code", "my @State isn't updating", "should I adopt Liquid Glass", "fix my Swift concurrency warning", "set up SwiftData", "what should App.swift own", "ObservableObject to @Observable", "should I use MVVM in SwiftUI", "do I need TCA", and "AppKit or SwiftUI for my Mac app". For driving/screenshotting a RUNNING app use the peekaboo validator; for dead-code hunts use the dead-code plugin.