wshobson/agents▌

Modern Python tooling, naming conventions, type checking, and documentation standards for maintainable codebases. \n \n Configure ruff for unified linting and formatting, replacing flake8, isort, and black with a single fast tool \n Set up strict type checking with mypy or pyright to catch errors before runtime \n Follow PEP 8 naming conventions: snake_case for functions/variables, PascalCase for classes, SCREAMING_SNAKE_CASE for constants \n Write Google-style docstrings for all public APIs wit

Fundamental design principles for writing maintainable, testable Python code. \n \n Covers five core patterns: KISS (Keep It Simple), Single Responsibility Principle, Separation of Concerns, Composition Over Inheritance, and the Rule of Three \n Includes practical code examples contrasting anti-patterns with recommended approaches for each principle \n Provides layered architecture guidance (API, Service, Repository layers) with dependency injection patterns for testability \n Emphasizes explici

Profile and optimize Python code using cProfile, memory profilers, and performance best practices. \n \n Covers CPU profiling with cProfile, line-by-line profiling with line_profiler, memory tracking with memory_profiler, and production profiling with py-spy \n Includes 20+ optimization patterns: list comprehensions, generators, string concatenation, dictionary lookups, NumPy vectorization, caching, multiprocessing, and async I/O \n Provides database optimization techniques including batch opera

Comprehensive guide to designing distributed systems with service boundaries, communication patterns, and resilience strategies. \n \n Covers service decomposition by business capability and domain-driven design, with the Strangler Fig pattern for gradual monolith migration \n Includes synchronous (REST, gRPC) and asynchronous (Kafka, message queues) communication patterns with event-driven architecture examples \n Provides Saga pattern implementation for distributed transactions with compensati

Master SQL query optimization, indexing strategies, and EXPLAIN analysis to eliminate slow queries. \n \n Covers EXPLAIN plan analysis with key metrics (Seq Scan, Index Scan, cost, rows, execution time) and five index types (B-Tree, Hash, GIN, GiST, BRIN) for different query patterns \n Includes five core optimization patterns: eliminating N+1 queries, cursor-based pagination, efficient aggregation, subquery transformation, and batch operations \n Provides advanced techniques like materialized v

Efficient, scalable monorepos with optimized builds and shared dependencies across multiple packages. \n \n Covers three major tools: Turborepo (recommended for most projects), Nx (feature-rich alternative), and pnpm workspaces (package manager) \n Includes setup patterns for shared configurations (TypeScript, ESLint, Prettier), code sharing strategies (UI components, utilities, types), and dependency management across packages \n Provides Turborepo pipeline configuration with caching, input/out

Production-ready Grafana dashboards for system and application metrics visualization. \n \n Covers RED method (Rate, Errors, Duration) for services and USE method (Utilization, Saturation, Errors) for resources \n Supports multiple panel types including stat panels, time series graphs, tables, and heatmaps with Prometheus queries \n Includes templating with query variables for dynamic filtering by namespace, service, and other dimensions \n Provides dashboard provisioning via YAML configuration

High-performance game development with Unity's data-oriented Entity Component System, Jobs, and Burst Compiler. \n \n Covers core ECS patterns including components, systems, entities, and archetypes, with practical examples for movement, spawning, damage, and inventory management \n Demonstrates both simple foreach queries and explicit job scheduling with IJobEntity and IJobChunk for fine-grained parallelization control \n Includes baking workflows to convert GameObjects to entities, singleton m

CSS-first design system framework for Tailwind v4 with tokens, components, and responsive patterns. \n \n Migrates configuration from tailwind.config.ts to CSS @theme blocks with native CSS variables, OKLCH color spaces, and @custom-variant for dark mode \n Provides production-ready component patterns including CVA-based variants, compound components, form controls, grids, and animations using native @keyframes and @starting-style \n Includes design token hierarchy (brand → semantic → component)

$22

Material Design 3 and Jetpack Compose patterns for building modern, adaptive Android applications. \n \n Covers Material Design 3 components (cards, buttons, navigation, text fields, dialogs) with dynamic color theming and tonal palettes for accessibility \n Provides Jetpack Compose layout patterns including Column/Row, LazyColumn/LazyVerticalGrid, and adaptive layouts for phones, tablets, and foldables \n Includes navigation implementations for bottom navigation, navigation drawers, and Navigat

Production-ready Kubernetes manifests for Deployments, Services, ConfigMaps, Secrets, and PersistentVolumeClaims. \n \n Covers eight core resource types with step-by-step guidance: Deployments with health checks and resource limits, Services (ClusterIP, LoadBalancer, NodePort), ConfigMaps, Secrets, PersistentVolumeClaims, security contexts, labels, and multi-resource organization \n Includes security best practices such as running as non-root, dropping capabilities, read-only filesystems, and Po

Clear module boundaries, explicit public interfaces, and maintainable directory layouts for Python projects. \n \n Define public APIs with __all__ in every module; unlisted members remain internal implementation details \n Prefer flat directory structures with minimal nesting; add sub-packages only for genuine sub-domains \n Organize by architectural layers (API, services, repositories, models) or business domains depending on project complexity \n Keep files focused on a single concept; conside

Comprehensive guide for selecting, implementing, and optimizing embedding models for vector search and RAG applications. \n \n Covers 10+ embedding models with dimensions, token limits, and domain specialization (Voyage AI, OpenAI, open-source options for code, finance, legal, and multilingual content) \n Provides four chunking strategies: token-based, sentence-based, semantic sections, and recursive character splitting with overlap handling \n Includes three implementation templates for Voyage

Production-ready React Native patterns with Expo, navigation, offline-first architecture, and native module integration. \n \n Covers Expo Router for file-based navigation, authentication flows with secure token storage, and route protection patterns \n Includes offline-first data sync using React Query with AsyncStorage persistence and online status detection \n Demonstrates native module integration for haptics, biometrics, push notifications, and platform-specific code patterns \n Provides pe

Advanced Git history management with rebasing, cherry-picking, bisect, worktrees, and reflog recovery. \n \n Interactive rebase enables commit squashing, rewording, reordering, and dropping to clean history before merging \n Cherry-pick applies specific commits across branches; bisect uses binary search to find commits that introduced bugs \n Worktrees allow simultaneous work on multiple branches without stashing or switching contexts \n Reflog tracks all ref movements and recovers deleted commi

Design and implement append-only event stores for event-sourced systems. \n \n Covers architecture patterns, technology comparison (EventStoreDB, PostgreSQL, Kafka, DynamoDB), and core requirements including append-only semantics, ordering, versioning, and subscriptions \n Includes production-ready PostgreSQL schema with indexing strategy, snapshots table, and subscription checkpoints for managing consumer state \n Provides Python event store implementation with optimistic concurrency control, s

