@anderskev

remix-v2-data-flow-review audits remix v2 route modules for loader/action anti-patterns, data leaks, validation gaps, and v1 migration holdovers. provides a checklist, scoping rules, hard gates for evidence, and context-sensitive flagging rules.

remix-v2-perf-ssr covers http caching via headers export, streaming with defer and await, server-client split via file conventions, prefetching modes, and hydration safety patterns. includes decision trees for defer vs await, .server.ts naming, and link prefetch selection.

remix-v2-forms covers form submissions, mutations, and fetcher patterns for remix v2 route handlers. includes decision trees for choosing between form/fetcher, handling optimistic ui, file uploads, and intent-based multi-action routes.

review-verification-protocol establishes mandatory checks before code review verdicts, emphasizing artifact echoing, sequential hard gates, and issue-type-specific false positive prevention. enforces severity calibration and contextual validity patterns to reduce reviewer hallucination.

review-feedback-schema defines a csv-based log format for tracking code review outcomes with structured verdict types, gating rules, and rationale requirements. designed to feed skill improvement workflows by capturing both accept/reject decisions and their justifications.

remix-v2-routing covers flat-routes v2 file naming conventions, nested layouts, dynamic segments, resource routes, and decision trees for choosing between layout patterns. concrete examples anchor each pattern.

remix-v2-data-flow covers loaders, actions, deferred responses, and pending state transitions with concrete examples, type annotation patterns, and decision trees for when to use each API.

remix-v2-meta-sessions covers document head management, cookie session storage with secure defaults, auth gating via loader/action throws, and csrf protection patterns. includes decision trees for routing meta tags and validates common v1 migration pitfalls.

rust-project-setup covers scaffolding new rust projects with cargo configuration, workspace organization, linting setup, and ci integration. includes edition 2024 migration notes and objective completion gates for validating setup correctness.

rust-best-practices delivers guidance on idiomatic code patterns, error handling, performance profiling, and api design across ownership, generics, async, and ecosystem choices. organized by topic with gates for clippy and performance claims.

humanize-beagle rewrites ai-generated developer text by applying categorized fixes (vocabulary, filler, tone, formatting) identified by a prior review run. includes dry-run preview, safety gates on git state and file validation, and interactive confirmation for risky rewrites.

remix-v2-perf-ssr-review is a specialized audit for remix v2 routes, targeting caching headers, server/client boundary enforcement, hydration safety, prefetch strategy, and asset optimization. structured around a checklist and hard-gate verification protocol.

remix-v2-forms-review flags violations of remix v2 form patterns: manual fetch(), native form misuse, wrong hook choice, missing pending state, unbounded uploads, and intent-pattern breaks. designed as a linter complement to a canonical pattern skill.

deepagents-implementation covers agent creation via create_deep_agent with pluggable backends, subagent delegation, middleware injection, streaming modes, human-in-the-loop interrupts, and mcp tool integration.

review-remix-v2 orchestrates parallel or sequential code review across six remix-specific domains, detects framework presence and tech surface via grep, loads domain skills, and gates findings against a verification protocol before reporting.

ffi-code-review examines rust ffi code across type safety, memory layout, string handling, callbacks, and unsafe boundaries. it uses a gated verification workflow to prevent premature findings and includes a detailed checklist covering extern blocks, symbol management, type layout, ownership, and bindgen patterns.

review-tui orchestrates multi-technology code review for bubbletea terminal applications by loading specialized skills conditionally, enforcing gated verification steps, and consolidating findings across go quality, elm architecture patterns, lipgloss styling, and ssh server concerns in a single pass.

bubbletea-code-review enforces elm architecture patterns and detects blocking i/o in update functions through hard gates and reference-backed checklist. targets charmbracelet tui code with focus on model immutability, command composition, and lipgloss styling discipline.

prfaq-beagle pressure-tests product concepts against amazon's working backwards framework, running them through five sequential stages (ignition, press release, customer faq, internal faq, verdict) with hard gates and companion grounding. produces a binary pass/fail verdict with targeted feedback on failure.

respond-pr-feedback posts evaluated replies to pr review comments, with optional thread resolution. requires prior execution of fetch-pr-feedback and enforces sequenced gate checks before API calls.

review-skill audits pr changes to agent skills against structural validity, design quality, and marketplace consistency rules. executes diffs, applies three check suites, verifies findings, and outputs categorized issues with confidence ratings.

review-go orchestrates multi-technology Go code review by detecting bubbletea, wish ssh, and prometheus, then loading domain-specific skills. sequential or parallel execution with mandatory verification gates before reporting findings.

review-frontend orchestrates parallel or sequential code review across react, remix, routing, state, and styling layers by detecting technologies and dispatching to specialized skills. includes verification gates and single-pass completeness rules.

create-pr-skip generates pull requests with standardized descriptions by gathering branch context, analyzing changes, and applying conventional commit formatting with optional label assignment.

llm-artifacts-detection provides four focused detection agents for identifying common quality issues in ai-generated code, spanning tests, dead code, over-abstraction, and style patterns. structured around specific reference criteria and reporting gates to minimize false positives.

review-llm-artifacts detects lsm coding agent artifacts across four categories (tests, dead code, abstraction, style) with parallel subagents when supported, scanning changed files by default or full project with --all flag, producing a structured json report and markdown summary.

prompt-improver refines code prompts by auditing six dimensions (clarity, investigation, verification, context, specificity, scope) and applying templated transformations. gates enforce rigor but the skill lacks failure mode recovery.

