Real Time Communication Patterns
Use when designing or reviewing real-time communication — covers WebSocket lifecycle, Server-Sent Events, long polling, protocol selection, connection manager, horizontal scaling with Redis Pub/Sub, auth at upgrade, backpressure, and real-time anti-patterns with TypeScript and Go examples
Observability Patterns
Use when reviewing code for observability correctness — covers Structured Logging, Log Levels, Distributed Tracing, Metrics (counters/gauges/histograms), Health Checks, Alerting, Correlation IDs, and Audit Trails with red flags and fix strategies across TypeScript, Python, Java, and Go
Ai Ml Integration Patterns
Use when designing or reviewing AI/ML integration code — covers RAG pipeline design, prompt engineering, structured output with schema validation, tool use/function calling, LLM error handling, token budget management, hallucination mitigation, and AI/ML anti-patterns with examples in TypeScript and Python
Concurrency Patterns
Use when reviewing code for concurrency correctness — covers Race Conditions, Deadlocks, Thread Safety, Immutable Data, Producer-Consumer, Actor Model, Thread Pool, Async/Await pitfalls, Read-Write Locks, and Compare-and-Swap with red flags and fix strategies across TypeScript, Java, Go, and Python
Ai Generated Code Review
Use when reviewing LLM/AI-generated code — covers hallucinated APIs, plausible-but-wrong logic, authorization gaps, shallow error handling, over-abstraction, copy-paste context mismatch, missing edge cases, and outdated patterns with detection strategies and before/after examples in TypeScript, Python, and Go
Performance Anti Patterns
Use when reviewing a PR for performance regressions, when a service is slow under load, when database query times are spiking, or when CPU or memory usage is growing unexpectedly
Cpp Review Patterns
Use when reviewing C++ code — covers memory management and RAII, undefined behavior traps, template pitfalls, const correctness, move semantics, and common anti-patterns. C++ demands a specialized review lens because manual memory, implicit conversions, and template metaprogramming create failure modes invisible to reviewers trained primarily on GC languages. Load alongside review-accuracy-calibr…
Agent Orchestration Patterns
Use when designing or reviewing multi-agent systems — covers orchestration topologies (hierarchical, flat, pipeline, hybrid), task decomposition, parallel fan-out/fan-in execution, result aggregation, shared context propagation, agent communication protocols, failure handling, token economics, and anti-patterns with TypeScript examples
Database Review Patterns
Use when reviewing a PR that touches database queries, ORM usage, schema migrations, or data access layers, or when diagnosing slow queries, data integrity failures, or connection issues in production
I18n L10n Patterns
Use when building or reviewing internationalized applications — covers message externalization, ICU MessageFormat, CLDR plural rules, Intl.DateTimeFormat/NumberFormat, RTL layout with CSS logical properties, Intl.Collator for locale-correct sorting, translation workflow, pseudo-localization testing, and i18n anti-patterns across TypeScript and React
Detect Code Smells
Use when reviewing code for quality issues, when code feels hard to change or understand, when preparing for refactoring, or when a module has grown unwieldy
Caching Strategies
Use when designing or reviewing caching layers — covers cache-aside/read-through/write-through/write-behind patterns, cache stampede and thundering herd prevention, CDN caching with Cache-Control headers, eviction policies (LRU/LFU/TTL/adaptive), multi-layer cache architecture, cache invalidation strategies, and anti-patterns with red flags across TypeScript, Go, Python, and Redis CLI
Multi Tenancy Patterns
Use when designing or reviewing multi-tenant systems — covers tenant isolation strategies (RLS, schema-per-tenant, DB-per-tenant), tenant context propagation, tenant-aware caching, tenant lifecycle management, shared vs isolated infrastructure tradeoffs, and multi-tenant anti-patterns across TypeScript, Go, Python, and SQL/PostgreSQL
Agent Token Optimization Patterns
Use when designing or reviewing AI agent systems for cost and latency efficiency — covers context engineering (write/select/compress/isolate), prompt caching strategies, model routing by complexity, token budget management, context window techniques, prompt compression, and anti-patterns with TypeScript and Python examples
Developer Experience Patterns
Use when designing or reviewing developer tooling, monorepo structure, dev environments, onboarding flows, or internal platforms — covers Monorepo tooling (Nx/Turborepo), dev containers, golden path / platform engineering, local-prod parity, fast feedback loops, DX-first API design, developer onboarding, and DX anti-patterns with TypeScript, YAML, and Dockerfile examples
Agent Self Evaluation Patterns
Use when designing or reviewing AI agents that must assess their own output quality — covers confidence scoring and calibration, chain-of-thought reflection, LLM-as-judge, hallucination self-detection, output quality verification, eval-driven development, and self-evaluation anti-patterns with examples in TypeScript and Python
Agent Shared Values Patterns
Use when designing multi-agent systems that must share consistent rules, values, and constraints across all agents — covers layered inheritance models, the CLAUDE.md pattern, override resolution, consistency enforcement, value propagation in parallel agents, conflict detection, and anti-patterns with TypeScript and Python examples
Microservices Resilience Patterns
Use when designing or reviewing microservice architectures — covers Saga (choreography vs orchestration), Bulkhead, API Gateway, Circuit Breaker, Retry with Backoff, Fallback and graceful degradation, Health Probes, Service Mesh/Sidecar, and resilience anti-patterns (retry storm, cascading failure, thundering herd) with multi-language examples in TypeScript, Java, and Go
Error Handling Patterns
Use when reviewing code for error handling correctness — covers Result/Either types, Exception hierarchies, Error propagation, Retry with backoff, Circuit breaker, Fail-fast, Graceful degradation, Error boundaries, Null Object/Optional, and Dead Letter Queue with red flags and fix strategies across TypeScript, Go, Rust, Python, and Java
Api Rate Limiting Throttling
Use when designing or reviewing rate limiting implementations — covers Token Bucket, Leaky Bucket, Sliding Window Counter, Fixed Window Counter, distributed Redis-based limiting with Lua scripts, response headers, client-side throttling/backoff, and anti-patterns across TypeScript, Go, Python, and Redis Lua
Data Pipeline Patterns
Use when reviewing or designing data pipelines — covers ETL vs ELT, batch vs streaming vs micro-batch selection, idempotency, exactly-once delivery, watermarking, checkpointing, dead letter queues, backpressure, schema evolution, data contracts, pipeline orchestration and DAG design, with anti-patterns and red flags across Python, SQL, and TypeScript
Batch Job Patterns
Use when designing or reviewing batch processing systems — covers distributed locking for exclusive job execution, idempotent checkpoint/resume, heartbeat-based dead job detection, job scheduling strategies, graceful shutdown, retry and DLQ for failed items, batch size optimization, and common anti-patterns across TypeScript, Go, and Python
Design Patterns Creational Structural
Use when reviewing code for object creation problems or structural composition issues — covers all 12 GoF Creational (5) and Structural (7) patterns with intent, red flags, and refactoring cross-references
Data Validation Schema Patterns
Use when reviewing code for data validation correctness — covers validation boundary principle, TypeScript (Zod, Joi, io-ts), Python (Pydantic v2, marshmallow, dataclasses), Go (go-playground/validator), Java (Bean Validation / Hibernate Validator), schema evolution and compatibility, coercion vs strict parsing, custom validators, composable schemas, and validation anti-patterns with red flags an…
Python Review Patterns
Python-specific code review guide for AI reviewers. Covers mutable defaults, type hints, GIL and concurrency patterns, import anti-patterns, Pythonic idioms, and exception handling. Load alongside review-accuracy-calibration to calibrate confidence before posting Python findings.
Code Documentation Patterns
Use when writing or reviewing documentation — covers Architecture Decision Records (ADR), API documentation (OpenAPI/AsyncAPI/JSDoc/docstrings), README and runbook standards, inline comments, technical debt registers, and documentation anti-patterns with concrete examples and red flags across TypeScript, Python, Java, and Go
Pr Review Workflow
Use when starting a PR review and you need the end-to-end orchestration of all review skills into one complete workflow. This is the capstone skill that sequences every component skill into a principled, time-boxed process from PR load to verdict.
Graphql Grpc Api Patterns
Use when reviewing or designing GraphQL and gRPC APIs — covers schema design and evolution, N+1/DataLoader batching, subscriptions, Protobuf field numbering, gRPC streaming modes, breaking-change detection, anti-patterns, and code review signals across TypeScript, Go, and Java
Refactor Functional Patterns
Use when reviewing code for functional programming quality — covers Pure Functions, Immutability, Map/Filter/Reduce, Function Composition, Higher-Order Functions, Currying, Functors/Monads, and Pattern Matching with red flags and anti-patterns
Design Patterns Behavioral
Use when reviewing code for communication and responsibility problems between objects — covers all 11 GoF Behavioral patterns with intent, red flags, and refactoring cross-references
Domain Driven Design Patterns
Use when designing or reviewing domain models — covers Bounded Contexts, Context Mapping, Aggregate Root, Value Objects vs Entities, Domain Events, Ubiquitous Language, Repository pattern, Domain vs Application Services, and DDD anti-patterns (anemic domain model, feature envy) with examples in TypeScript, Java, Go, and Python
Pattern Detection Walkthroughs
Use when you need end-to-end examples of detecting a code smell, identifying the underlying anti-pattern, selecting a refactoring technique, and applying the appropriate design pattern — each walkthrough traces the full diagnostic flow with before/after TypeScript code
Language Specific Idioms
Use when reviewing code for language-specific correctness — covers idiomatic patterns, common anti-idioms, and code review red flags for TypeScript/JavaScript, Python, Java, Go, Rust, and C++, with before/after examples and a quick reference table
Event Sourcing Cqrs Patterns
Use when designing or reviewing systems that store state as an immutable sequence of events — covers Event Sourcing fundamentals, CQRS, projections and read models, snapshot strategy, aggregate replay, event schema evolution and upcasting, eventual consistency, idempotency, and anti-patterns across TypeScript, Java, and Go
Java Review Patterns
Use when reviewing Java code — covers null safety and Optional misuse, Stream API pitfalls, concurrency hazards (synchronized scope, CompletableFuture, ThreadLocal), resource management via try-with-resources, generics and type erasure traps, immutability patterns, and common Java anti-patterns. Load alongside review-accuracy-calibration to ensure findings are well-calibrated before posting comme…
Auth Authz Patterns
Use when reviewing or implementing authentication and authorization — covers OAuth2 grant flows (Authorization Code + PKCE, Client Credentials, Device Flow), OpenID Connect (OIDC) and ID tokens, JWT best practices, RBAC and ABAC policy design, service-to-service authentication (mTLS, workload identity, API keys), session management security, and auth anti-patterns across TypeScript, Go, Java, and…
Anti Patterns Catalog
Use when reviewing architecture or design for structural problems, when a codebase is hard to change or extend, when onboarding to a legacy system, or when recurring bugs suggest a deeper design flaw
Refactor Composing Methods
Use when methods are too long, contain duplicate code, or have complex expressions that need simplification — covers Extract Method, Inline Method, Extract Variable, and 6 more techniques
Feature Flags Progressive Delivery
Use when designing or reviewing feature flag systems, progressive delivery pipelines, A/B testing infrastructure, or rollout strategies — covers feature toggles, canary/blue-green/ring deployments, percentage rollouts, kill switches, flag lifecycle, targeting rules, user segments, experiment design, and anti-patterns with TypeScript examples
Migration Patterns
Use when planning or reviewing monolith decomposition, service extraction, or database migration — covers Strangler Fig, Anti-Corruption Layer, Branch by Abstraction, Database Decomposition (Expand-Contract, dual-write), Change Data Capture (Debezium, AWS DMS), and migration anti-patterns across TypeScript, Go, and Java
Cross Language Review Heuristics
Universal code review patterns that apply across all languages. Use this skill when reviewing code regardless of the implementation language — covers naming clarity, complexity thresholds, dependency direction, test quality, error handling, and documentation. Load alongside a language-specific skill (go-review-patterns, python-review-patterns, typescript-review-patterns, rust-review-patterns, jav…
Message Queue Patterns
Use when designing or reviewing event-driven systems — covers Point-to-Point vs Pub/Sub, Competing Consumers, delivery guarantees (at-most-once, at-least-once, exactly-once), Transactional Outbox, Dead Letter Queues, Kafka partition design and consumer groups, message ordering and idempotency, backpressure, and messaging anti-patterns across TypeScript, Java, and Go
Cicd Pipeline Patterns
Use when designing or reviewing CI/CD pipelines — covers pipeline design (stages, jobs, parallelism), GitOps and IaC patterns, build optimization (caching, incremental builds, artifact management), deployment strategies (blue-green, canary, rolling update, recreate), security in pipelines (SLSA, SBOM, supply chain, secrets management), testing in pipelines (shift-left, test pyramid, flaky test ma…
File Upload Media Patterns
Use when designing or reviewing file upload and media processing systems — covers presigned URL direct-to-storage uploads, resumable uploads (tus/S3 multipart), upload security pipeline (MIME magic bytes, virus scanning, quarantine), async media processing (thumbnails, transcoding, webhooks), image optimization (WebP/AVIF, responsive images, CDN transforms), storage abstraction layer, content-add…
Go Review Patterns
Use when reviewing Go code — covers goroutine leak detection, context propagation rules, error handling patterns (sentinel vs typed vs wrapped), slice/map pitfalls, interface design, nil traps, and common anti-patterns. Load alongside review-accuracy-calibration to ensure findings are well-calibrated before posting comments.
Container Kubernetes Patterns
Use when designing, reviewing, or debugging Kubernetes workloads — covers health probe design, resource requests vs limits, autoscaling (HPA/KEDA/VPA), PodDisruptionBudget and graceful shutdown, workload RBAC isolation, configuration injection, and container anti-patterns (CrashLoopBackOff, OOMKilled, Pending, fat images, root containers)
Agent Memory Patterns
Use when designing or reviewing AI agent memory systems — covers memory type taxonomy (short-term, working, long-term), episodic vs semantic vs procedural memory, embedding-based retrieval with recency and importance weighting, memory compression and consolidation, cross-agent memory sharing, and anti-patterns like infinite context stuffing and stale memory poisoning, with examples in TypeScript…
Distributed Tracing Patterns
Use when instrumenting distributed systems or reviewing tracing code — covers OpenTelemetry auto and manual instrumentation, span design, context propagation (W3C TraceContext, B3), sampling strategies (head, tail, probabilistic, rate-limiting), trace-based testing, exemplars, and anti-patterns (over-instrumentation, missing context, span explosion) across TypeScript, Go, Java, and Python
Architectural Patterns
Use when reviewing code for architectural boundary violations, dependency direction errors, or layer coupling issues — covers 10 architectural patterns with invariants, violation signals, and dependency diagrams
Dependency Injection Module Patterns
Use when reviewing code for dependency coupling problems or module organisation issues — covers 6 DI patterns (Constructor, Property, Method, Interface, Service Locator, DI Container), Composition Root, Module/Package organisation, and a catalogue of DI anti-patterns with multi-language examples