Cross-platform mobile apps with React Native styling, navigation, and performant Reanimated animations. \n \n Covers StyleSheet patterns, dynamic styling, Flexbox layouts, and platform-specific designs for iOS and Android \n Includes React Navigation 6+ setup for stack and tab navigators with type-safe route definitions \n Provides Reanimated 3 fundamentals including shared values, animated styles, and Gesture Handler integration for drag interactions \n Features best practices for performance (

Production-ready patterns for Apache Airflow DAGs, operators, sensors, testing, and deployment. \n \n Covers DAG design principles (idempotent, atomic, incremental, observable) with task dependency patterns for linear, fan-out, fan-in, and complex workflows \n Includes TaskFlow API decorators for cleaner code with automatic XCom passing, dynamic DAG generation from configs, and branching with conditional logic \n Provides sensor patterns for S3 files, external task dependencies, and custom senso

Structured approach to migrating AngularJS applications to modern Angular with hybrid mode support. \n \n Three migration strategies: Big Bang (complete rewrite), Incremental (hybrid side-by-side), and Vertical Slice (feature-by-feature), each suited to different app sizes and delivery constraints \n Hybrid app setup using ngUpgrade to run AngularJS and Angular simultaneously, enabling gradual feature migration without full rewrites \n Component, service, routing, and forms migration patterns wi

Comprehensive testing strategies for Python using pytest, fixtures, mocking, and test-driven development. \n \n Covers unit, integration, functional, and performance testing with the AAA pattern (Arrange, Act, Assert) for test structure \n Includes 10 fundamental and advanced patterns: basic tests, fixtures with setup/teardown, parameterization, mocking, exception handling, async testing, monkeypatching, temporary files, custom fixtures, and property-based testing \n Provides test design princip

Production-ready GDScript patterns for Godot 4 game architecture, state management, and performance optimization. \n \n Covers seven core patterns: state machines, autoload singletons, resource-based data, object pooling, component systems, scene management, and save systems with complete working examples \n Includes best practices for signal-based decoupling, static typing, caching node references, and avoiding allocations in hot paths \n Demonstrates performance optimization techniques like ob

Memory-safe programming patterns for RAII, ownership, smart pointers, and resource management across Rust, C++, and C. \n \n Covers six core memory bug categories (use-after-free, double-free, leaks, buffer overflow, dangling pointers, data races) with language-specific prevention strategies \n Provides RAII patterns in C++ with destructors, lock guards, and transactions; smart pointer guidance (unique_ptr, shared_ptr, weak_ptr) with custom deleters \n Implements Rust ownership, borrowing, lifet

Advanced prompt engineering techniques for optimizing LLM performance, reliability, and structured outputs in production. \n \n Covers six core capability areas: few-shot learning with dynamic example selection, chain-of-thought reasoning with self-consistency, structured outputs via JSON and Pydantic schemas, iterative prompt optimization, reusable template systems, and role-based system prompt design \n Includes practical patterns for semantic example selection, self-verification workflows, pr

Native iOS app design with SwiftUI, Apple HIG compliance, and adaptive layouts for iPhone and iPad. \n \n Covers SwiftUI stack-based and grid layouts, NavigationStack and TabView patterns, and system integration with SF Symbols and Dynamic Type \n Includes semantic color system, materials, shadows, and depth techniques that automatically support light and dark modes \n Provides best practices for accessibility, safe areas, state restoration, and iPad multitasking support \n Addresses common pitf

REST and GraphQL API design principles for building scalable, developer-friendly APIs. \n \n Covers resource-oriented REST patterns including HTTP method semantics, URL design, pagination, filtering, and error handling with consistent status codes \n Includes GraphQL schema-first development with type definitions, resolver patterns, Relay-style pagination, and DataLoader implementation for N+1 prevention \n Provides versioning strategies (URL, header, query parameter) and HATEOAS patterns for hy

Comprehensive patterns for designing effective KPI dashboards that drive business decisions. \n \n Covers three dashboard hierarchy levels (strategic, tactical, operational) with department-specific KPI templates for sales, marketing, product, and finance \n Includes three layout patterns: executive summary, SaaS metrics, and real-time operations dashboards with visual examples \n Provides SQL queries for common calculations (MRR, cohort retention, CAC) and Python/Streamlit implementation code f

Comprehensive testing framework for shell scripts using Bats with patterns, fixtures, and CI/CD integration. \n \n Covers core Bats concepts including test syntax, assertion patterns for exit codes and output, and setup/teardown lifecycle management \n Provides mocking and stubbing strategies for external commands, functions, and environment variables to isolate units under test \n Includes fixture management patterns, error condition testing, and shell compatibility validation across bash, sh,

Implement proven backend architecture patterns for maintainable, testable, and scalable systems. \n \n Covers three core patterns: Clean Architecture (layered dependency inward), Hexagonal Architecture (ports and adapters), and Domain-Driven Design (bounded contexts, aggregates, value objects) \n Includes complete directory structures, code examples, and implementation patterns for Python backends using FastAPI, asyncpg, and similar frameworks \n Demonstrates practical separation of concerns: do

Structured input validation, exception design, and graceful failure handling for Python applications. \n \n Covers fail-fast validation patterns, meaningful exception hierarchies, and partial failure handling for batch operations \n Includes Pydantic integration for complex input validation with automatic error messages and custom exception types with context \n Demonstrates exception chaining to preserve debug trails, batch processing with per-item error tracking, and progress reporting for lon

Modern React state management with Redux Toolkit, Zustand, Jotai, and React Query for every state category. \n \n Covers five state types: local component state, global state, server state, URL state, and form state, with recommended solutions for each \n Includes complete TypeScript patterns for Redux Toolkit slices, Zustand with scalable slice architecture, Jotai atomic state, and React Query with optimistic updates \n Demonstrates combining client state (Zustand) with server state (React Quer

Establish design token hierarchies, theming infrastructure, and component architecture for scalable design systems. \n \n Covers three-layer token organization: primitive tokens (raw values), semantic tokens (contextual meaning), and component tokens (specific usage) \n Includes theme switching patterns with CSS custom properties, React context providers, system preference detection, and persistent storage \n Provides component architecture patterns including compound components, polymorphic var

Async task processing patterns for decoupling long-running work from request/response cycles. \n \n Covers core patterns including immediate job ID returns, task queue configuration with Celery, idempotency strategies, and job state management for visibility \n Includes advanced workflows: dead letter queues for failed tasks, status polling endpoints, task chaining, and parallel execution \n Provides examples for Celery, RQ, and Dramatiq, plus guidance on cloud-native alternatives like AWS SQS a

Production-grade C#/.NET patterns for APIs, MCP servers, and enterprise backends with modern async, DI, and data access practices. \n \n Covers clean architecture project structure, dependency injection lifetimes, and configuration with IOptions pattern \n Async/await best practices including parallel execution, ConfigureAwait usage, and ValueTask optimization for hot paths \n Entity Framework Core and Dapper repository patterns with query optimization, multi-mapping, and performance considerati

$22

Comprehensive patterns for Next.js 14+ App Router, Server Components, and modern full-stack React development. \n \n Covers rendering modes (Server Components, Client Components, static, dynamic, streaming), file conventions, and core architectural patterns with practical TypeScript examples \n Includes eight key patterns: Server Components with data fetching, Client Components, Server Actions, parallel routes, intercepting routes for modals, streaming with Suspense, Route Handlers, and metadata

Optimize vector index performance across latency, recall, and memory tradeoffs. \n \n Covers HNSW parameter tuning (M, efConstruction, efSearch) with benchmarking templates and automated recommendation logic based on vector count and target recall \n Includes quantization strategies: scalar INT8, product quantization, binary quantization, and FP16 compression with memory estimation tools \n Provides Qdrant collection configuration templates optimized for three scenarios: recall-focused, speed-fo

Production-ready Solidity templates for staking, AMMs, governance, lending, and flash loan protocols. \n \n Includes five core DeFi contract templates: staking with reward distribution, AMM with liquidity pools and swaps, governance token with voting, flash loan provider, and flash loan receiver patterns \n Staking contract features time-based reward calculations, reentrancy guards, and exit functionality for combined withdrawal and reward claiming \n AMM implements constant product formula with

Structured incident response runbooks with detection, triage, mitigation, and communication procedures. \n \n Provides severity-level framework (SEV1–SEV4) with response time targets and impact classifications \n Includes ready-to-use templates for service outages and database incidents with bash/SQL commands, health checks, and rollback procedures \n Covers escalation matrices, communication templates for notifications and status updates, and verification steps to confirm resolution \n Emphasiz

Structured logging, metrics, and distributed tracing patterns for Python production systems. \n \n Covers four core observability areas: structured JSON logging with structlog, Prometheus metrics for the four golden signals (latency, traffic, errors, saturation), correlation ID propagation across service boundaries, and OpenTelemetry distributed tracing \n Includes semantic log level guidance, bounded cardinality rules for metrics to prevent storage explosion, and context manager patterns for co

Comprehensive observability for Istio and Linkerd service meshes with distributed tracing, metrics, and visualization. \n \n Covers three observability pillars: metrics (request rate, error rate, latency), traces (span context, dependencies, bottlenecks), and logs (access logs, error details) \n Includes ready-to-use templates for Prometheus, Grafana, Jaeger, Kiali, and OpenTelemetry integration with Istio and Linkerd \n Provides golden signals framework (latency, traffic, errors, saturation) wi

Production-grade Bash scripting with strict error handling, defensive patterns, and safety best practices. \n \n Covers 10 fundamental patterns including strict mode ( set -Eeuo pipefail ), error trapping, variable quoting, array handling, and safe temporary file management \n Includes advanced techniques for argument parsing, structured logging, process orchestration with signals, and idempotent script design \n Provides templates for function definitions, file operations, command substitution,

Organize and manage Conductor tracks—logical work units for features, bugs, and refactors. \n \n Provides track lifecycle management from creation through completion, including specification (spec.md), planning (plan.md), and status tracking via tracks.md registry \n Supports four track types: feature, bug, chore, and refactor, each with distinct use cases and conventions \n Includes structured templates for specifications with functional/non-functional requirements, acceptance criteria, scope b

Stripe payment processing with checkout sessions, subscriptions, webhooks, and customer management. \n \n Supports three checkout approaches: Stripe-hosted checkout (lowest maintenance), custom UI with Payment Element, and Payment Intents for bespoke control \n Handles subscriptions, one-time payments, refunds, and disputes with built-in webhook event handling for payment success, failure, and subscription lifecycle changes \n Includes customer management, payment method storage, and customer po

Map identified threats to appropriate security controls and mitigations for effective defense-in-depth planning. \n \n Provides control categorization by type (preventive, detective, corrective) and layer (network, application, data, endpoint, process), with templates for building threat-to-control mappings and calculating coverage gaps \n Includes a standard control library with 15+ pre-built controls covering authentication, encryption, logging, access control, and availability, each mapped to

Efficient similarity search patterns for vector databases and semantic retrieval systems. \n \n Covers four major vector database implementations: Pinecone, Qdrant, pgvector with PostgreSQL, and Weaviate, each with production-ready code templates \n Explains three index types (Flat, HNSW, IVF+PQ) with trade-offs between search speed, recall accuracy, and data scale \n Includes four distance metrics (Cosine, Euclidean, Dot Product, Manhattan) and guidance on when to use each \n Demonstrates hybri

Multi-stage CI/CD pipelines with approval gates and deployment orchestration. \n \n Covers four deployment strategies: rolling updates, blue-green, canary, and feature flags, each with trade-offs for downtime, rollback speed, and infrastructure cost \n Includes approval gate patterns for manual review, time-based delays, and multi-approver workflows across GitHub Actions, GitLab CI, and Azure Pipelines \n Provides automated rollback mechanisms triggered by health checks and failure detection, pl

Modern Python package creation with pyproject.toml, setuptools, and PyPI publishing. \n \n Covers source layout (recommended), flat layout, and multi-package project structures with complete pyproject.toml examples \n Supports CLI tools via Click or argparse with entry point configuration, dynamic versioning, and namespace packages \n Includes build, distribution, and automated publishing workflows for PyPI with GitHub Actions integration \n Provides patterns for data files, C extensions, editab

Structured framework for writing blameless postmortems that drive organizational learning from incidents. \n \n Provides templates for standard postmortems, 5 Whys analysis, and quick incident reviews, with sections for timelines, root cause analysis, detection gaps, and action items \n Emphasizes blameless culture by shifting focus from individual blame to systemic failures and conditions that enabled incidents \n Includes facilitation guide for postmortem meetings, anti-patterns to avoid, and

Design durable distributed workflows with Temporal, separating orchestration logic from external interactions. \n \n Workflows handle orchestration and decision-making (must be deterministic); activities handle external calls like APIs and databases (must be idempotent) \n Implements saga pattern with compensation for distributed transactions, entity workflows for long-lived state management, and fan-out/fan-in for parallel execution \n Automatic state preservation across failures via event hist

Transform threat analysis into actionable security requirements. \n \n Converts STRIDE threat categories into functional, non-functional, and constraint requirements with automatic priority calculation based on impact and likelihood \n Generates security user stories, acceptance criteria, and test cases directly from threats; includes traceability matrices linking threats to requirements \n Maps requirements to compliance frameworks (PCI-DSS, HIPAA, GDPR, SOC2, NIST, ISO 27001, OWASP) and identi

Comprehensive guide to building reliable, maintainable end-to-end test suites with Playwright and Cypress. \n \n Covers both Playwright and Cypress with setup, configuration, and framework-specific patterns including Page Object Model, fixtures, network mocking, and custom commands \n Addresses core E2E testing philosophy, the testing pyramid, and best practices for deterministic, independent tests using data attributes and user-behavior assertions \n Includes advanced patterns for visual regres

Comprehensive testing strategies for JavaScript/TypeScript using Jest, Vitest, and Testing Library. \n \n Covers unit testing, integration testing, and component testing with patterns for pure functions, classes, async code, and React hooks \n Includes mocking strategies: module mocking, dependency injection, and spying on functions for isolated test execution \n Provides API and database integration test examples with real request/response handling and transaction cleanup \n Supports snapshot t

Static analysis tool for detecting shell script issues and enforcing code quality standards. \n \n Supports Bash, sh, dash, ksh, and other POSIX shells with over 100 different warnings and errors \n Configurable via .shellcheckrc files, environment variables, and command-line flags to target specific shells and disable false positives \n Integrates with CI/CD pipelines, pre-commit hooks, and editors; outputs in multiple formats including GCC, JSON, and quiet mode \n Common error categories cover

Comprehensive guide to asyncio, concurrent patterns, and async/await for building high-performance, non-blocking Python applications. \n \n Covers core concepts (event loops, coroutines, tasks, futures) and 10+ fundamental and advanced patterns including concurrent execution, error handling, timeouts, context managers, and producer-consumer workflows \n Includes real-world examples for web scraping with aiohttp, async database operations, and WebSocket servers \n Provides performance best practi

Validate data pipelines with Great Expectations, dbt tests, and data contracts. \n \n Covers three complementary frameworks: Great Expectations for statistical and schema validation, dbt tests for transformation layer checks, and data contracts for cross-team data agreements \n Includes six core quality dimensions (completeness, uniqueness, validity, accuracy, consistency, timeliness) with ready-to-use expectation patterns and custom test examples \n Provides checkpoint automation for CI/CD inte

Comprehensive error handling patterns across Python, TypeScript, Rust, and Go with language-specific implementations. \n \n Covers error philosophies (exceptions vs Result types), error categories (recoverable vs unrecoverable), and language-specific patterns including custom exception hierarchies, Result types, and async error handling \n Includes three universal patterns: circuit breaker for preventing cascading failures, error aggregation for collecting multiple errors, and graceful degradati

GDPR-compliant data handling with consent management, data subject rights, and privacy controls. \n \n Implements consent management with audit trails, data subject access requests (DSARs), erasure, portability, and rectification workflows \n Provides data retention policies with legal basis tracking, anonymization options, and automated enforcement \n Includes breach notification handling with 72-hour authority reporting and affected individual notification workflows \n Covers privacy-by-design

WCAG 2.2 compliance patterns for keyboard navigation, screen readers, mobile accessibility, and inclusive design. \n \n Covers WCAG 2.2 Levels A, AA, and AAA with specific success criteria, color contrast requirements (4.5:1 for normal text, 3:1 for large text), and minimum touch target sizing (44x44px) \n Includes five core implementation patterns: accessible buttons with focus indicators, modal dialogs with focus trapping, forms with error announcements, skip navigation links, and live regions

ERC-721 and ERC-1155 NFT standards with metadata, royalties, and advanced features. \n \n Covers both ERC-721 (unique tokens) and ERC-1155 (multi-token) standards with complete contract examples including minting, burning, and supply management \n Supports off-chain metadata via IPFS and on-chain metadata with SVG generation, plus EIP-2981 royalty implementation for marketplace compatibility \n Includes soulbound token patterns (non-transferable), dynamic NFTs with evolving state, and gas-optimi

Structured patterns and templates for seamless on-call shift handoffs with full context transfer. \n \n Provides shift handoff document template covering active incidents, ongoing investigations, recent changes, known issues, and upcoming events \n Includes recommended 30-minute overlap timing with split responsibilities for outgoing and incoming engineers \n Offers quick async handoff template for rapid transitions and mid-incident handoff template for continuity during active incidents \n Feat

Centralized, typed configuration management using environment variables and pydantic-settings. \n \n Load and validate all configuration into typed objects at application startup, with required settings crashing immediately if missing \n Supports nested configuration groups, type coercion, custom validators, and environment-specific behavior switching \n Provides sensible defaults for local development while enforcing explicit values for secrets and production settings \n Integrates with .env fi

Production patterns for optimizing Bazel builds in large-scale monorepos. \n \n Covers WORKSPACE configuration, .bazelrc tuning, remote caching/execution setup, and platform-specific build constraints \n Includes templates for TypeScript and Python libraries, custom Docker rules, and dependency analysis via Bazel query \n Provides performance profiling techniques, memory optimization strategies, and best practices for fine-grained targets and visibility enforcement \n Addresses monorepo patterns

Reduce cloud spending across AWS, Azure, GCP, and OCI through rightsizing, reserved capacity, and cost governance. \n \n Covers four optimization pillars: visibility (tagging, dashboards, alerts), rightsizing (utilization analysis, auto-scaling), pricing models (reserved instances, spot/preemptible, savings plans), and architecture patterns (serverless, managed services, tiered storage) \n Includes cloud-specific strategies: AWS reserved instances and savings plans (30–72% savings), Azure hybrid

Robust backtesting systems that avoid look-ahead bias, survivorship bias, and overfitting. \n \n Event-driven and vectorized backtester implementations with realistic transaction cost modeling, slippage, and commission handling \n Walk-forward optimization and Monte Carlo simulation for strategy robustness testing across multiple time windows \n Comprehensive performance metrics including Sharpe, Sortino, Calmar ratios, drawdown analysis, and win-rate calculations \n Point-in-time data handling,

Configure Istio routing, load balancing, circuit breakers, and canary deployments for service mesh traffic policies. \n \n Covers four core resources: VirtualService for host-based routing, DestinationRule for service-level policies, Gateway for ingress/egress, and ServiceEntry for external services \n Includes templates for basic routing, canary deployments (weighted traffic splits), circuit breakers with outlier detection, retries with timeouts, traffic mirroring, and fault injection \n Suppor

Capture, analyze, and document network protocols through packet inspection and binary dissection. \n \n Covers traffic capture with Wireshark, tcpdump, and mitmproxy, including transparent interception and ring-buffer rotation for continuous monitoring \n Provides protocol analysis techniques: display filtering, stream following, field extraction, and TLS decryption with pre-master-secret logs \n Includes binary protocol parsing patterns (length-prefixed, TLV, fixed-header) with Python struct un

Static type checking with annotations, generics, protocols, and strict mode enforcement. \n \n Covers type annotations, generics with TypeVars, structural protocols, and type narrowing patterns for catching errors at analysis time \n Includes modern syntax (Python 3.10+ union types), bounded type variables, and generic repository patterns for type-safe APIs \n Provides configuration guidance for mypy strict mode and incremental adoption strategies for existing codebases \n Demonstrates 10 fundam

Reusable Terraform modules for AWS, Azure, GCP, and OCI infrastructure with standardized patterns and best practices. \n \n Provides pre-built module templates across four cloud providers covering core services like VPC/VNet, Kubernetes clusters, databases, and object storage \n Enforces consistent module structure with input variables, outputs, documentation, examples, and Terratest-based testing \n Includes validation blocks, conditional resources via count/for_each, and tagging strategies for

Acquire, analyze, and extract artifacts from memory dumps for incident response and malware analysis. \n \n Supports live memory acquisition across Windows (WinPmem, DumpIt), Linux (LiME, /dev/mem), and macOS (osxpmem), plus virtual machine memory from VMware, VirtualBox, QEMU, and Hyper-V \n Volatility 3 framework with 30+ plugins covering process analysis, network connections, DLL inspection, code injection detection, registry analysis, and file system artifacts \n Includes malware analysis an

Systematic code review practices for constructive feedback, bug detection, and team knowledge sharing. \n \n Covers the complete review workflow: context gathering, high-level architecture assessment, line-by-line analysis, and decision-making with clear severity labeling (blocking, important, nit, suggestion) \n Includes language-specific patterns for Python, TypeScript, and JavaScript, plus specialized review techniques for security, testing, and architectural changes \n Provides templates, ch

Build knowledge-grounded LLM applications with vector databases, semantic search, and retrieval strategies. \n \n Supports six vector database options (Pinecone, Weaviate, Milvus, Chroma, Qdrant, pgvector) and six embedding models optimized for different use cases and providers \n Covers five advanced retrieval patterns: hybrid search combining dense and sparse retrieval, multi-query generation, contextual compression, parent document retrieval, and HyDE (hypothetical document embeddings) \n Inc

Production-ready Node.js backend patterns with Express/Fastify, middleware, authentication, and database integration. \n \n Covers layered architecture (controllers, services, repositories), dependency injection, and microservices design with TypeScript \n Includes middleware patterns for authentication, validation, rate limiting, and request logging with practical examples \n Provides custom error handling, global error handlers, and async error wrappers for robust error management \n Supports

Build 3-5 year financial models with revenue projections, cost structures, and scenario planning for startups. \n \n Cohort-based revenue modeling with customer acquisition, retention, and ARPU inputs; supports SaaS, marketplace, e-commerce, and services business models \n Comprehensive cost structure breakdown across COGS, S&M, R&D, and G&A with fixed vs. variable categorization and scaling assumptions \n Cash flow analysis including monthly burn rate, runway calculation, and fun

Orchestrate distributed transactions and long-running workflows with saga patterns for multi-service coordination. \n \n Supports both orchestration (centralized coordinator) and choreography (event-driven) saga patterns with step-by-step execution and automatic compensation on failure \n Includes base orchestrator class with saga state management (started, pending, compensating, completed, failed) and built-in step tracking with results and error handling \n Provides ready-to-use templates for

Nx monorepo configuration patterns for workspace setup, project boundaries, and build optimization. \n \n Provides architectural templates for organizing apps, libraries, and tools with five library types (feature, ui, data-access, util, shell) and scope-based dependency rules \n Includes ready-to-use configurations for nx.json, project.json, module boundary enforcement via ESLint, and custom generators to maintain consistency \n Covers build caching setup with cacheable operations, named inputs

Automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. \n \n Manages complete subscription lifecycle including trial periods, activation, plan changes, cancellation, and pause/resume workflows \n Handles failed payment recovery through configurable dunning workflows with retry schedules, customer notifications, and grace periods \n Calculates prorated charges for mid-cycle plan upgrades, downgrades, and seat changes with day-based adjustments

Build read models and materialized views from event streams using projection patterns. \n \n Covers four projection types: live (real-time subscriptions), catchup (historical processing), persistent (with checkpointing), and inline (strong consistency) \n Includes five ready-to-use templates: basic projector framework, order summary projection, Elasticsearch search indexing, daily sales aggregation, and multi-table customer activity tracking \n Emphasizes idempotency, transactional consistency,

Turborepo configuration for efficient monorepo builds with local and remote caching strategies. \n \n Configure pipeline tasks with dependency graphs, output caching, and environment-specific inputs to optimize build performance across workspaces \n Supports local caching, Vercel remote caching, and self-hosted cache servers with filtering to build only affected packages \n Includes task-level configuration for persistent processes (dev servers), cache exclusions, and package-specific pipeline o

Secure connectivity between on-premises infrastructure and multiple cloud platforms via VPN and dedicated connections. \n \n Supports four cloud providers (AWS, Azure, GCP, OCI) with provider-specific connection types: Site-to-Site VPN, Direct Connect, ExpressRoute, Cloud Interconnect, and FastConnect \n Covers three hybrid network patterns: hub-and-spoke, multi-region, and multi-cloud architectures with BGP dynamic routing and route propagation \n Includes high-availability configurations with

Legally-sound employment documentation templates for contracts, offers, and HR policies. \n \n Includes three core templates: offer letters, employment agreements, and employee handbook policy sections, each with detailed sections covering compensation, benefits, confidentiality, and termination \n Covers key employment relationship distinctions: at-will vs. fixed-term, employee vs. contractor, exempt vs. non-exempt, with jurisdiction-specific considerations \n Incorporates essential legal prote

Advanced TypeScript type system patterns for building type-safe, reusable components and utilities. \n \n Covers five core concepts: generics with constraints, conditional types with inference, mapped types for property transformation, template literal types for string patterns, and built-in utility types \n Includes six advanced patterns: type-safe event emitters, API clients, builder patterns, deep readonly/partial, form validation, and discriminated unions for robust type narrowing \n Demonst

Assembly instruction patterns, control flow analysis, and decompilation techniques for understanding compiled binaries. \n \n Covers x86-64, ARM64, and ARM32 calling conventions with detailed instruction patterns for function prologues, epilogues, and parameter passing across System V and Microsoft x64 ABIs \n Includes control flow patterns for conditionals, loops, and switch statements, plus data structure recognition for arrays, structs, and linked lists \n Provides common code patterns for st

$22

Common Python anti-patterns to catch during code review and debugging. \n \n Covers 14+ anti-patterns across infrastructure, architecture, error handling, resources, type safety, and testing with before/after code examples \n Includes a quick review checklist and summary table for fast reference during code reviews \n Focuses on practical fixes: centralized retry logic, DTOs, repository pattern, specific exception handling, and async-native libraries \n Emphasizes validation at API boundaries, c

Portfolio risk measurement with VaR, CVaR, Sharpe, Sortino, and drawdown analysis. \n \n Covers 15+ risk metrics across volatility, tail risk, drawdown, and risk-adjusted return categories with parametric, historical, and Cornish-Fisher VaR methods \n Includes rolling window analysis, portfolio-level calculations with marginal risk contribution and risk parity optimization, and stress testing against historical crises or hypothetical shocks \n Supports Monte Carlo simulation with elevated volati

Complete PayPal payment processing with express checkout, subscriptions, refunds, and webhook handling. \n \n Supports one-time payments, recurring billing, and payouts via client-side Smart Buttons or server-side REST API \n Includes IPN (Instant Payment Notification) webhook verification and processing for asynchronous payment updates \n Provides order creation, capture, refund, and subscription management with full OAuth token handling \n Handles payment status flows (completed, refunded, rev

Document significant technical decisions with structured context, rationale, and consequences. \n \n Provides five template formats (standard MADR, lightweight, Y-statement, deprecation, RFC-style) covering different decision complexity levels and team preferences \n Includes lifecycle management patterns for proposed, accepted, deprecated, and superseded decisions with clear status tracking \n Offers directory structure, indexing strategies, and automation tools (adr-tools) for maintaining ADR

Industry-standard authentication and authorization patterns for building secure, scalable access control systems. \n \n Covers JWT (with refresh token flow), session-based, and OAuth2/social login strategies with production-ready code examples \n Includes role-based access control (RBAC), permission-based authorization, and resource ownership validation patterns \n Provides password hashing with bcrypt, rate limiting, and security best practices including token expiration and secure cookie flags

Establish design tokens, spacing systems, and color palettes for cohesive, accessible visual designs. \n \n Provides modular typography scale, 8-point spacing grid, semantic color tokens, and iconography system with CSS variable templates \n Includes WCAG contrast requirements (4.5:1 for body text, 3:1 for UI), dark mode implementation patterns, and font-pairing guidelines \n Covers responsive typography with clamp() , color accessibility checking, and vertical rhythm techniques for visual consi

Microinteractions, motion design, and state transitions that enhance UI polish and user feedback. \n \n Covers timing guidelines (100ms to 500ms+), easing functions, and purposeful motion principles for feedback, orientation, and focus \n Includes patterns for loading states, skeleton screens, progress indicators, toggles, page transitions, ripple effects, and swipe gestures \n Provides CSS keyframe animations and transition examples alongside Framer Motion implementations for React \n Built-in

Ultra-fast Python package installer and resolver written in Rust, 10-100x faster than pip. \n \n Drop-in pip replacement with virtual environment and Python version management built in \n Supports dependency locking with uv.lock for reproducible builds, monorepo workspaces, and seamless migration from pip, poetry, and pip-tools \n Includes uv run for executing scripts and tools without manual venv activation, plus parallel package installation and global caching for speed \n Integrates with CI/C

Modern framework patterns for building reusable, maintainable UI components across React, Vue, and Svelte. \n \n Covers three composition strategies: compound components, render props, and slots, with framework-specific examples and use cases \n Compares five CSS-in-JS solutions (Tailwind, CSS Modules, styled-components, Emotion, Vanilla Extract) with guidance on when to use each \n Includes component API design principles, accessibility best practices, and patterns for controlled/uncontrolled c

Build sophisticated LLM applications with LangChain 1.x and LangGraph for agents, memory, and tool integration. \n \n LangGraph provides the standard agent framework with StateGraph for explicit state management, durable execution, human-in-the-loop inspection, and checkpointing across sessions \n Supports ReAct agents, plan-and-execute workflows, multi-agent supervision, and structured tool invocation with Pydantic schemas \n Memory systems include ConversationBufferMemory, ConversationSummaryM

Generate, maintain, and validate OpenAPI 3.1 specifications for RESTful APIs. \n \n Supports design-first, code-first, and hybrid approaches with templates for complete specs, FastAPI/Python generation, and TypeScript/Express decorators \n Includes reusable components for schemas, parameters, responses, and security schemes to minimize duplication across endpoints \n Provides Spectral and Redocly validation rules to enforce naming conventions, security requirements, and documentation standards \

Defense-in-depth Kubernetes security through network policies, pod security standards, RBAC, and admission control. \n \n Covers three pod security levels (Privileged, Baseline, Restricted) enforced via namespace labels for graduated security posture \n Provides NetworkPolicy templates for default-deny, service-to-service communication, and DNS egress patterns \n Includes RBAC configuration examples for roles, cluster roles, and bindings to implement least-privilege access \n Demonstrates OPA Ga

Systematic debugging methodology with tools, techniques, and patterns for tracking down bugs across any codebase. \n \n Covers the scientific method for debugging: observe, hypothesize, experiment, analyze, and repeat until root cause is found \n Includes language-specific debugging tools and configurations for JavaScript/TypeScript, Python, and Go with practical examples \n Provides advanced techniques like binary search debugging, differential debugging, trace debugging, and memory leak detect

Production-ready GitHub Actions workflow templates for testing, building, and deploying applications. \n \n Includes four core workflow patterns: testing with matrix builds, Docker image building and pushing, Kubernetes deployment, and multi-OS/multi-version matrix builds \n Covers security scanning with Trivy and Snyk, reusable workflows for DRY CI/CD, and deployment approvals with environment protection rules \n Provides best practices including dependency caching, secret management, specific

Lightweight service mesh patterns for Kubernetes with automatic mTLS and zero-trust networking. \n \n Covers installation, namespace injection, and core resources including ServiceProfile for per-route metrics, TrafficSplit for canary deployments, and Server/ServerAuthorization policies for access control \n Includes templates for mesh setup, traffic splitting, retry configuration with budgets, multi-cluster linking, and HTTPRoute-based advanced routing \n Provides monitoring and debugging comma

Comprehensive smart contract security patterns, vulnerability prevention, and secure Solidity development practices. \n \n Covers critical vulnerabilities including reentrancy, integer overflow/underflow, access control failures, and front-running with vulnerable code examples and secure patterns \n Teaches Checks-Effects-Interactions pattern, pull-over-push payment design, input validation, and emergency stop mechanisms for production-ready contracts \n Includes gas optimization techniques such

Transform raw data into compelling narratives that drive stakeholder decisions and action. \n \n Three-pillar framework combining data evidence, narrative meaning, and visual clarity to structure insights for maximum impact \n Includes five story templates (Problem-Solution, Trend, Comparison, Executive Summary, One-Page Dashboard) with ready-to-use structures for common business scenarios \n Progressive reveal and annotation techniques to layer complexity, build understanding, and highlight key

ES6+ syntax and functional programming patterns for writing clean, modern JavaScript. \n \n Master arrow functions, destructuring, spread operators, template literals, and enhanced object syntax for concise, readable code \n Implement async/await and Promise patterns for handling asynchronous operations, with combinators like Promise.all and Promise.race \n Apply functional programming techniques including map, filter, reduce, higher-order functions, composition, and pure functions for data tran

Separate read and write models with command and query buses for scalable, event-driven architectures. \n \n Provides command and query handler infrastructure with bus patterns for dispatching operations to appropriate handlers \n Includes templates for command validation, event persistence, read model projections, and FastAPI integration \n Supports eventual consistency patterns with checkpoint-based synchronization and read-your-writes consistency helpers \n Covers event sourcing fundamentals,

Configure SAST tools for automated vulnerability detection across multiple languages and CI/CD pipelines. \n \n Covers three major SAST platforms: Semgrep (custom pattern-based rules), SonarQube (quality gates and code coverage), and CodeQL (GitHub Advanced Security integration) \n Includes CI/CD integration patterns for GitHub Actions, GitLab CI, and Jenkins, plus pre-commit hook setup for early detection \n Provides production-ready configuration templates, custom rule examples, and performanc

Essential metrics framework for tracking startup performance across seed through Series A stages. \n \n Covers universal metrics (MRR, ARR, CAC, LTV, burn rate, runway) plus specialized frameworks for SaaS, marketplaces, consumer, and B2B models \n Includes formulas, calculation methods, and stage-specific benchmarks for evaluating unit economics and growth efficiency \n Provides stage-gated guidance: pre-seed focuses on product-market fit signals; seed emphasizes retention and baseline unit eco

Systematic threat identification using the STRIDE methodology for security analysis and documentation. \n \n Covers six threat categories (Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, Elevation of Privilege) with specific questions and control families for each \n Includes ready-to-use templates for threat model documents, data flow diagram analysis, and risk assessment matrices with prioritization \n Provides Python utilities for automated threat enumeration, que

Comprehensive team structure, compensation, and equity planning for early-stage startups from pre-seed through Series A. \n \n Provides role-by-role hiring guidance, salary benchmarks (US 2024), and fully-loaded cost calculations across engineering, sales, product, customer success, and G&A functions \n Includes equity allocation frameworks by stage and role, option pool sizing, and founder vesting guidelines \n Covers organizational design patterns, reporting structures, span-of-control ra

Systematic visualization and analysis of attack paths with difficulty, cost, and detection metrics. \n \n Provides Python data models for building attack trees with OR/AND logic, leaf attacks, and attributes (difficulty, cost, detection risk, time required) \n Includes fluent builder API for constructing trees programmatically and methods to find easiest, cheapest, and stealthiest attack paths \n Exports to Mermaid and PlantUML diagram formats for stakeholder communication and threat visualizati

Pytest-based testing strategies for Temporal workflows with time-skipping, mocking, and replay validation. \n \n Covers unit testing (WorkflowEnvironment with time-skipping), integration testing (mocked activities), and replay testing for determinism validation \n Time-skipping enables month-long workflows to execute in seconds; ActivityEnvironment isolates activity logic for fast feedback \n Includes progressive disclosure resources for unit testing, integration testing, replay testing, and loc

Design optimal agent team compositions with sizing heuristics, preset configurations, and agent type selection. \n \n Seven preset team configurations (Review, Debug, Feature, Fullstack, Research, Security, Migration) with recommended agent counts and types for common workflows \n Team sizing heuristic table matching task complexity (simple to very complex) with recommended team size (1–5 agents) and coordination overhead guidance \n Agent type selection guide covering general-purpose, read-only

Implement PCI DSS compliance requirements for secure payment card handling. \n \n Covers all 12 core PCI DSS requirements across network security, data protection, access control, monitoring, and policy \n Provides practical code examples for tokenization (both processor-based and custom), encryption at rest and in transit, and audit logging \n Includes data minimization rules specifying what card data can and cannot be stored, plus Luhn validation for card numbers \n Outlines compliance levels

Production-ready FastAPI project structure with async patterns, dependency injection, and layered architecture. \n \n Provides recommended directory layout separating API routes, models, schemas, services, and repositories for maintainable codebases \n Includes base repository pattern for generic CRUD operations and service layer for business logic encapsulation \n Demonstrates async/await patterns throughout, from database sessions to route handlers, with proper lifespan management and middlewa

Automatic retries, exponential backoff, timeouts, and fault-tolerant decorators for Python services. \n \n Covers transient vs. permanent failure classification, exponential backoff with jitter, bounded retries, and timeout patterns using the tenacity library \n Includes nine production patterns: basic retry, selective error handling, HTTP status code retries, combined exception and status retries, retry logging, timeout decorators, stacked decorators, dependency injection for testing, and fail-

Coordinate parallel code reviews across multiple quality dimensions with deduplication and severity calibration. \n \n Allocates reviews across five dimensions (Security, Performance, Architecture, Testing, Accessibility) with recommended combinations for different code change types \n Deduplicates findings from multiple reviewers using merge rules based on file location and issue type, with conflict resolution for severity ratings \n Provides severity calibration criteria (Critical, High, Mediu

Coordinate parallel feature development with file ownership strategies, conflict avoidance rules, and integration patterns. \n \n Provides three file ownership models (by directory, module, or layer) and enforces the cardinal rule: one owner per file to prevent merge conflicts \n Defines interface contracts as read-only coordination points between implementers, allowing shared boundaries without direct file conflicts \n Covers two integration patterns (vertical slice for independent features, ho

Structured messaging protocols for coordinating agent teams through direct messages, broadcasts, plan approvals, and graceful shutdown. \n \n Three message types: message for direct teammate coordination, broadcast for critical shared-resource updates, and shutdown_request for graceful termination with approval workflows \n Plan approval workflow where teammates in plan mode submit proposals to a lead for review and feedback before execution \n Shutdown protocol with rejection handling: lead sen

Decompose complex tasks, design dependency graphs, and coordinate multi-agent work with structured task descriptions. \n \n Provides four decomposition strategies: by architectural layer, functional component, cross-cutting concern, or file ownership to parallelize work effectively \n Includes dependency graph patterns (independent, sequential, diamond) with principles for minimizing chain depth and identifying critical paths \n Offers task description template covering objective, owned files, r

Systematic debugging framework using competing hypotheses to identify root causes across multiple failure categories. \n \n Generates hypotheses across six failure mode categories: logic errors, data issues, state problems, integration failures, resource issues, and environment mismatches \n Establishes evidence standards with citation requirements (file:line references) and confidence levels (high/medium/low) to avoid confirmation bias \n Supports parallel agent investigation with structured re

Deterministic resource management with context managers, cleanup patterns, and streaming state accumulation. \n \n Covers class-based and decorator-based context managers for sync and async resources, with unconditional cleanup guarantees even on exceptions \n Includes patterns for database connections, file handles, connection pools, and dynamic resource management via ExitStack \n Provides streaming response patterns with efficient state accumulation, metrics tracking, and time-to-first-byte m

Track requests across microservices to identify latency, dependencies, and failure points. \n \n Supports Jaeger and Tempo backends with OpenTelemetry instrumentation for Python, Node.js, and Go \n Includes trace structure concepts (traces, spans, context, tags, logs) and automatic service dependency graph generation \n Provides sampling strategies (probabilistic, rate-limiting, adaptive) to control tracing overhead in production \n Covers context propagation via HTTP headers, trace analysis que

Apache Spark job optimization through partitioning, memory tuning, shuffle reduction, and join strategies. \n \n Covers partitioning strategies, broadcast joins, bucketed joins, and skew handling with salting techniques to minimize shuffle overhead \n Includes caching and persistence patterns with storage level selection, checkpointing for complex lineages, and memory configuration breakdown \n Provides data format optimization for Parquet and Delta Lake, column pruning, predicate pushdown, and

Decision framework and service comparison patterns for architecting across AWS, Azure, GCP, and OCI. \n \n Includes detailed service mapping tables across compute, storage, and database categories to identify equivalent offerings and best-of-breed selections \n Four core multi-cloud patterns: single provider with disaster recovery, best-of-breed service selection, geographic distribution, and cloud-agnostic abstraction layers \n Cloud-agnostic alternatives using Kubernetes, PostgreSQL, Apache Ka

Comprehensive screen reader testing guide covering VoiceOver, NVDA, JAWS, and TalkBack with practical commands and accessibility patterns. \n \n Covers four major screen readers with platform-specific setup, essential keyboard commands, and testing checklists for macOS, Windows, iOS, and Android \n Includes detailed testing scenarios for modals, live regions, tabs, and form validation with HTML/JavaScript examples \n Provides browse vs. focus mode navigation strategies, landmark discovery, headi

End-to-end MLOps pipeline orchestration from data ingestion through model deployment and monitoring. \n \n Covers five core pipeline stages: data preparation, model training, validation, deployment, and monitoring with DAG orchestration patterns (Airflow, Dagster, Kubeflow) \n Includes data validation, feature engineering, experiment tracking integration, and model versioning strategies across the full ML lifecycle \n Provides deployment automation patterns including canary releases, blue-green

Production-ready patterns for dbt model organization, testing, documentation, and incremental processing. \n \n Implements medallion architecture with staging, intermediate, and marts layers using consistent naming conventions (stg_, int_, dim_, fct_) and materialization strategies \n Covers source definitions with freshness checks, data quality tests (unique, not_null, relationships), and comprehensive YAML documentation for lineage tracking \n Provides incremental model patterns including dele

Comprehensive smart contract testing with Hardhat and Foundry, supporting unit tests, integration tests, mainnet forking, and gas optimization. \n \n Supports both Hardhat (JavaScript/TypeScript) and Foundry (Solidity) testing frameworks with fixtures, cheatcodes, and assertion libraries \n Includes mainnet forking capabilities for realistic testing against live contract state, account impersonation, and time manipulation \n Covers gas optimization testing, fuzzing for edge cases, snapshot/rever

Combine vector and keyword search for improved retrieval in RAG systems and search engines. \n \n Provides four fusion methods: Reciprocal Rank Fusion (RRF) for general use, linear combination for tunable balance, cross-encoder reranking for highest quality, and cascade filtering for efficiency \n Includes production-ready templates for PostgreSQL with pgvector, Elasticsearch with dense vectors, and custom Python pipelines with parallel search execution \n Handles score normalization, metadata f

Complete Prometheus setup guide covering scrape configuration, recording rules, and alerting. \n \n Includes Kubernetes and Docker Compose installation methods with example configurations for static targets, file-based discovery, and Kubernetes service discovery \n Provides pre-built recording rules for HTTP metrics (request rates, error rates, latency percentiles) and resource metrics (CPU, memory, disk utilization) \n Covers alert rule examples for service availability, error rates, latency th

Declarative, Git-based continuous delivery for Kubernetes using ArgoCD or Flux CD. \n \n Supports both ArgoCD and Flux CD with installation, configuration, and repository structure guidance for each \n Covers core GitOps patterns including App of Apps, automated sync policies with pruning and self-healing, and progressive delivery strategies (canary, blue-green) \n Includes secret management approaches using External Secrets Operator and Sealed Secrets to keep credentials out of Git \n Provides

Production patterns for Go concurrency including goroutines, channels, synchronization primitives, and context management. \n \n Covers core primitives: goroutines, channels, select, sync.Mutex, sync.WaitGroup, and context.Context with practical examples for each \n Includes seven battle-tested patterns: worker pools, fan-out/fan-in pipelines, bounded concurrency with semaphores, graceful shutdown, error groups, concurrent maps, and select timeouts \n Provides race detection guidance via command

Systematic evaluation of LLM applications using automated metrics, human feedback, and statistical testing. \n \n Covers three evaluation approaches: automated metrics (BLEU, ROUGE, BERTScore, accuracy, precision/recall), human evaluation across dimensions like accuracy and coherence, and LLM-as-Judge for pointwise, pairwise, and reference-based scoring \n Includes implementations for text generation, classification, and retrieval (RAG) evaluation with ready-to-use metric functions and custom me

Manage major dependency version upgrades with compatibility analysis, staged rollout, and comprehensive testing. \n \n Provides semantic versioning review, dependency auditing tools, and compatibility matrix validation across framework versions \n Includes staged upgrade strategies with phase-based planning, incremental updates, and validation workflows to minimize breaking changes \n Covers breaking change identification, automated codemods for API migrations, and custom migration scripts for l

Analyze competitive dynamics using Porter's Five Forces, Blue Ocean Strategy, and positioning maps to identify market gaps and defensible advantages. \n \n Covers five competitive forces (new entrants, supplier power, buyer power, substitutes, rivalry) with intensity scoring and industry attractiveness assessment \n Includes Blue Ocean Strategy framework with four actions (eliminate, reduce, raise, create) and strategy canvas mapping to find uncontested market space \n Provides positioning map t

Comprehensive Helm chart creation, templating, and packaging guidance for Kubernetes applications. \n \n Covers full chart lifecycle: initialization, Chart.yaml configuration, values.yaml design, template creation with Go templating, and dependency management \n Includes multi-environment deployment patterns with environment-specific values files (dev, staging, prod) and conditional resource rendering \n Provides validation, testing, and packaging workflows with linting, dry-run testing, and cha

Automated WCAG 2.2 auditing with violation detection, remediation patterns, and compliance guidance. \n \n Covers all four WCAG principles (Perceivable, Operable, Understandable, Robust) with detailed checklists for Levels A, AA, and AAA conformance \n Includes code examples for common violations: missing alt text, insufficient contrast, keyboard traps, form labels, and focus management \n Provides automated testing patterns using axe-core, Playwright, and CLI tools alongside manual verification

Comprehensive market sizing framework for calculating TAM, SAM, and SOM across three methodologies. \n \n Provides three complementary approaches: top-down (industry reports), bottom-up (customer segment calculations), and value theory (willingness to pay), with formulas and validation techniques for each \n Includes step-by-step process covering market definition, data gathering, TAM/SAM/SOM calculations, and triangulation across methods \n Offers industry-specific guidance for SaaS, marketplac

Structured project context management through persistent, synchronized documentation artifacts. \n \n Creates and maintains five core artifacts in a conductor/ directory: product.md (vision/goals), tech-stack.md (dependencies/architecture), workflow.md (development practices), tracks.md (work unit registry), and product-guidelines.md (communication standards) \n Scaffolds new projects interactively or extracts context from existing codebases, pre-populating artifacts based on discovered patterns

Mutual TLS configuration for zero-trust service mesh communication with certificate management. \n \n Covers Istio, Linkerd, cert-manager, and SPIFFE/SPIRE implementations with ready-to-use YAML templates for strict mTLS enforcement, workload policies, and external service integration \n Includes certificate hierarchy design, automatic rotation strategies, and port-level mTLS control for mixed-protocol environments \n Provides debugging commands for TLS handshake issues, certificate expiry verif

Secure secrets management for CI/CD pipelines using Vault, AWS Secrets Manager, and platform-native solutions. \n \n Supports multiple backends: HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, Google Secret Manager, and GitHub/GitLab native secrets \n Includes integration examples for GitHub Actions, GitLab CI, Terraform, and Kubernetes with automatic secret rotation capabilities \n Covers best practices including secret masking in logs, least-privilege access, audit logging, and secret s

Upgrade React applications to latest versions, migrate class components to hooks, and adopt concurrent features. \n \n Covers version upgrade paths (React 16→17→18) with breaking changes, class-to-hooks migration patterns, and concurrent features like Suspense, transitions, and automatic batching \n Includes ready-to-run codemods for automating unsafe lifecycle renames, import updates, and class-to-function conversions \n Demonstrates performance optimization techniques using useMemo, useCallbac

Define and implement Service Level Indicators, Objectives, and error budgets for reliability targets. \n \n Provides SLI/SLO/SLA hierarchy with common indicator types (availability, latency, durability) and Prometheus recording rules for automated calculation \n Includes error budget formulas, burn rate calculations, and multi-window alerting strategies to balance reliability with development velocity \n Offers SLO compliance dashboards, review processes (weekly/monthly/quarterly), and decision

$22

Automate changelog generation from commits following Conventional Commits and Keep a Changelog standards. \n \n Supports multiple implementation methods: Conventional Changelog (Node.js), standard-version, semantic-release with full CI/CD automation, git-cliff (Rust-based), and commitizen (Python) \n Enforces Conventional Commits format with commitlint validation, mapping commit types (feat, fix, perf, etc.) to changelog sections automatically \n Includes semantic versioning integration, GitHub

Execute database migrations across ORMs with zero-downtime strategies and rollback procedures. \n \n Supports three major ORMs: Sequelize, TypeORM, and Prisma, with migration syntax and CLI commands for each \n Covers schema transformations including column additions, renames, type changes, and data restructuring with multi-step approaches for large tables \n Includes transaction-based and checkpoint-based rollback strategies to safely recover from failed migrations \n Provides zero-downtime dep

Multi-stage GitLab CI/CD pipelines with Docker builds, Kubernetes deployments, and security scanning. \n \n Covers core pipeline patterns including build, test, and deploy stages with artifact caching and environment management \n Includes Docker image building and pushing to registries, multi-environment deployments (staging/production), and Terraform infrastructure automation \n Provides security scanning templates (SAST, dependency scanning, container scanning) and Trivy vulnerability checks

Modern responsive layouts using container queries, fluid typography, CSS Grid, and mobile-first strategies. \n \n Container queries enable component-level responsiveness independent of viewport size, with support for container query units (cqi, cqw, cqh) and style queries \n Fluid typography and spacing via CSS clamp() scales smoothly across screen sizes with min/max bounds, eliminating discrete breakpoint jumps \n CSS Grid auto-fit/auto-fill patterns and Flexbox provide intrinsic layouts that a