fetch-pr-feedback retrieves unresolved review comments from a pull request, filters by author and thread status via flags, strips formatting noise, groups feedback by reviewer, then delegates evaluation to the receive-feedback skill.

sqlx-code-review provides a structured checklist for auditing rust database code against compile-time safety, pool management, and migration practices. procedure relies on gates and external references but lacks actionable examples and explicit failure recovery steps.

remix-v2-routing-review flags structural route violations (naming, layouts, resource shapes, v1 artifacts) in remix v2 codebases. extensive checklist and exemption rules, but procedure lacks step-by-step invocation logic.

agent-architecture-analysis audits agentic systems against 12-factor methodology via structured codebase scanning, evidence collection, and per-factor compliance scoring. covers prompt ownership, state management, tool validation, and control flow patterns with explicit hard gates before assigning ratings.

tokio-async-code-review provides a structured review workflow for async runtime patterns, task management, and synchronization primitives with explicit gate checks and severity calibration. covers 2024 edition changes and common pitfalls but lacks actionable trigger phrases and specific integration examples.

review-rust dispatches comprehensive code analysis across detected technology areas (tokio, axum, sqlx, serde, macros, ffi, concurrency, testing), with hard gates for scope, compiler output, and evidence verification before reporting findings.

rust-code-review covers ownership, borrowing, lifetimes, error handling, traits, unsafe code, and concurrency via a gated workflow with edition-aware checklists. execution depends on loading external references and applying severity calibration before submitting findings.

fix-llm-artifacts applies fixes from a prior review run, respecting safe/risky classification and optional verification overlays to suppress false positives. depends on review-llm-artifacts output and requires explicit user confirmation for destructive changes.

axum-code-review provides a checklist-driven inspection of axum web services covering routing, extractors, state, and error handling, with version-specific guidance for 0.6/0.7+ and edition 2024. gating mechanism ensures findings are evidence-backed before reporting.

swift-testing-code-review validates Swift Testing patterns including expect/require macros, parameterized tests, async handling, and suite organization. enforces checklist discipline via external protocol linkage and reference documents.

deepagents-code-review catalogs 23 specific anti-patterns in deep agents configuration, backends, subagents, middleware and system prompts, with code examples for each. coverage is comprehensive but procedure for applying findings lacks step-by-step rigor, and trigger phrases are absent entirely.

elixir-security-review provides a checklist-based vulnerability scanner for elixir code focusing on injection, atom exhaustion, and secrets. execution requires external verification protocol and manual ingress mapping.

urlsession-code-review provides a checklist and hard gates for auditing ios networking code, but lacks step-by-step procedure. the gates structure is novel but underspecified, and many checks lack actionable remediation detail.

review-plan enforces artifact verification and gated execution of five review lenses (parallelization, tdd, types, libraries, security) against implementation plans, but lacks concrete trigger phrases, assumes subagent availability without fallback, and conflates procedural gating with actual review rigor.

review-structure defines a demanding structural-review discipline with strong principles but no actionable procedure. it reads as a manifesto and rubric rather than a skill a reviewer can execute step-by-step.

Analyzes feedback logs to identify patterns and suggest improvements to review skills. Use when you have accumulated feedback data and want to improve review...

Reviews LangGraph code for bugs, anti-patterns, and improvements. Use when reviewing code that uses StateGraph, nodes, edges, checkpointing, or other LangGra...

Use when the user wants a cited, structured read of local documents and project knowledge. Triggers on: "analyze these docs", "scan my project for context",...

Use when comparing two or more code implementations against a spec or requirements doc. Triggers on "which repo is better", "compare these implementations",...

Use when the user wants to build or think through a strategy via guided conversation — for a company, product, team, career, or initiative. Triggers on "help...

Use when reviewing, critiquing, or stress-testing an existing strategy document. Evaluates seven dimensions — diagnosis quality, guiding policy strength, act...

commit and push all local changes to remote repo

generate release notes for changes since a given tag

Process external code review feedback with technical rigor. Use when receiving feedback from another LLM, human reviewer, or CI tool. Verifies claims before...

Detect AI-generated writing patterns in developer text — docs, docstrings, commit messages, PR descriptions, and code comments. Use when reviewing any text a...

Comprehensive Elixir/Phoenix code review with optional parallel agents

Comprehensive iOS/SwiftUI code review with optional parallel agents

Comprehensive Python/FastAPI backend code review with optional parallel agents

Reviews Remix v2 code for v1-shape meta exports (BREAKING in v2), cookie security gaps (httpOnly, secure, secrets rotation), auth gates in wrong layer, and m...

Reviews Rust macro code for hygiene issues, fragment misuse, compile-time impact, and procedural macro patterns. Use when reviewing macro_rules! definitions,...

Reviews Rust test code for unit test patterns, integration test structure, async testing, mocking approaches, and property-based testing. Covers Rust 2024 ed...

Reviews serde serialization code for derive patterns, enum representations, custom implementations, and common serialization bugs. Use when reviewing Rust co...

Analyze repo, detect stack, trace changes to user-facing entry points, generate E2E YAML test plan

Execute YAML test plan, stop on first failure, output rich debug prompt

Reviews Remix v2 error-handling code for the unified ErrorBoundary, isRouteErrorResponse narrowing, throw-vs-return, root boundary scaffolding, and v1 holdov...