aj-geddes/useful-ai-prompts
202 skills113k installs61.6k starsGitHub
Install
npx skills add https://github.com/aj-geddes/useful-ai-promptsSkills in this repo
1Nodejs Express ServerThe nodejs-express-server skill documents how to build production-ready Express.js servers with routing, middleware chains, authentication, database integration, and centralized error handling. It opens with a minimal working server using express.json and express.urlencoded middleware, a /health route, and error middleware that returns JSON with requestId and status codes. Reference guides in references/ cover basic Express setup, middleware chain implementation, PostgreSQL integration with Sequelize, JWT authentication, RESTful CRUD routes, error-handling middleware, and environment configuration. Documented best practices include async await in route handlers, input validation before processing, rate limiting, HTTPS in production, logging, and keeping route handlers small. Anti-patterns warn against silent errors, storing secrets in code, synchronous route work, callback hell, exposing stack traces, and trusting client-side validation alone. Developers reach for it when creating REST APIs, wiring cross-cutting middleware, protecting routes with JWT, or connecting Express to PostgreSQL through Sequelize.3kinstalls2Code Review AnalysisThe code-review-analysis skill structures comprehensive reviews across code quality, security, performance, maintainability, and standards compliance. It targets pull request and merge request review, pre-merge quality checks, vulnerability identification, and mentoring through constructive feedback. Quick start uses git diff main...feature-branch, git diff --stat for scope, and git log --oneline for commit history context. Reference guides split work into initial assessment, code quality analysis, security review, performance review, testing review, and best practices files under references/. DO guidance emphasizes respectful tone, explaining why behind suggestions, code examples, clarifying questions, acknowledging good patterns, focusing on important issues, and offering pairing on complex fixes. DON'T guidance warns against personal criticism, style nitpicks better handled by automation, blocking on subjective taste, reviewing more than about four hundred lines at once, skipping tests, ignoring security, or rushing. The overview positions the process as systematic industry-standard review rather than ad hoc commentary.2.3kinstalls3Rest Api DesignThe rest-api-design skill documents agent workflows from the repository SKILL.md. It covers when to Use when-to-use. Key workflows include quick Start quick-start. Design REST APIs that are intuitive, consistent, and follow industry best practices for resource-oriented architecture. Developers invoke rest-api-design when the task matches the triggers and reference files in SKILL.md for grounded, stepwise execution. Reference files and progressive disclosure keep context focused while preserving concrete commands, configuration fields, and validation checks copied from the upstream documentation. Reference files and progressive disclosure keep context focused while preserving concrete commands, configuration fields, and validation checks copied from the upstream documentation. Reference files and progressive disclosure keep context focused while preserving concrete commands, configuration fields, and validation checks copied from the upstream documentation. Reference files and progressive disclosure keep context focused while preserving concrete commands, configuration fields, and validation checks copied from the upstream documentation.1.8kinstalls4Architecture DiagramsThe architecture-diagrams skill documents workflows and patterns from the repository SKILL md name architecture-diagrams description Create system architecture diagrams using Mermaid PlantUML C4 model flowcharts and sequence diagrams Use when documenting architecture system design data flows or technical workflows Architecture Diagrams Table of Contents Overview overview When to Use when-to-use Quick Start quick-start Reference Guides reference-guides Best Practices best-practices Overview Create clear maintainable architecture diagrams using code-based diagramming tools like Mermaid and PlantUML for system design data flows and technical documentation When to Use System architecture documentation C4 model diagrams Data flow diagrams Sequence diagrams Component relationships Deployment diagrams Infrastructure architecture Microservices architecture Database schemas visual Integration patterns Quick Start Minimal working example mermaid graph TB subgraph Client Layer Web Web App Mobile Mobile App CLI CLI Tool end subgraph API Gateway Layer Gateway API Gateway br Rate Limiting br Authentication end subgraph Service Layer Auth Auth Service User User Service Order Order Service Paymen.1.8kinstalls5Ansible AutomationThe ansible-automation skill helps developers write Ansible playbooks, roles, inventories, and modules for repeatable infrastructure and application deployment automation. It covers idempotent task design, variable management, handlers, templates, and common server hardening or app deploy patterns. Use when teams need Ansible automation for configuration management or CI-driven provisioning.1.4kinstalls6Ios Swift Developmentios-swift-development is an agent skill from aj-geddes/useful-ai-prompts that apply ios-swift-development agent skill workflows from documented skill.md guidance. # iOS Swift Development ## Table of Contents - [Overview](#overview) - [When to Use](#when-to-use) - [Quick Start](#quick-start) - [Reference Guides](#reference-guides) - [Best Practices](#best-practices) ## Overview Build high-performance native iOS applications using Swift with modern frameworks including SwiftUI, Combine, and async/await pat Developers invoke ios-swift-development during build/frontend work for frontend development tasks. The skill documents triggers, prerequisites, and step-by-step workflows grounded in SKILL.md. Compatible with Claude Code, Cursor, and Codex agent runtimes that load marketplace skills. Review the Security Audits panel on this listing before installing in production environments. Category Frontend Development with development vertical focus supports repeatable agent-guided delivery.1.4kinstalls7Android Kotlin DevelopmentThe android-kotlin-development skill is designed for develop native Android apps with Kotlin. Covers MVVM with Jetpack, Compose for modern UI, Retrofit for API calls, Room for local storage, and navigation architecture. Invoke when the user asks about android kotlin development or related SKILL.md workflows.1.3kinstalls8Flask Api DevelopmentThe flask-api-development skill is designed for develop lightweight Flask APIs with routing, blueprints, database integration, authentication, and request/response handling. Use when building RESTful APIs, microservices, or. Invoke when the user building RESTful APIs, microservices, or lightweight web services with Flask.1.3kinstalls9Wireframe PrototypingThe wireframe-prototyping skill is designed for create wireframes and interactive prototypes to visualize user interfaces and gather feedback early. Use tools and techniques to communicate design ideas before development. Invoke when the user asks about wireframe prototyping or related SKILL.md workflows.1.3kinstalls10Nginx ConfigurationThe nginx-configuration skill Nginx Configuration Table of Contents Overview overview When to Use when-to-use Quick Start quick-start Reference Guides reference-guides Best Practices best-practices Overview Master Nginx configuration for production-grade web servers reverse proxies load balancing SSL termination caching and API gateway patterns with advanced performance tuning When to Use Reverse proxy setup Load balancing between backend services SSL TLS termination HTTP 2 and gRPC support Caching and compression Rate limiting and DDoS protection URL rewriting and routing API gateway functionality Quick Start Minimal working example nginx etc nginx nginx conf user nginx worker_processes auto worker_rlimit_nofile 65535 error_log var log nginx error log warn pid var run nginx pid events worker_connections 4096 use epoll multi_accept on http include etc nginx mime types default_type application octet-stream Logging log_format main remote_addr remote_user time_local request status body_bytes_sent http_referer http_user_agent http_x_forwarded_for log_format upstream_time remote_addr remote_user time_local request status body_bytes_sent http_referer http_user_agent see reference guides.1.2kinstalls11Markdown DocumentationThe markdown-documentation skill Markdown Documentation Table of Contents Overview overview When to Use when-to-use Quick Start quick-start Reference Guides reference-guides Best Practices best-practices Overview Master markdown syntax and best practices for creating well-formatted readable documentation using standard Markdown and GitHub Flavored Markdown GFM When to Use README files Documentation pages GitHub GitLab wikis Blog posts Technical writing Project documentation Comment formatting Quick Start Comment formatting markdown H1 Header H2 Header H3 Header H4 Header H5 Header H6 Header Alternative H1 Alternative H2 Reference Guides Detailed implementations in the references directory Guide Contents Text Formatting references text-formatting md Text Formatting Lists references lists md Lists Links and Images references links-and-images md Links and Images Code Blocks Tables Extended Syntax GitHub Flavored Markdown references extended-syntax-github-flavored-markdown md Extended Syntax GitHub Flavored Markdown Collapsible Sections references collapsible-sections md Collapsible Sections Syntax Highlighting Badges Alerts and Callouts references alerts-and-callouts md Alerts and Ca.1.2kinstalls12Jenkins PipelineThe jenkins-pipeline skill provides prompt templates and patterns for authoring Jenkins declarative pipelines with checkout, build, test, artifact archive, and deployment stages. It documents agent labels, environment blocks, parallel stages, credentials binding, and post actions for success or failure notifications. Agents scaffold Jenkinsfiles aligned with common stack patterns while keeping secrets in Jenkins credential stores instead of plaintext. The skill helps teams modernize freestyle jobs into pipeline-as-code with reproducible stage boundaries and clear failure diagnostics.1.1kinstalls13Penetration TestingPenetration Testing is an agent skill from aj-geddes/useful-ai-prompts that provides an automated penetration testing framework in Python. The `PenetrationTester` class accepts a target, accumulates structured `Finding` records with severity, category, target URL, vulnerability description, evidence, remediation guidance, and CVSS scores, and includes methods such as `test_sql_injection` for probing web endpoints. Developers reach for Penetration Testing when they need a repeatable pre-ship scan for common web vulnerabilities rather than manual security review alone. The framework uses requests, socket, and subprocess tooling to probe targets and export findings as structured dataclass records suitable for triage before deployment.995installs14Responsive Web Designresponsive-web-design is a frontend skill from aj-geddes/useful-ai-prompts for creating mobile-first responsive layouts with CSS Grid, Flexbox, and media queries. It targets multi-device applications, accessible flexible UI systems, and adaptive user experiences without device-specific code forks. Developers reach for responsive-web-design when building landing pages, dashboards, or ecommerce layouts that must reflow cleanly from phone to desktop breakpoints. The skill outputs production-ready CSS patterns following modern mobile-first conventions rather than desktop-down retrofits.965installs15Css Architecturecss-architecture is a frontend agent skill focused on scalable CSS structure for growing web applications. It demonstrates Block Element Modifier (BEM) patterns with concrete selectors like `.button`, `.button__icon`, and `.button--primary`, plus variant and state modifiers for disabled and hover behavior. The skill emphasizes component-scoped class naming, predictable specificity, and stylesheet organization so teams avoid cascade conflicts as UI surface area expands. Use it when a React, Vue, or plain HTML project needs a naming system and folder structure before CSS debt compounds across dozens of components.874installs16Event Sourcingevent-sourcing is a TypeScript pattern skill from aj-geddes/useful-ai-prompts for building an in-memory EventStore that appends DomainEvent records with aggregateId, aggregateType, eventType, payload data, and versioned metadata. It demonstrates optimistic concurrency via expectedVersion checks before append and defines Aggregate interfaces for replay-based state reconstruction. Developers use event-sourcing when modeling financial ledgers, workflow histories, or collaborative domains that require append-only audit logs instead of destructive updates. The skill ships reference TypeScript interfaces and EventStore methods rather than a specific vendor framework.843installs17Api Contract TestingAPI Contract Testing is an installable skill from aj-geddes/useful-ai-prompts that guides contract testing between microservice consumers and providers. It validates that API changes do not break dependent consumers without requiring full integration test suites. Coverage includes consumer-driven contracts, Pact workflows, schema validation, and compatibility checks before ship. Developers reach for API Contract Testing when services evolve independently and integration tests are too slow or brittle to catch contract drift. The skill documents overview, quick start, reference guides, and best practices for honoring published API contracts.797installs18Api Security Hardeningapi-security-hardening is a Claude Code skill from aj-geddes/useful-ai-prompts that implements comprehensive REST API protection including authentication, authorization, rate limiting, input validation, CORS, and attack-prevention middleware. It includes an overview, quick start, reference guides, and best-practices sections for new API development and security audit remediation. Developers reach for api-security-hardening when exposing endpoints publicly or closing gaps found during reviews. The workflow focuses on practical middleware patterns rather than theoretical checklists.780installs19Mobile App Testingmobile-app-testing is an aj-geddes/useful-ai-prompts skill that implements comprehensive mobile testing strategies for iOS and Android applications. It covers unit tests, UI tests, integration tests, and performance testing with automation frameworks including Detox, Appium, and XCTest. Developers reach for mobile-app-testing when building reliable mobile apps, automating UI flows, or establishing test coverage before release. The skill provides quick-start guidance, reference guides, and best practices for creating test suites that catch regressions across native mobile stacks. Use it when release readiness depends on structured mobile QA rather than ad hoc manual checks.752installs20Mobile First Designmobile-first-design is a useful-ai-prompts skill that starts layouts at 320–480px mobile widths, enhances at 768–1024px tablet, and optimizes desktop at 1200px plus with progressive enhancement. It bundles three reference guides—responsive-design-implementation, mobile-performance, and progressive-enhancement—and prescribes 44×44px minimum touch targets, hamburger navigation on small screens, and safe-area awareness for notched devices. Performance targets include mobile First Contentful Paint under 3 seconds, Largest Contentful Paint under 4 seconds, CLS under 100, JavaScript bundles under 100KB gzipped, and CSS under 50KB gzipped with critical CSS inlined. Image guidance covers responsive srcset, WebP with fallbacks, lazy loading, and CDN delivery. Testing guidance covers iPhone SE at 320px baseline, Samsung S21 at 360px, iPad at 768px, Chrome DevTools emulation, orientation changes, and slow-network verification on physical hardware. Developers reach for mobile-first-design when agents need concrete responsive rules instead of generic make-it-responsive advice.752installs21Technical Specificationtechnical-specification is a prompt skill from aj-geddes/useful-ai-prompts that produces API data models and REST endpoint documentation agents can implement directly. It emits TypeScript interfaces such as User, LoginRequest, LoginResponse, and RegisterRequest with typed fields, plus endpoint sections like POST /api/auth/register with JSON request and response examples. Developers reach for technical-specification when starting auth, CRUD, or service APIs and need contracts that eliminate ambiguous field names, missing types, or inconsistent response shapes before coding. The output pairs interface blocks with per-route descriptions, HTTP methods, and payload schemas so implementation agents follow one canonical spec.720installs22User Story Writinguser-story-writing is a skill from aj-geddes/useful-ai-prompts that turns a feature idea into sprint-ready user stories backed by Gherkin acceptance criteria and explicit non-functional requirements. The readme documents multi-scenario Given-When-Then examples such as saving payment methods, editing entries, and validating success states. Developers and product engineers reach for it when backlog items lack testable acceptance criteria or NFR coverage before sprint planning. The skill standardizes story format so QA and engineering share one definition of done.710installs23Kubernetes Deploymentkubernetes-deployment is a useful-ai-prompts skill for deploying and scaling containerized applications on Kubernetes with production workload practices. The skill helps agents author Deployment manifests covering replica counts, rolling update strategies, liveness and readiness probes, resource requests and limits, and namespace-aware operations for multi-environment clusters. Developers reach for kubernetes-deployment when moving services from Docker images to orchestrated production deployments without hand-writing boilerplate YAML each time. Reference guides and best practices in the readme emphasize multi-container services, health checks, and controlled rollouts suited to long-running APIs and web backends.677installs24User Guide Creationuser-guide-creation is an aj-geddes useful-ai-prompts agent skill for automatically generating structured end-user documentation from application artifacts. The skill produces step-by-step setup guides with numbered instructions, preference configuration sections, tips, and screenshot references pulled from app UI captures and inline code comments. Output follows patterns like account creation flows, settings configuration tabs, and feature walkthroughs with image placeholders. Developers reach for user-guide-creation when they need onboarding docs, setup wizards, or feature guides written in consistent plain language without spending hours on manual technical writing after each UI change.661installs25Root Cause Analysisroot-cause-analysis is an incident postmortem skill from aj-geddes/useful-ai-prompts that walks developers through timeline reconstruction, log and metrics review, 5 Whys root-cause identification, contributing-factor analysis, and follow-up prevention checklists. The skill outputs action items with owners and deadlines, plus monitoring, testing, and procedural changes to stop recurrence. Use it when an outage or regression needs a documented RCA with shareable learnings rather than a Slack thread or one-line fix summary. The bundled checklist covers incident documentation, timeline establishment, log review, metrics analysis, and preventive measure tracking.657installs26Flutter Developmentflutter-development is a prompt-driven skill from aj-geddes/useful-ai-prompts that gives agents concrete Flutter patterns instead of improvised widget trees. It documents pubspec.yaml dependencies including provider ^6.0.0, http ^1.1.0, and go_router ^12.0.0, then shows main.dart wired to MaterialApp.router with Material 3 enabled via useMaterial3: true. Navigation uses GoRouter configuration rather than legacy Navigator 1.0 patterns, and state flows through Provider for screen-level data. Developers reach for flutter-development when bootstrapping a new Flutter client or standardizing navigation and theming across screens during active build work. The skill emphasizes project structure and routing first, making it a practical reference when agents need copy-pasteable Dart starting points. It suits teams adopting Material 3 and declarative routing without spending sessions debugging basic scaffold mistakes.656installs27Logging Best Practiceslogging-best-practices is an observability skill for Node.js and TypeScript backends needing centralized logging. It provides docker-compose setups for Elasticsearch 8.0.0, Logstash 8.0.0, and Kibana 8.0.0 with JSON tcp input pipelines, plus patterns for forwarding structured logs to CloudWatch. Developers reach for logging-best-practices when microservices produce unstructured console output, when on-call engineers cannot search production events, or when ELK or CloudWatch aggregation is being introduced. The skill covers logstash.conf tcp json codecs, index-friendly field naming, and operational log shipping suitable for debugging incidents and building dashboards in Kibana or CloudWatch Logs Insights.636installs28Funnel AnalysisFunnel Analysis is a prompt-driven agent skill from aj-geddes/useful-ai-prompts that guides systematic conversion funnel reviews across onboarding, checkout, and feature-adoption flows. The skill structures analysis around sequential steps—entry, progression, and abandonment—so you can compare segments, traffic sources, and cohort behavior without ad-hoc spreadsheet work. It fits when conversion rates stall, bottlenecks are unclear, or product teams need repeatable funnel diagnostics tied to measurable KPIs. Developers reach for Funnel Analysis during growth reviews, A/B planning, and journey-mapping sessions where qualitative guesses need quantitative step definitions. Outputs include annotated funnel stages, hypothesized drop-off causes, and prioritized optimization experiments you can feed into analytics tooling or product backlogs.635installs29E2e Testing Automatione2e-testing-automation is a testing skill that scaffolds Cypress end-to-end specs for web applications. It produces cypress/e2e test files with describe and it blocks, cy.visit navigation, data-cy and name attribute selectors, form filling, URL assertions, and repeatable user-flow coverage such as registration and authentication. Developers reach for e2e-testing-automation when they need automated browser tests for signup, login, checkout, or other multi-step UI paths without hand-writing every cy.get interaction. The skill emphasizes reliable selectors, beforeEach setup, and flow verification patterns suitable for CI pipelines running Cypress against staging or production-like environments.630installs30Access Control Rbacaccess-control-rbac is a Java Spring Security skill for developers implementing role-based access control on REST APIs. The skill provides RBACConfiguration patterns using SecurityFilterChain, HttpSecurity path matchers, and @EnableGlobalMethodSecurity with prePostEnabled for @PreAuthorize method guards. Developers reach for access-control-rbac when endpoints must restrict access by role—admin versus user—and when fine-grained permissions must apply at both URL and method levels. Example code covers filter chain setup, HTTP authorization rules, and annotation-driven method security for production Spring Boot services.625installs31Docker Containerizationdocker-containerization is a DevOps skill from aj-geddes/useful-ai-prompts that guides agents through optimized Dockerfiles, multi-stage builds, security hardening, and Docker Compose service definitions. The skill includes a table-of-contents reference covering quick-start patterns, image-size reduction, non-root users, and Compose-friendly multi-service layouts for deployment and CI pipelines. Developers reach for docker-containerization when containerizing a new service, shrinking bloated images, or standardizing local and production runtimes before registry push. Outputs follow maintainability and attack-surface reduction practices rather than single-stage dev-only images.608installs32React Component Architecturereact-component-architecture is a Claude Code skill from aj-geddes/useful-ai-prompts that codifies scalable React UI design with functional components, hooks, composition, and TypeScript type safety. The skill includes reference guides, quick-start patterns, and best practices for component library design and large-scale React applications. Developers reach for react-component-architecture when scaffolding a new UI layer, refactoring monolithic components, or establishing team conventions for props, state, and composition. It focuses on maintainable structure rather than visual styling, making it a fit during greenfield builds and ongoing refactors alike.607installs33Visual Regression Testingvisual-regression-testing is an aj-geddes/useful-ai-prompts skill for automated visual QA on UI components and pages. It explains capturing baseline screenshots, diffing them across code versions, and integrating services such as Percy and Chromatic to catch CSS bugs, layout shifts, and design regressions that functional tests miss. The skill includes quick-start steps, reference guides, and best practices for when visual comparison belongs in CI. Developers reach for visual-regression-testing when style or layout changes slip through Jest or Playwright assertions alone. It bridges design-system stability and release confidence for component libraries and marketing pages alike.607installs34Ruby Rails Applicationruby-rails-application is a pattern library skill from aj-geddes/useful-ai-prompts focused on production-grade Ruby on Rails backend code. Excerpts document service objects such as PostService with methods for get_user_posts filtered by status, trending_posts joining comments with GROUP BY ordering, ILIKE search_posts queries, and archive_old_drafts retention logic. Developers reach for ruby-rails-application when scaffolding Rails APIs and they want vetted Active Record query shapes, JWT authentication snippets, and service-layer structure instead of ad hoc controller fat models. The skill emphasizes copy-ready Ruby examples under app/services and related Rails conventions for maintainable backend modules.606installs35Security Compliance Auditsecurity-compliance-audit is an automated compliance checker skill from aj-geddes/useful-ai-prompts that evaluates codebases against five regulatory frameworks: SOC 2, GDPR, HIPAA, PCI-DSS, and ISO 27001. The bundled compliance_auditor.py Python module defines Control dataclasses with control IDs, framework mappings, requirement descriptions, and status enums for compliant, non-compliant, partially compliant, and not applicable results. Developers reach for security-compliance-audit when preparing for compliance reviews, generating audit-ready control assessments, or identifying gaps across multiple frameworks in one pass. The skill produces structured JSON compliance reports with per-control status rather than ad-hoc checklist reviews.605installs36Websocket Implementationwebsocket-implementation is an agent skill from aj-geddes/useful-ai-prompts for engineers adding real-time chat, notifications, dashboards, or collaborative editing. It bundles five reference guides covering a Node.js Socket.IO server, browser WebSocket client, Python aiohttp server, message-type protocols, and Redis horizontal scaling with @socket.io/redis-adapter. The quick-start server configures reconnection with reconnectionAttempts set to 5, reconnectionDelay 1000 ms, and Redis adapter wiring for multi-node deployments. Browser client examples track reconnectAttempts, messageQueue buffering while offline, and isAuthenticated handshake state. Best-practice checklists cover room management, message acknowledgment, rate limiting, and connection cleanup. Developers reach for websocket-implementation when scaffolding bidirectional transport instead of inventing reconnect and auth edge cases from scratch for each feature, especially in SaaS products that must survive flaky mobile networks and horizontal scale-out. Reference files split server, browser, Python, protocol, and Redis scaling concerns so agents paste only the slice needed.600installs37Image Optimizationimage-optimization is a frontend performance skill from aj-geddes/useful-ai-prompts that encodes format-specific compression playbooks for JPEG, PNG, WebP, and SVG assets. It recommends JPEG quality 70–85 for photos (~50–70% size reduction), PNG lossless workflows with PNGQuant or OptiPNG (10–30% reduction), WebP via cwebp for ~25–35% savings over JPEG/PNG with <picture> fallbacks for 90% browser support, and SVG guidance for icons and logos. The skill includes ready-to-run ImageMagick, cwebp, and optipng command examples developers can paste into CI or local optimization scripts. Reach for image-optimization when Lighthouse or Core Web Vitals flag heavy images and you need consistent, format-aware budgets instead of ad-hoc TinyJPEG uploads.595installs38Agile Sprint PlanningAgile-sprint-planning is an agent skill for time-boxed Agile iterations with AI coding agents. It helps teams define sprint goals, estimate user stories, manage the sprint backlog, and run daily standups to deliver value incrementally while adapting to change. Developers reach for agile-sprint-planning at sprint kickoff, backlog refinement, or when an agent-assisted team needs a repeatable ceremony structure instead of ad hoc task lists.592installs39Business Case Developmentbusiness-case-development is a Claude skill from aj-geddes/useful-ai-prompts that walks developers and technical leads through building investment justifications with financial analysis, strategic alignment, and risk assessment. It helps teams quantify benefits, estimate costs, and present ROI arguments when requesting budget for tools, infrastructure, or new product bets. The skill includes reference guides and best practices for structuring cases leadership can approve. Developers and engineering managers reach for business-case-development when they need to translate a technical initiative into numbers executives understand, such as migration costs, platform upgrades, or headcount for a new service.588installs40Gitlab Cicd Pipelinegitlab-cicd-pipeline is a GitLab CI/CD authoring skill for creating .gitlab-ci.yml files with staged jobs, artifacts, caching, Docker integration, and deployment strategies on GitLab Runner infrastructure. It covers multi-stage pipelines spanning lint, test, build, security scanning, review environments, and production deploys, plus runner and container execution configuration. Developers reach for this skill when standing up CI for a GitLab repository, wiring Docker registry pushes, or adding Kubernetes deployment stages without hand-writing every job block from scratch.588installs41Information Architectureinformation-architecture is a useful-ai-prompts skill that helps agents structure large information spaces so users can find content intuitively. It guides creation of logical hierarchies, navigation patterns, mental models, and categorization schemes aligned to user tasks—covering website redesigns, documentation portals, and e-commerce catalogs called out in its when-to-use list. Developers reach for it when sitemaps, nav labels, or taxonomy drift cause support burden and search failure before a single React component ships. The skill includes quick-start flows, reference guides, and best-practice checklists for labeling, grouping, and cross-linking. It complements visual UI work by defining the skeleton developers implement in routes, menus, and CMS collections.580installs42Api Rate Limitingapi-rate-limiting is a Claude Code skill from aj-geddes/useful-ai-prompts that walks developers through implementing API rate limiting with three core algorithms: token bucket, sliding window, and fixed window. The skill covers per-user, per-IP, and per-endpoint strategies plus quick-start setup, reference guides, and best practices for tiered limits. Developers reach for api-rate-limiting when hardening REST or GraphQL endpoints against brute-force attacks, smoothing traffic spikes, or enforcing plan-based quotas before launch. The guidance is algorithm-focused rather than framework-specific, so teams can map patterns onto Express, FastAPI, NestJS, or gateway middleware. Use it during backend build when abuse protection is required but a full API gateway product is not yet in place.579installs43Requirements Gatheringrequirements-gathering is an agent skill from aj-geddes/useful-ai-prompts that structures how coding agents interview stakeholders, capture needs, and confirm agreement before implementation starts. It provides overview guidance, quick-start steps, reference guides, and best practices for project kickoff, feature development initiation, and clarity checks that prevent misalignment and expensive late changes. Developers reach for requirements-gathering when a feature brief is vague, acceptance criteria are missing, or multiple stakeholders need a single documented source of truth. The skill emphasizes completeness, validation, and shared understanding rather than writing production code.577installs44Aws Lambda Functionsaws-lambda-functions is a useful-ai-prompts skill documenting AWS CLI patterns to stand up Lambda from scratch. It covers creating a lambda-execution-role with sts:AssumeRole for lambda.amazonaws.com, attaching AWSLambdaBasicExecutionRole, zipping index.js into function.zip, and calling aws lambda create-function with a Node.js runtime. Developers reach for this skill when they need repeatable shell commands for IAM plus deployment instead of clicking through the console or writing one-off Terraform for a single function experiment. The excerpts focus on minimal viable Lambda creation and invocation workflows suitable for hack-day APIs or webhook handlers.571installs45Github Actions Workflowgithub-actions-workflow is a Claude Code skill for building comprehensive GitHub Actions workflows covering CI/CD, testing, security scanning, and deployment. The skill teaches workflows, jobs, steps, and conditional execution patterns so agents can automate build, test, security analysis, and release pipelines directly in .github/workflows YAML. Developers reach for github-actions-workflow when bootstrapping repository automation, adding matrix test jobs, wiring dependency updates, or extending deploy stages without memorizing Actions syntax edge cases.569installs46Internationalization I18ninternationalization-i18n is a comprehensive agent skill from useful-ai-prompts for implementing internationalization and localization in web and mobile codebases. It walks developers through message extraction, translation catalog structure, pluralization rules, locale-aware date/time and number formatting, and right-to-left language support. The skill references established libraries including i18next and gettext and includes quick-start paths, reference guides, and best-practice checklists agents can apply directly in repositories. Developers reach for internationalization-i18n when adding a new locale, refactoring hard-coded strings, or standing up translation management before launch. Because i18n touches routing, component copy, and server responses, the skill spans multiple implementation steps rather than a single file edit, making it suited to sustained build-phase work across frontend and API layers.566installs47Fastapi Developmentfastapi-development is an aj-geddes useful-ai-prompts skill for building modern Python APIs with FastAPI. It teaches async/await route handlers, Pydantic request and response validation, dependency injection, security hooks, CORS configuration, structured logging, and automatic OpenAPI documentation generation. Developers reach for fastapi-development when starting a new microservice, replacing synchronous Flask endpoints, or hardening an API that must expose interactive docs and strict type validation out of the box. The skill includes quick-start patterns, reference guides, and best practices for performance-oriented services where automatic schema generation and async I/O matter. Invoke it during backend scaffolding or when extending existing FastAPI projects with new routers, middleware, or validated models.564installs48Log Analysislog-analysis is a Debugging skill from aj-geddes/useful-ai-prompts that analyzes application and system logs to identify errors, recurring patterns, and root causes using structured logging and aggregation practices. Developers reach for log-analysis when troubleshooting failures, investigating performance regressions, reviewing security incidents, auditing user actions, or monitoring application health. The skill guides effective log parsing so agents quickly narrow noisy stack traces and timestamps into actionable reports rather than raw dump review. log-analysis fits operate-stage workflows where staging or production telemetry must be interpreted under time pressure. It complements monitoring stacks by focusing on interpretive analysis—correlating events, highlighting anomalies, and explaining likely root causes from unstructured or semi-structured log streams inside Claude or Cursor debugging sessions.563installs49Project Estimationproject-estimation is a skill from aj-geddes/useful-ai-prompts that guides accurate project scoping through bottom-up, top-down, and analogous estimation methods combined with historical data and expert judgment. It helps agents break work into estimable units, apply structured techniques to minimize surprise overruns, and document assumptions behind timeline and budget outputs. The skill includes quick-start guidance, reference guides, and best practices for when to re-estimate after scope changes. Developers reach for project-estimation when kicking off migrations, greenfield services, or multi-sprint features inside Cursor or Claude Code and need defensible hour, headcount, and milestone tables before writing production code. Output emphasizes realistic ranges and explicit dependencies rather than single-point guesses, making plans suitable for stakeholder review, sprint zero planning, or RFC appendices. Pair with architecture or TDD skills after scope is accepted to translate estimates into implementation phases.562installs50Color Accessibilitycolor-accessibility is a Claude Code skill for designing color palettes accessible to all users including those with color vision deficiency. It ensures sufficient contrast ratios per WCAG guidelines, meaningful non-color-only information encoding, and inclusive patterns for data visualizations, status indicators, and interface themes. Developers reach for color-accessibility when creating new palettes, testing interface designs for contrast failures, or validating that charts and alerts remain readable for protanopia, deuteranopia, and tritanopia users before shipping UI components.561installs51Static Code Analysisstatic-code-analysis is a skill in aj-geddes/useful-ai-prompts for setting up automated code analysis without execution. It integrates linters, formatters, and security scanners to detect bugs, vulnerabilities, and style violations early in the development cycle. Developers invoke it when enforcing team coding standards, hardening CI pipelines, or augmenting manual code review with repeatable checks. The skill guides agent sessions through tool selection, configuration, and pipeline wiring so analysis runs on every pull request or pre-deploy step. Reach for static-code-analysis when prompts mention ESLint, Prettier, Semgrep, SonarQube, or automated review gates.559installs52Terraform Infrastructureterraform-infrastructure is a skill in aj-geddes/useful-ai-prompts for building Infrastructure as Code with Terraform. It covers modular components, remote state management, and multi-cloud deployments across AWS, Azure, GCP, and on-premise targets. Developers use it when provisioning networks, compute, storage, and supporting cloud resources through declarative .tf files rather than console clicks. The skill guides agent sessions on state backends, module composition, and environment separation for staging and production. Reach for terraform-infrastructure when prompts mention Terraform plans, remote state, module structure, or multi-environment cloud provisioning.559installs53Competitor Analysiscompetitor-analysis is a product strategy research skill that guides developers through systematic competitive landscape mapping to reveal market positioning, advantages, and strategic gaps. Reach for it during product strategy development, market entry planning, pricing decisions, feature prioritization, or repositioning exercises. The skill structures SWOT-style evaluation of rival strengths and weaknesses, surfaces opportunities and threats, and translates findings into actionable product decisions. Reference guides and best practices are included for repeatable analysis rather than ad-hoc competitor notes.557installs54Data Encryptiondata-encryption is a skill from aj-geddes/useful-ai-prompts that walks developers through industry-standard encryption for data at rest, in transit, and end-to-end protected channels. It covers AES and RSA usage, TLS configuration, and proper key management practices via an overview, quick start, reference guides, and best-practices sections rather than ad-hoc cipher choices. Developers invoke it when storing sensitive records, encrypting database columns, sealing file blobs, or hardening service-to-service communication where rolling custom crypto would be unsafe. The skill emphasizes proven algorithms and operational key handling instead of inventing primitives. It fits backend and API workstreams where compliance or threat models require explicit encryption design. Pair it with deployment skills for certificate rotation and secrets stores. Skip it when you only need framework defaults like HTTPS termination already managed by your cloud provider and no field-level encryption is required.551installs55Refactor Legacy CodeRefactor Legacy Code is an Agent Skill from aj-geddes/useful-ai-prompts that guides systematic modernization of old code while keeping functionality intact. The skill follows industry best practices for improving readability, performance, and structure when deprecated APIs, tangled modules, or accumulated debt block safe feature work. Developers reach for Refactor Legacy Code when they need to refactor old services, replace obsolete patterns, or raise maintainability before adding features—without introducing breaking changes. Reference guides and best-practice sections in the skill structure incremental refactors with verification steps suited to long-lived SaaS, API, and CLI repositories.550installs56Security Testingsecurity-testing is a security agent skill from aj-geddes/useful-ai-prompts that structures vulnerability discovery through static analysis, dynamic analysis, penetration testing workflows, and dependency scanning. It activates on security test, OWASP, SQL injection, XSS, CSRF, and penetration testing requests, helping agents surface common web flaws and third-party package risks before production. Developers invoke security-testing during pre-release hardening when automated scanners and manual test plans must align with OWASP guidance and data-protection requirements. The skill packages reference guides and best practices so agents produce actionable findings instead of generic security reminders.548installs57Backup Disaster Recoverybackup-disaster-recovery is an agent skill from aj-geddes/useful-ai-prompts for designing comprehensive backup and disaster recovery strategies. The skill guides automated backup configuration, disaster recovery plan authoring, data restoration procedures, and business continuity planning for production infrastructure. Developers reach for it during compliance-driven data protection work, failover planning, or post-incident recovery procedure documentation. Reference guides and best practices cover backup scheduling, retention policies, and restoration testing. Output includes backup configurations, DR runbooks, and restoration checklists rather than application feature code.546installs58Design Patterns Implementationdesign-patterns-implementation is a skill in aj-geddes/useful-ai-prompts that guides developers through selecting and applying proven design patterns to solve common architectural problems. The skill covers Singleton, Factory, Observer, Strategy, and additional patterns with reference guides, quick-start steps, and best practices for creating maintainable, extensible, and testable code. Developers reach for design-patterns-implementation when refactoring tangled service layers, introducing extension points, or aligning new modules with SOLID principles. The skill pairs pattern selection guidance with concrete implementation workflows rather than abstract theory alone.546installs59Performance Testingperformance-testing from aj-geddes/useful-ai-prompts guides developers through designing and running performance tests that measure how systems behave under load. The skill covers response times, throughput, resource utilization, and scalability analysis to find bottlenecks and validate SLAs before release. Triggers include performance test, load test, JMeter, k6, benchmark, latency testing, and scalability analysis requests. It structures quick starts, reference guides, and best practices rather than replacing your observability stack. Developers reach for performance-testing when APIs or services need evidence they meet latency and capacity targets, not just passing functional tests. Pair it with frontend vitals skills when both browser and backend saturation must be validated.546installs60Aws S3 Managementaws-s3-management is a skill in aj-geddes/useful-ai-prompts for provisioning and managing Amazon S3 object storage through an AI coding agent. It covers bucket creation, versioning, server-side encryption, access control policies, lifecycle transitions, and cross-region replication. Developers use it for static website hosting, backup archives, and data lake foundations where durable blob storage is required. The skill follows AWS best practices for secure, scalable object retrieval and pairs with agent sessions that generate CLI commands, SDK calls, or infrastructure snippets. Reach for aws-s3-management when prompts mention S3 buckets, object policies, or storage lifecycle automation.541installs61Vulnerability Scanningvulnerability-scanning is a Claude Code skill from aj-geddes/useful-ai-prompts that structures agent-led security review before production deployment. The skill directs scans across third-party dependencies for known CVEs, configuration files for misconfigurations, and application source for OWASP-class unsafe patterns. Developers reach for vulnerability-scanning when preparing a release candidate, responding to security audit requests, or hardening a codebase without a dedicated AppSec engineer in the loop. It functions as a prompt-driven checklist that channels the agent through systematic discovery and reporting of exploitable weaknesses rather than ad-hoc grep searches.541installs62User Research Analysisuser-research-analysis is a skill from aj-geddes/useful-ai-prompts that transforms raw user research into actionable product insight. It guides synthesis of qualitative interviews and quantitative surveys, pattern identification across responses, and validation of design assumptions through structured analysis steps documented in overview, quick start, reference guides, and best-practices sections. Developers and product engineers use it after collecting user feedback but before locking roadmap priorities, especially when disparate notes need consistent theming and severity ranking. The skill outputs clear pain-point clusters and recommendation lists suitable for tickets or PRDs rather than leaving bullet dumps in Slack. It complements prototyping skills by grounding experiments in observed user behavior. Skip it when you lack primary research data or only need statistical analysis of large automated telemetry datasets without qualitative context.537installs63Push Notification Setuppush-notification-setup is a React Native mobile skill from aj-geddes/useful-ai-prompts that implements end-to-end push notifications for iOS and Android. It covers Firebase Cloud Messaging setup, Apple Push Notification service configuration, in-app notification handling, deep-link payloads, and backend integration patterns. Developers reach for push-notification-setup when adding real-time alerts, re-engagement nudges, or deep-link opens from notification taps rather than wiring FCM and APNs piecemeal from scattered docs. The skill includes quick-start steps, reference guides, and best-practice checklists for permissions, token registration, and foreground versus background delivery behavior on both platforms.529installs64Time Series Analysistime series analysis is a skill from aj-geddes/useful-ai-prompts for examining data collected over time to identify trends, seasonality, autocorrelation, and forecastable patterns. Developers reach for it when predicting future values from historical sales, stock prices, website traffic, or product usage metrics. The skill supports decomposition, trend analysis, and forecasting models for temporal dependencies. It fits grow-stage analytics where teams translate historical signals into forward-looking estimates. Use it when stakeholders need grounded forecasts rather than one-off snapshot reports.529installs65Database Query Optimizationdatabase-query-optimization is a structured performance skill from aj-geddes/useful-ai-prompts that walks developers through systematic SQL diagnosis and remediation. The skill covers EXPLAIN ANALYZE interpretation, indexing strategies, efficient query rewrites, and execution plan review to reduce response times and database CPU usage. Reference guides and best-practice sections address slow endpoints, performance regressions, and high-load scenarios common in API-backed applications. Developers reach for database-query-optimization when profiling shows database-bound latency, when new features introduce expensive joins or scans, or when production monitoring flags rising query times. The workflow emphasizes measurable before-and-after plans rather than ad-hoc query tweaks.525installs66App Store Deploymentapp-store-deployment is a Claude Code skill from aj-geddes/useful-ai-prompts for publishing mobile applications to official app stores. It walks developers through iOS and Android code signing, semantic versioning, build configuration, pre-submission testing checks, and the App Store Connect and Google Play Console submission workflows. Developers reach for app-store-deployment when a mobile build is ready but store certificates, provisioning profiles, bundle IDs, or release track configuration remain incomplete. The skill consolidates platform-specific release management guidance that otherwise spans Apple developer portals, Xcode archive settings, Android keystore files, and Play Console tracks. It targets teams shipping React Native, Flutter, or native mobile apps who need a structured release checklist inside their AI coding session.522installs67Technical Roadmap Planningtechnical-roadmap-planning is a skill from aj-geddes/useful-ai-prompts that helps engineering leads produce strategic technology plans spanning quarters or years. It structures discovery of business goals, maps them to architecture evolution, infrastructure investments, and capability milestones, and outputs prioritized phases with explicit trade-offs. The README includes quick start, reference guides, and best practices for aligning roadmaps to organizational objectives. Developers and tech leads reach for technical-roadmap-planning during annual planning, post-funding scale decisions, or platform modernization when stakeholders need a coherent timeline instead of ad-hoc ticket backlogs.522installs68Database Schema Designdatabase-schema-design is a skill from aj-geddes/useful-ai-prompts for designing scalable, normalized relational schemas with proper relationships, constraints, and data types. It covers normalization techniques, relationship patterns, and constraint strategies for PostgreSQL and MySQL. Developers reach for database-schema-design when starting greenfield data models, redesigning tables, or planning indexes and foreign keys before writing migrations. The skill outputs table definitions, relationship diagrams in prose, and constraint recommendations suited to transactional application backends.521installs69Api Authenticationapi-authentication is a skill in aj-geddes/useful-ai-prompts that implements secure API authentication patterns with JWT tokens, OAuth 2.0 providers, API keys, and session management following documented best practices. A Node.js quick-start shows express login with bcrypt password verification, signed access tokens, and separate refresh secrets loaded from environment variables. Four reference guides ship in references/: jwt-authentication, oauth-20-implementation, api-key-authentication, and python-authentication-implementation for language-specific depth. Developers reach for this skill when securing endpoints, building login and logout flows, managing refresh tokens, or integrating third-party OAuth providers. The skill emphasizes HTTPS-only transport and proper secret handling rather than demo-hardcoded keys in production paths.519installs70Data Cleaning PipelineData Cleaning Pipeline is a Skillselion skill from aj-geddes/useful-ai-prompts that structures end-to-end preprocessing for messy tabular and semi-structured datasets. The skill walks through missing-value strategies, duplicate removal, outlier detection, type coercion, and repeatable transformation steps so cleaned outputs are safe for pandas, SQL warehouses, ML training jobs, or AI agent ingestion. Developers reach for Data Cleaning Pipeline when exploratory analysis keeps breaking on nulls, inconsistent encodings, or schema drift, and they need a documented, automatable quality gate instead of one-off notebook fixes. The workflow emphasizes data quality checks, standardized column formats, and pipeline automation patterns that keep downstream models and APIs from inheriting silent data defects.516installs71Frontend Accessibilityfrontend-accessibility is a skill from aj-geddes/useful-ai-prompts for building inclusive web UIs to WCAG standards. It guides implementation of semantic HTML structure, appropriate ARIA attributes, keyboard navigation patterns, and screen reader support so applications work for assistive technology users. Developers reach for frontend-accessibility when compliance is required, inclusive design is a release criterion, or existing components fail keyboard and screen reader checks. The skill includes quick-start guidance, reference guides, and best-practice checklists the agent applies while editing React, HTML, or component libraries. It fits frontend build tasks where accessibility must be designed into markup and interaction patterns, not patched after QA.516installs72Accessibility Testingaccessibility-testing is a Claude skill in aj-geddes/useful-ai-prompts that guides developers through inclusive QA before release. It structures WCAG conformance reviews, keyboard-only navigation checks, screen reader user flows, and actionable remediation plans for web and mobile UI. The skill fits ship-phase testing when compliance, audit readiness, or user inclusivity block a launch. Developers reach for accessibility-testing when a PR needs a11y coverage beyond lint rules, when preparing for WCAG-driven reviews, or when screen reader and keyboard paths have not been validated on real components.513installs73Data Visualizationdata visualization is a skill from aj-geddes/useful-ai-prompts that guides agents to create effective charts with matplotlib and seaborn. It supports exploratory data analysis, stakeholder presentations, distribution comparisons, outlier detection, and publication-ready report graphics. Developers reach for data visualization when complex tabular results need clear visual storytelling instead of raw tables. The skill covers pattern discovery, relationship plots, and decision-support graphics for reports and dashboards. It fits grow-stage analytics work where Python visualization libraries translate analysis output into communicable artifacts.513installs74Mobile App Debuggingmobile-app-debugging is an aj-geddes/useful-ai-prompts agent skill that guides systematic diagnosis of iOS and Android crashes, performance regressions, and platform-specific defects. The skill addresses device hardware limits, mobile network conditions, connectivity failures, and OS-level behaviors that desktop debugging workflows miss. Reference guides and best practices walk agents through repro steps, log capture, and platform tooling before proposing fixes. Reach for mobile-app-debugging when an app crashes on device, stutters under load, or behaves differently across iOS and Android builds. Skip mobile-app-debugging for backend-only APIs, web SPAs, or desktop apps with no mobile target. The skill fits React Native, Flutter, native Swift/Kotlin, and hybrid stacks where agents need a structured mobile triage checklist instead of generic debugging advice.510installs75Security Audit Loggingsecurity-audit-logging is an aj-geddes/useful-ai-prompts agent skill for implementing comprehensive security audit logging across user actions, security events, and system changes. The skill covers structured log schemas, retention policies, and SIEM integration for compliance frameworks including SOC 2, HIPAA, and PCI-DSS, plus security monitoring and forensic investigation support. Reference guides and best practices walk agents through audit trail design from quick start through production hardening. Developers reach for security-audit-logging when building compliance logging, wiring events to a SIEM, or adding forensic-grade audit trails to APIs and backend services before launch.508installs76Memory Leak Detectionmemory-leak-detection is a debugging skill from useful-ai-prompts for tracing memory growth in long-running clients and backend services before release or after performance complaints. It guides investigation of rising heap usage, orphaned event listeners, and retained object graphs that cause gradual memory bloat. Developers reach for memory-leak-detection when production or staging processes show climbing RSS or heap metrics and standard profiling has not isolated the retaining path.507installs77Bundle Size Optimizationbundle-size-optimization is a skill from aj-geddes/useful-ai-prompts that systematizes JavaScript and CSS bundle reduction through code splitting, tree shaking, and build-time optimization techniques. It applies during build process tuning, bundle analysis before deployment, and performance baseline improvements when downloads, parse time, or execution time regress. Developers reach for it when Lighthouse or webpack/vite reports show oversized chunks or slow first loads, especially on slower networks. The skill includes quick-start steps, reference guides, and best-practice checklists rather than a single framework lock-in. Use it when shipping frontend changes that must meet performance budgets.505installs78Oauth Implementationoauth-implementation is a Claude skill from aj-geddes/useful-ai-prompts that guides secure auth system construction using OAuth 2.0 and OpenID Connect with JWT access tokens, refresh tokens, and session management. It applies when building user authentication, third-party API authorization, or single sign-on across web and mobile clients. The skill includes overview, quick start, reference guides, and best practices for token lifecycle and secure flows. Developers reach for oauth-implementation when adding login to a new API, integrating an identity provider, or replacing ad-hoc session cookies with standards-based OIDC and JWT patterns.504installs79Database Schema Documentationdatabase-schema-documentation is an agent skill from aj-geddes/useful-ai-prompts for creating comprehensive database schema documentation from existing or planned schemas. The skill produces entity relationship diagrams, table definitions, index listings, constraint documentation, and data dictionaries that onboard engineers faster. Developers reach for database-schema-documentation when a schema lacks readable docs, when onboarding requires ERD visuals, or when migrations need accompanying reference material. Output is structured for both human readers and downstream tooling that consumes schema metadata.503installs80Database Backup Restoredatabase-backup-restore is an agent skill from aj-geddes/useful-ai-prompts that guides comprehensive backup and disaster recovery planning for production databases. The skill covers backup types, retention policies, automated backup setup, restore testing, and recovery time objectives including RTO and RPO targets. Developers reach for database-backup-restore when creating backup plans, validating restore procedures, or automating scheduled snapshots before an incident occurs. The workflow emphasizes tested recovery paths so teams can meet defined recovery windows rather than discovering gaps during outages.501installs81Caching Strategycaching-strategy is an aj-geddes/useful-ai-prompts skill for designing multi-layer caches that shrink database query volume and speed API responses under traffic spikes. The skill covers Redis and Memcached application caches, CDN edge caching for static and semi-static assets, TTL selection, and invalidation patterns that prevent stale reads after writes. Developers reach for caching-strategy when endpoints show repeated hot-key queries, p95 latency climbs, or origin databases saturate during peak load. Guidance includes quick-start patterns, reference architectures, and best practices for choosing what to cache, how long to keep it, and how to bust entries safely when upstream data changes.499installs82Memory Optimizationmemory-optimization is an aj-geddes/useful-ai-prompts skill focused on diagnosing and reducing heap consumption, memory leaks, and garbage-collection pressure. Developers reach for it when services, mobile clients, or CLI tools spike memory under load or during long-running sessions and need structured profiling guidance rather than ad-hoc fixes. The skill supports performance work across backend services and client runtimes where RSS growth, retained objects, or GC thrashing degrade stability. Use it during profiling passes, pre-release performance reviews, or incident response where memory is the bottleneck. It complements CPU profiling by targeting allocation patterns, leak sources, and GC tuning strategies.494installs83Real Time Featuresreal-time-features is a backend architecture skill from aj-geddes/useful-ai-prompts that helps developers choose and design real-time update patterns for multi-client applications. The skill covers WebSocket bidirectional channels, Server-Sent Events for server-push streams, and pub/sub fan-out for notifications, live dashboards, chat, and collaborative editing. A coding agent applies it when you need connection lifecycle, scaling, and channel-selection guidance rather than generic API design. Developers reach for real-time-features when adding live data to SaaS dashboards, in-app messaging, or shared document editing and want structured prompts instead of ad-hoc stack decisions.493installs84Web Performance Auditweb-performance-audit is a Claude Code skill from aj-geddes/useful-ai-prompts that walks developers through comprehensive web performance audits. The skill structures lab and field measurement of Core Web Vitals—LCP, FID, CLS, and FCP—with concrete good and poor thresholds, then maps findings to prioritized fixes for images, JavaScript bundles, caching, and mobile networks. It ships four reference guides covering performance metrics, analysis process, optimization strategies, and continuous monitoring workflows. Developers reach for web-performance-audit after major frontend changes, when users report slowness, during SEO tuning, or while setting performance budgets before launch. The workflow emphasizes regular measurement, realistic targets, slow-network testing, and documenting improvements rather than one-off tuning without baseline data or ongoing monitoring. The Quick Start section encodes LCP, FID, and CLS good-versus-poor thresholds in YAML so agents compare lab runs against Google guidance. Best-practice checklists warn against optimizing a single metric, ignoring field data, or skipping mobile throttling during audits.493installs85Integration Testingintegration-testing is a Testing & QA skill from aj-geddes/useful-ai-prompts that guides agents through designing and running tests beyond unit isolation. The skill covers component interaction validation, API endpoint testing, database operation checks, and external service communication patterns with reference guides and best practices. Unlike unit tests that mock dependencies, integration tests exercise real boundaries between modules and services. Developers reach for integration-testing when validating REST or GraphQL APIs, ORM database layers, message queues, or third-party SDK calls need end-to-end component verification before a release candidate ships.492installs86Design System Creationdesign-system-creation is a Design & UI/UX skill from aj-geddes/useful-ai-prompts that builds comprehensive design systems with components, patterns, and guidelines to keep interfaces consistent as products scale. The overview defines a design system as a structured set of components, principles, and rules that accelerate development and improve quality, and the when-to-use section cites multiple product interfaces, scaling design consistency, and reducing redundant UI work. A developer reaches for design-system-creation when bootstrapping token sets, component specs, usage patterns, and documentation for React, Vue, or other frontend stacks. The skill includes quick start, reference guides, and best practices sections for repeatable system authoring.489installs87Browser Debuggingbrowser-debugging is a structured debugging skill from useful-ai-prompts for client-side web issues. It guides developers through browser DevTools to isolate JavaScript exceptions, layout and CSS problems, slow renders, broken network requests, animation glitches, and interaction bugs. The skill includes overview, quick start, reference guides, and best practices so agents follow a repeatable inspection order instead of guessing. Use browser-debugging when a web app misbehaves in the browser and you need a methodical DevTools pass rather than random code edits.486installs88Code Generation Templatecode-generation-template is a Claude Code skill from aj-geddes/useful-ai-prompts that documents code generation techniques including template engines, AST-based transforms, project scaffolding, and automated boilerplate workflows. The skill bundles reference guides, quick-start steps, and best practices for when agents generate modules, CRUD layers, API stubs, or full project skeletons from repeatable patterns. Developers reach for code-generation-template when repetitive structure work slows feature delivery or when prompts produce inconsistent file layouts across runs. It pairs naturally with scaffolding tasks in TypeScript, Python, or polyglot repos where pattern reuse beats hand-writing every file. The README positions it for generating code, scaffolding projects, creating boilerplate, and operating template engines during active build work.485installs89Semantic Versioningsemantic-versioning is a Release Management skill from aj-geddes/useful-ai-prompts that implements semantic versioning with automated release management through conventional commits, semantic-release, and version bumping strategies. The overview ties version numbers to release significance and automated release notes generation, and the when-to-use list covers package and library releases, API versioning, and version bump automation. A developer reaches for semantic-versioning when configuring commit message conventions, CI release pipelines, changelog generation, and npm or library publish flows. The skill provides quick start, reference guides, and best practices for maintaining consistent SemVer across teams.484installs90Mobile Offline Supportmobile-offline-support is a Claude Code skill from aj-geddes/useful-ai-prompts for building offline-first mobile applications that stay usable without connectivity and reconcile data when the network returns. The skill walks through local persistence options—AsyncStorage, Realm, and SQLite—and patterns for background sync, queueing writes, and conflict resolution so React Native apps degrade gracefully offline. Developers reach for mobile-offline-support when adding reliable caching, sync-on-reconnect, or merge logic to field apps, travel tools, or any mobile product where dropped connections are common.482installs91Grpc Service Developmentgrpc-service-development is a skill from aj-geddes/useful-ai-prompts for building gRPC microservices with Protocol Buffers. It covers service contract design in .proto files and server implementations supporting unary RPC plus client streaming, server streaming, and bidirectional streaming patterns. Reference guides and best-practices sections walk through quick-start scaffolding and inter-service communication setups. Developers reach for this skill when replacing REST with gRPC, defining protobuf messages and services, or implementing streaming APIs between backend services. Output targets production-ready patterns rather than toy examples, emphasizing efficient binary serialization and strongly typed contracts across language stacks that support gRPC codegen.478installs92Network Debuggingnetwork-debugging is a skill from aj-geddes/useful-ai-prompts that structures agent-led investigation of connectivity, DNS resolution, TLS handshakes, latency spikes, and API failures. It leverages curl for HTTP probes, tcpdump for packet capture, traceroute for path analysis, and browser or proxy tools for client-side verification. Developers reach for network-debugging when services fail intermittently, endpoints time out, certificates misbehave, or API gateways return ambiguous errors. The skill fits backend and platform engineers who need a repeatable network triage playbook inside agent sessions rather than ad-hoc command guessing.476installs93Process Mappingprocess-mapping is a prompt skill from aj-geddes/useful-ai-prompts for documenting how work actually flows across people, systems, and handoffs before writing code. The skill structures discovery of actors, steps, decision points, bottlenecks, and failure modes so engineering scope reflects real operations instead of assumptions. Developers reach for process-mapping when a feature request spans multiple teams, when automation targets are unclear, or when a refactor must mirror an existing operational workflow. The output is a shared process view that informs API boundaries, state machines, and integration priorities. process-mapping suits technical leads and engineers asked to translate business workflows into software requirements without skipping operational detail.476installs94Sql Injection Preventionsql-injection-prevention is a security review skill from aj-geddes/useful-ai-prompts that guides developers through hardening database-backed APIs, ORM queries, and form inputs against SQL injection during pre-release security review. The skill applies parameterized query patterns, input validation strategies, and unsafe concatenation checks tailored to common web stack database access layers. Developers reach for sql-injection-prevention when shipping endpoints that accept user input and connect to SQL databases, especially before penetration testing or compliance audits.476installs95Microservices Architecturemicroservices-architecture is an aj-geddes/useful-ai-prompts skill for designing and implementing microservices and service-oriented architectures. It walks through bounded contexts such as Order, User, and Payment services, asynchronous communication, circuit breakers, API gateways, service discovery, database-per-service data consistency, and Istio service mesh patterns. Six reference guides cover service boundary design, communication patterns, API gateway pattern, service discovery, data consistency patterns, and service mesh with Istio, plus explicit do-and-don't lists for idempotency, correlation IDs, and chaos-ready health checks. Developers reach for microservices-architecture when splitting monoliths, defining inter-service contracts, or planning observability and failure handling for independent deployable services.471installs96Payment Gateway Integrationpayment-gateway-integration is a prompt skill from aj-geddes/useful-ai-prompts that walks developers through production payment wiring for monetized products. The skill covers gateway selection, checkout session design, server-side charge APIs, webhook signature verification, idempotent payment retries, refund flows, subscription lifecycle events, and PCI-aware patterns that keep card data off your servers. Developers reach for payment-gateway-integration when a SaaS or ecommerce feature needs real money movement and the team must avoid double charges, missed webhook events, or unsafe client-side token handling. The skill targets backend engineers adding billing to an existing app rather than teams still choosing a business model. It assumes you already have an application stack and need concrete integration steps for Stripe, PayPal, or comparable providers.469installs97Sql Query Optimizationsql-query-optimization is a skill from aj-geddes/useful-ai-prompts focused on production database performance rather than tutorial SQL. It guides rewriting expensive queries, choosing indexes, correcting join plans, and cutting latency on API handlers and reporting paths that hit Postgres, MySQL, or comparable relational engines. Developers reach for sql-query-optimization when EXPLAIN plans show full scans, nested loops blow up, or p95 endpoint times trace back to specific statements. The skill fits iterative ops work after launch—when schema exists and the goal is measurable query speedups without redesigning the entire data model.464installs98Anomaly Detectionanomaly detection is a data science skill in aj-geddes/useful-ai-prompts that walks developers through outlier detection with statistical, distance, isolation, density, and deep-learning methods. The bundled Python workflow covers Z-score, IQR, Isolation Forest, Local Outlier Factor, Elliptic Envelope, and a majority-vote ensemble across 1,000 synthetic samples, plus rolling-statistics time-series detection with matplotlib visualizations. It distinguishes point, contextual, collective, and novel-class anomaly types and documents method selection guidance for normal versus high-dimensional data. Deliverables include scored anomaly masks, method comparison charts, precision-recall curves, and deployment recommendations. Reach for anomaly detection when instrumenting fraud checks, manufacturing QC, IoT sensor monitoring, or production metric baselines where simple thresholds miss contextual spikes or collective pattern breaks.463installs99Exploratory Data Analysisexploratory data analysis is a skill from aj-geddes/useful-ai-prompts that structures quick exploration of unfamiliar datasets before feature or model work begins. It focuses on distributions, missing values, correlations, and segmented outliers so developers can judge data quality and signal strength early. Reach for exploratory data analysis when a CSV, warehouse table, or experiment log arrives without documented schema or when stakeholders ask whether a metric or ML feature is feasible. The skill guides analysis steps and interpretation rather than deploying production pipelines. It complements formal modeling skills by producing a grounded go/no-go view of the underlying data shape and anomalies.460installs100Gap Analysisgap-analysis is a useful-ai-prompts skill that structures a capability comparison across what exists today, what competitors ship, and what the target product requires. Developers invoke it before locking MVP scope or sprint backlogs to surface missing features, misaligned priorities, and over-scoped commitments. The skill outputs a prioritized gap matrix—must-have versus nice-to-have features—with rationale tied to competitive positioning and user requirements. gap-analysis prevents build-phase rework by forcing explicit scope decisions while requirements are still cheap to change.460installs101Technical Debt Assessmenttechnical-debt-assessment is a Claude Code skill in aj-geddes/useful-ai-prompts that systematically identifies, measures, and prioritizes technical debt across code, architecture, tests, documentation, security, and performance categories. The workflow scans repositories for anti-patterns such as duplicated code, long methods, missing tests, outdated dependencies, and architectural coupling, then estimates remediation effort, debt hours, and ongoing interest cost if left unfixed. A priority formula weights severity, impact, interest, and effort to produce ranked remediation lists, category breakdowns, and sprint-ready summaries for refactoring, backlog grooming, acquisition due diligence, or quality gate planning. Developers reach for technical-debt-assessment when releases slow, defect rates climb, or on-call burden rises because legacy shortcuts compound. The skill includes a TechnicalDebtAssessment registry pattern for adding debt items with severity, effort, impact, and interest fields, supporting ROI-focused conversations with engineering leadership.460installs102Api Error Handlingapi-error-handling is a prompt skill in aj-geddes/useful-ai-prompts for implementing comprehensive API error systems across Node.js and Python services. It standardizes JSON error envelopes with code, message, statusCode, requestId, timestamp, and field-level details arrays for validation failures. Quick-start snippets define an ApiError class mapping ERROR_CODES to HTTP statuses and ship four reference guides covering error codes and middleware, exponential backoff with circuit breakers, Sentry monitoring with /metrics/errors endpoints, and input validation guards. Best practices distinguish logging 5xx at ERROR versus 4xx at WARN, mandate requestId traceability, and forbid exposing stack traces or returning HTTP 200 for failures. Developers reach for this skill when debugging production incidents, adding retry logic, or unifying error shapes across microservices. Use it during API design reviews where clients need actionable validation messages and operators need observable error-rate alerts without leaking secrets in logs.457installs103Frontend Testingfrontend-testing is a prompt skill from aj-geddes/useful-ai-prompts for adding frontend test coverage before merge or release. It structures work on unit tests for utilities, component tests for UI pieces, and integration tests for hooks and user flows so regressions surface in CI instead of production. Developers reach for frontend-testing when a feature branch needs systematic test plans for React or similar UI stacks without writing boilerplate guidance from scratch. The skill encodes testing workflows agents can execute against existing component and hook files.457installs104Kpi Dashboard Designkpi-dashboard-design is a prompt skill from aj-geddes/useful-ai-prompts that helps developers and data-minded engineers draft KPI dashboard plans before touching BI tools. It structures north-star metrics, conversion funnels, retention cohorts, and threshold alerts tied to concrete business decisions so engineering teams know which charts, filters, and drill-downs to implement in Metabase, Looker, Grafana, or custom admin panels. Use kpi-dashboard-design when stakeholders ask for an executive overview or team ops board and you need a defensible metric hierarchy instead of ad-hoc SQL charts. The output is a specification-ready blueprint, not live queries.456installs105Rate Limiting Implementationrate-limiting-implementation is a backend skill from aj-geddes/useful-ai-prompts that walks developers through concrete rate-limit designs instead of vague throttling advice. The skill covers token bucket and sliding window algorithms, Redis-backed counters, HTTP middleware hooks, and per-tenant quota policies so public and multi-tenant APIs survive abuse without runaway infra bills. Developers reach for rate-limiting-implementation when adding first-class limits to REST or GraphQL gateways, internal microservices, or AI proxy endpoints where burst traffic and shared keys need enforced ceilings. Expect implementation-ready patterns for middleware placement, header semantics, and storage choices rather than high-level security checklists alone.456installs106Webhook Developmentwebhook-development is a prompt skill from aj-geddes/useful-ai-prompts that walks developers through production-grade inbound webhook endpoints. It addresses signature or HMAC verification, idempotency keys for duplicate delivery, retry-safe handlers, and explicit JSON payload contracts for providers like Stripe, GitHub, or custom SaaS partners. Use webhook-development when adding event-driven features—subscription billing updates, outbound notification fan-out, or third-party sync—where dropped or double-processed events would cause revenue or data integrity bugs. The skill emphasizes handler design and operational edge cases, not just route scaffolding.456installs107Ml Model Trainingml model training is an agent skill from aj-geddes/useful-ai-prompts that walks developers through full machine learning training workflows. The skill covers data preparation, feature engineering, algorithm selection, hyperparameter tuning, cross-validation, and exporting deployment-ready model artifacts for production inference. Developers reach for ml model training when a predictive model must move from raw datasets to validated, reproducible training outputs rather than notebook experiments alone. Agents apply structured steps for train-test splits, metric selection, tuning strategies, and packaging serialized models with preprocessing pipelines. Outcomes include tuned model files, validation reports, and inference-ready artifacts suitable for API or batch serving endpoints.455installs108Prometheus Monitoringprometheus-monitoring is a skill from aj-geddes/useful-ai-prompts that guides Prometheus-based production observability setup. It covers application metric instrumentation, exporter configuration, scrape job definitions, recording rules, and PromQL alert expressions so teams can detect regressions in running services. Developers reach for prometheus-monitoring when services are deployed and need standardized metrics pipelines instead of ad hoc logging, especially when on-call needs actionable alerts tied to scrape targets and recorded aggregates.455installs109Api Gateway Configurationapi-gateway-configuration is a prompt skill in aj-geddes/useful-ai-prompts for designing API gateway layers that centralize authentication, rate limiting, routing, and request transformation. The quick-start Kong YAML example defines a user-service upstream, /api/users routes, rate-limiting at 100 requests per minute, JWT validation, and CORS origins. Five reference guides cover Kong, Nginx, AWS API Gateway, Traefik, and Node.js gateway implementations with production-focused patterns. Best practices urge gateway-level auth, global rate limits, backend health checks, response caching where safe, circuit breakers, HTTPS enforcement, and comprehensive access logging while warning against exposing internal IPs or skipping validation. Developers reach for this skill when standing up reverse proxies for microservices, enforcing quotas, or versioning public APIs behind a single edge. Use it during architecture passes where TLS termination, plugin configuration, and upstream timeouts must be decided before services go live.454installs110React Native Appreact-native-app is an aj-geddes/useful-ai-prompts agent skill for building cross-platform mobile apps with React Native using modern patterns. The skill documents React Navigation stack and tab setups, Redux and Context API state management, Axios API integration, functional components with hooks, and platform-specific handling across 4 reference guides in the references directory. Developers reach for react-native-app when bootstrapping iOS and Android apps from a shared JavaScript codebase, wiring navigation flows, FlatList performance, and environment-based API endpoints. It fits teams leveraging web React experience who need structured mobile scaffolding with TypeScript, error boundaries, and dual-platform testing checklists.454installs111Security Headers Configurationsecurity-headers-configuration is a Security skill from aj-geddes/useful-ai-prompts that walks developers through setting Content-Security-Policy, Strict-Transport-Security, X-Frame-Options, Referrer-Policy, and companion HTTP headers on web applications. The skill explains which directives block inline scripts, enforce HTTPS, prevent clickjacking, and control referrer leakage so teams can harden Express, Next.js, nginx, or CDN configs before a security review. Developers reach for security-headers-configuration when launching a SaaS or API surface and need a structured checklist instead of copying generic header snippets. It focuses on pre-production header design rather than ongoing WAF tuning or penetration testing.454installs112Cicd Pipeline Setupcicd-pipeline-setup is a skill from aj-geddes/useful-ai-prompts that guides creation of CI/CD pipelines covering lint, test, artifact build, and staged promotion across staging and production. It emphasizes gates, caching, and rollback-friendly deploy steps so failures surface before customers see broken builds. Developers reach for cicd-pipeline-setup when bootstrapping GitHub Actions, GitLab CI, or similar workflows, or when an existing pipeline lacks test coverage, artifact promotion, or safe rollback paths. The skill outputs pipeline structure and step recommendations rather than executing cloud provisioning itself. It pairs well with repository testing skills and release checklists when a team moves from manual deploys to automated promotion.453installs113Application Loggingapplication-logging is a backend observability skill in aj-geddes/useful-ai-prompts for instrumenting services with structured logs, correlation IDs, level discipline, and centralized analysis. The quick-start ships a Winston logger with timestamped JSON formatting, service and environment defaultMeta, console and error.log transports, and guidance on LOG_LEVEL configuration. Six reference guides cover Node.js Winston patterns, Express HTTP request logging, Python structured logging, Flask integration, ELK stack setup, and Logstash configuration. Best-practice rules require request IDs, sensitive-data redaction, rotation, and centralized aggregation while forbidding secret logging and unbounded files. Reach for application-logging when standing up a new API, hardening production debuggability, or migrating from unstructured printf logs to JSON streams compatible with ELK or similar aggregators.452installs114Database Migration Managementdatabase-migration-management is a prompt skill in aj-geddes/useful-ai-prompts for robust schema versioning across PostgreSQL and MySQL environments. The quick-start SQL defines schema_migrations and migration_logs tables plus a record_migration function tracking version, name, duration_ms, checksum, status, and rollback timestamps. Five reference guides cover adding columns, renaming columns, non-blocking index creation, data transformations, and table structure changes with production deployment patterns. Best practices emphasize reversible migrations, testing before production, and coordinated multi-environment rollouts while avoiding destructive changes without rollback plans. Developers reach for this skill when adding indexes online, backfilling columns, or designing migration frameworks for services that cannot tolerate schema drift between staging and production. Use it during schema reviews where deployment ordering, checksum validation, and rollback execution must be explicit before ALTER statements ship.452installs115Progressive Web Appprogressive-web-app is a skill from aj-geddes/useful-ai-prompts that walks developers through building installable Progressive Web Apps. It covers web app manifests, service worker registration, offline caching strategies, push notification setup, and responsive app-shell UX patterns across browsers. Developers reach for progressive-web-app when a web product should behave like an installable app with offline resilience and mobile-friendly shells, and they need structured guidance instead of piecing together manifest, worker, and caching steps from scattered documentation.452installs116Causal Inferencecausal inference is a useful-ai-prompts skill that helps developers move beyond correlation to estimate treatment effects when randomized experiments are not feasible. The skill covers six key concepts including treatment, outcome, confounding, causal graphs, selection bias, and treatment effect types, plus five causal methods: randomized controlled trials, propensity score matching, difference-in-differences, instrumental variables, and causal forests. A bundled Python walkthrough generates an n=1000 observational dataset, demonstrates a biased naive comparison, and walks through propensity-based correction. Developers reach for causal inference when evaluating policy interventions, marketing campaigns, product changes, or heterogeneous user-segment effects before betting engineering or growth resources.451installs117Changelog Maintenancechangelog-maintenance is an aj-geddes/useful-ai-prompts agent skill for creating and updating structured changelogs and release notes using Keep a Changelog and Semantic Versioning conventions. It supplies CHANGELOG.md templates with Added, Changed, Deprecated, Removed, Fixed, and Security sections, plus release-note drafts with highlights, breaking changes, migration guides, and security patch guidance. Developers invoke it for version history documentation, deprecation notices, CVE-style security entries, and semver-friendly customer-facing announcements. The skill emphasizes dating releases (YYYY-MM-DD), linking issues and PRs, and separating security fixes with recommended upgrade actions. Outputs help maintainers keep releases transparent for users and API integrators without memorizing format rules each cut. Install via npx skills add aj-geddes/useful-ai-prompts --skill changelog-maintenance when preparing tagged releases or publishing integrator-facing notes that must follow industry-standard changelog structure, semver migration guidance, dated release sections, and linked PR references.451installs118Grafana Dashboardgrafana-dashboard is an agent skill from aj-geddes/useful-ai-prompts that helps developers design production Grafana dashboards for service observability. The skill guides panel layout, metric queries, visualization choices, and alert thresholds for health signals like latency, error rates, saturation, and business KPIs. Agents use it when a running service lacks clear operational visibility or when on-call engineers need faster incident triage through structured dashboards. Developers reach for grafana-dashboard when Prometheus, Loki, or other datasource-backed monitoring must translate raw metrics into SLO-friendly views and paging rules. The workflow produces dashboard JSON definitions, query snippets, and alert configurations ready to import or refine in Grafana.451installs119Interaction Designinteraction-design is an agent skill in aj-geddes/useful-ai-prompts that helps coding agents specify how interfaces behave—not just how they look—across loading, success, error, empty, and hover states. It guides micro-interaction choices, transition timing, feedback patterns, and cross-screen flow consistency so components feel responsive and accessible to keyboard and screen-reader users. Developers reach for interaction-design when polishing dashboards, forms, and mobile views where ambiguous state changes confuse users or violate accessibility expectations. The skill fits feature work where agents might otherwise ship static layouts without skeleton loaders, focus management, or toast confirmation patterns. Catalog metadata records 401 installs. Use it when defining interaction specs before implementation, reviewing UX gaps in existing React or Vue screens, or documenting state diagrams agents can translate into component code. The skill also covers focus order, aria-live feedback, and motion-reduction considerations so agents do not ship flashy transitions that break keyboard navigation or screen-reader announcements.451installs120Neural Network DesignNeural Network Design is a Data Science & ML skill from aj-geddes/useful-ai-prompts for architecting neural networks across five core types: MLPs, CNNs, LSTMs, Transformers, and ResNets. Runnable PyTorch examples include an MLP with three hidden layers (512, 256, 128), a three-block CNN with BatchNorm and Dropout, a two-layer LSTM, a multi-head Transformer with three blocks, and a ResNet with four residual stages. The skill covers design principles for depth versus width, skip connections, batch and layer normalization, dropout regularization, and activation choices like ReLU and GELU. A TensorFlow Keras Sequential model and parameter-count comparison chart help developers pick architectures for tabular, image, sequence, or NLP tasks. Reach for Neural Network Design when custom topology decisions—not off-the-shelf model APIs—determine model quality.451installs121Feature Engineeringfeature-engineering is a Data Science skill in aj-geddes/useful-ai-prompts that guides agents through creating and selecting ML features from raw tabular data. It covers six technique families: categorical encoding, numeric scaling, polynomial features, interaction terms, domain-specific business transforms, and temporal derivations from dates. The bundled Python walkthrough uses pandas, numpy, sklearn StandardScaler, MinMaxScaler, RobustScaler, OneHotEncoder, OrdinalEncoder, PolynomialFeatures, and ColumnTransformer pipelines with twelve worked sections from encoding through binning and missing-value imputation. Key principles stress domain knowledge, removing redundant columns, appropriate scaling per algorithm, and avoiding data leakage from future information. Deliverables include an engineered dataset, transformation documentation, correlation analysis, distribution comparisons, feature importance rankings, and reusable preprocessing pipeline code. Developers reach for feature-engineering when model performance stalls on raw columns, categorical fields need encoding, scales differ wildly, or skewed distributions require log transforms before training.450installs122Stakeholder Communicationstakeholder-communication is an agent skill from aj-geddes/useful-ai-prompts for writing stakeholder-ready project communication. It helps developers and tech leads produce status updates, executive summaries, and alignment messages that connect engineering progress—milestones, risks, blockers—to business outcomes executives and partners care about. Developers reach for stakeholder-communication before steering meetings, investor updates, or cross-functional syncs when raw commit logs or ticket dumps would confuse non-technical readers. The skill emphasizes outcome framing, concise narrative structure, and audience-appropriate tone so technical teams spend less time rewriting updates and more time delivering features.450installs123Unit Testing Frameworkunit-testing-framework is a useful-ai-prompts skill that helps developers bootstrap or expand unit test infrastructure with consistent patterns, mock strategies, and coverage targets. The skill guides framework selection, test file structure, assertion style, and isolation techniques so new features ship with regression protection instead of ad-hoc test additions. Developers invoke it before merging significant features or cutting a release candidate when test gaps would block confident deployment. Output includes scaffolded test files, mock patterns for async dependencies, and coverage goals aligned to critical code paths.450installs124Test Automation Frameworktest-automation-framework is a skill from aj-geddes/useful-ai-prompts that guides design of a full test automation stack before new features land. It structures test layers, shared fixtures, CI pipeline hooks, and reporting so unit, integration, and end-to-end suites run on every change rather than relying on manual spot checks. The skill emphasizes repeatable patterns—where tests live, how data is seeded, how failures surface in CI, and how teams onboard new cases—so coverage scales with the product. Reach for test-automation-framework when bootstrapping QA for a greenfield service, refactoring a flaky suite, or formalizing regression gates ahead of continuous delivery. It produces an architecture blueprint and CI integration plan developers can implement with their chosen runner such as Jest, Pytest, or Playwright.449installs125Database Performance Debuggingdatabase-performance-debugging is a prompt skill from aj-geddes/useful-ai-prompts for diagnosing production database performance regressions. It structures investigation of slow queries, missing indexes, lock contention, and connection pool exhaustion when latency spikes or cloud database costs climb unexpectedly. Developers reach for database-performance-debugging during incident triage or cost reviews when ORM-generated SQL, index gaps, or pool saturation need systematic analysis rather than guesswork. The skill encodes DBA-style debugging prompts for agent-assisted root-cause work on live systems.447installs126Ssl Certificate Managementssl-certificate-management is a useful-ai-prompts skill for automated SSL/TLS certificate lifecycle management across infrastructure. It covers HTTPS enablement, renewal automation, multi-domain and wildcard certificates, expiry alerting, zero-downtime rotation, and internal PKI with Let's Encrypt, AWS ACM, and Vault integrations. A quick-start cert-manager ClusterIssuer YAML demonstrates HTTP-01 and DNS-01 ACME solvers, and five reference guides in references/ cover Let's Encrypt with cert-manager, AWS ACM, monitoring and renewal, automated renewal workflows, and certificate pinning. Developers reach for this skill when standing up TLS on Kubernetes ingress, rotating expiring certs on load balancers, or replacing manual openssl renewals with automated pipelines.447installs127Test Data Generationtest-data-generation is a skill from aj-geddes/useful-ai-prompts that produces realistic synthetic datasets when production copies are unavailable or non-compliant. It covers unit, integration, and QA scenarios where fixtures are too thin, privacy policies block real records, or edge cases need diverse data at scale. The skill guides schema-aware generation—valid formats, boundary values, relational consistency, and volume profiles—so tests exercise realistic paths without leaking PII. Reach for test-data-generation when bootstrapping a new service schema, expanding coverage for rare states, or unblocking CI that currently mocks only happy-path rows. Output includes seed files, factory definitions, or bulk JSON/CSV artifacts teams can wire into test runners and staging environments.445installs128Api Reference Documentationapi-reference-documentation is a skill from aj-geddes/useful-ai-prompts that drafts full API reference pages for developer portals. It structures endpoint tables, authentication examples, request and response schemas, and error code matrices so public API docs read consistently for integrators. Developers reach for api-reference-documentation when an API surface exists or is stabilizing and portal pages must be generated or refreshed faster than hand-writing every endpoint section, especially before external developers need self-serve integration guidance.443installs129Computer VisionComputer Vision is a Data Science & ML agent skill from aj-geddes/useful-ai-prompts that walks through six core CV tasks—classification, detection, semantic and instance segmentation, pose estimation, and face recognition—using PyTorch and TensorFlow. The skill ships runnable Python for a CNN classifier, an object-detection head, and a U-Net segmentation model, plus transfer-learning patterns with ResNet18 and torchvision transforms. It documents popular architectures including YOLO, Faster R-CNN, RetinaNet, U-Net, DeepLab, and Vision Transformer, and lists evaluation metrics such as mAP, IoU, and Dice coefficient. Developers reach for Computer Vision when adding image understanding, embedding extraction, or detection APIs to a backend or ML service and need architecture selection, preprocessing, and evaluation guidance in one place.443installs130Stress Testingstress-testing is an aj-geddes/useful-ai-prompts Claude Code skill for capacity validation from a library of 260+ skills. It pushes systems beyond normal operating load to identify breaking points, failure modes, auto-scaling behavior, and recovery after stress. The quick-start k6 script defines progressive stages ramping from 100 to 400 virtual users over timed sustain periods with p99 latency and 5% error-rate thresholds. Six reference guides cover k6 stress testing, spike testing, soak/endurance testing, JMeter stress tests, auto-scaling validation, and breaking-point analysis. Best practices require production-like environments, gradual load increases, resource monitoring, recovery testing, and documenting limits while warning against unsafeguarded production tests. Developers reach for stress-testing before release when APIs or web services need validated saturation limits and graceful degradation plans under burst traffic.443installs131User Persona Creationuser-persona-creation is an agent skill from aj-geddes/useful-ai-prompts for defining research-backed user personas before product decisions harden. It guides developers and product thinkers through goals, pains, and usage scenarios so positioning, roadmap bets, and messaging aim at concrete segments instead of vague everyone audiences. Teams reach for user-persona-creation during discovery workshops, PRD drafting, or messaging reviews when assumptions need explicit persona anchors backed by research notes or interview themes. The skill outputs structured persona artifacts—segment names, motivations, friction points, and scenario narratives—that downstream specs, marketing copy, and feature prioritization can reference consistently.442installs132Form Validationform-validation is a skill from aj-geddes/useful-ai-prompts that guides agents to implement comprehensive form validation with client-side rules, server-side synchronization, and real-time error feedback. It ships a TypeScript quick-start with LoginFormData and RegisterFormData interfaces plus a React Hook Form register and handleSubmit skeleton, and five reference guides covering React Hook Form, Formik with Yup, Vue Vee-Validate, custom validator hooks, and server-side validation integration. Developers invoke it for signup and checkout flows, multi-step forms, complex cross-field rules, and accessible error messaging—not for non-form API validation alone. The skill lives in the useful-ai-prompts collection of 260+ skills installable via npx skills add, making it a pattern library agents load when users mention form validation, react-hook-form, or real-time field errors.441installs133Statistical Hypothesis Testingstatistical-hypothesis-testing is an aj-geddes/useful-ai-prompts Claude Code skill for data-driven product decisions from a library of 260+ skills. It frames null and alternative hypotheses, significance level alpha typically 0.05, and p-value interpretation for A/B tests and metric comparisons. Covered tests include independent and paired t-tests, one-way ANOVA, chi-square contingency, Mann-Whitney U, Kruskal-Wallis, Welch's t-test, Levene's variance test, and Shapiro-Wilk normality checks. The Python scipy implementation calculates Cohen's d effect sizes, 95% confidence intervals, bootstrap CIs, Bonferroni correction for multiple testing, eta-squared for ANOVA, and statistical power analysis. Deliverables include test statistics, p-values, effect sizes, distribution visualizations, and business interpretation guidelines. Developers reach for statistical-hypothesis-testing when experiment results need rigorous significance testing beyond dashboard averages.440installs134Reactive Programmingreactive-programming is a prompt-driven skill from aj-geddes/useful-ai-prompts that teaches Rx-style reactive programming patterns for async UI events, server data pipelines, backpressure handling, and composable stream operators. The skill helps developers refactor callback-heavy or Promise-chained code into observable pipelines using map, filter, mergeMap, switchMap, and debounce patterns familiar from RxJS, RxJava, and ReactiveX ecosystems. Reach for reactive-programming when building real-time dashboards, autocomplete search, WebSocket feeds, or multi-step async workflows where event composition and cancellation matter. Output includes observable chain designs, operator selection rationale, marble-diagram explanations, and refactored TypeScript or Java stream code snippets.439installs135Api Paginationapi-pagination is a Backend & APIs skill from aj-geddes/useful-ai-prompts for implementing scalable pagination on collection endpoints. It documents three strategies—offset/limit, cursor-based, and keyset pagination—with six detailed reference guides covering offset/limit, cursor, keyset, search pagination, response formats, and Python SQLAlchemy implementations. The quick-start example shows a Node.js /api/users route capping limit at 100, returning page, total, totalPages, and hasNext metadata alongside data arrays. Best practices warn against offset pagination on billions of rows, unlimited page sizes, and changing sort order mid-pagination. Developers reach for api-pagination when building search results, infinite scroll backends, or REST list endpoints that must stay performant at scale.438installs136Api Response Optimizationapi-response-optimization is a useful-ai-prompts agent skill focused on faster API responses through payload trimming, caching, compression, and query efficiency. The quick-start contrasts bloated user JSON exposing password_hash, SSN, and unused nested geo fields against a minimal id-name-email response shape. Four reference guides cover response-payload-optimization, caching-strategies, compression-performance, and an optimization-checklist with concrete implementation patterns. Developers reach for api-response-optimization when endpoints show high CPU, large response bodies, scaling bottlenecks, or measurable latency regressions before production load. The skill emphasizes selecting only required GraphQL or REST fields, setting Cache-Control and ETag headers, enabling gzip or Brotli compression, and eliminating N+1 database access patterns. Best practices warn against sending sensitive columns, shipping unused metadata, and skipping response-size monitoring during load tests.438installs137Code Documentationcode-documentation is a skill from aj-geddes/useful-ai-prompts in a library of 260+ agent skills that teaches agents to document functions, classes, modules, and types with language-specific standards. It covers JSDoc for JavaScript and TypeScript, Python docstrings, JavaDoc, inline comments, thrown exceptions, and usage examples, with six reference guides under references/ for functions, classes, modules, and type definitions. The parent repository applies eleven quality gates to its prompt catalog, but this skill focuses on executable documentation patterns developers paste or generate beside real code. Developers reach for code-documentation when annotating public APIs, adding @param and @returns blocks, or generating module overviews—not when bootstrapping a full docs/ tree or writing marketing copy.438installs138Container Debuggingcontainer-debugging from aj-geddes/useful-ai-prompts provides structured agent prompts for diagnosing failing Docker and Kubernetes containers. The workflow guides systematic investigation across container logs, interactive exec shells, health and readiness probe results, and image-layer inspection to isolate crash loops, OOM kills, misconfigured entrypoints, and networking faults. Developers reach for container-debugging when pods or compose services exit unexpectedly, probes fail intermittently, or deployments roll back without an obvious application stack trace. The skill fits operations and on-call contexts where kubectl and docker CLI commands must be applied in a consistent order rather than ad-hoc guessing. Expect command-shaped prompts and checklists agents can follow to narrow root cause before code changes ship.437installs139Database Indexing Strategydatabase-indexing-strategy is an agent skill from aj-geddes/useful-ai-prompts for planning indexes on PostgreSQL and MySQL workloads. It covers B-tree, Hash, GiST, and BRIN index types, plus composite, partial, filtered, and expression indexes with concrete CREATE INDEX examples. Three reference guides ship in the skill's references/ directory for PostgreSQL types, MySQL types, and single- versus multi-column patterns. Use it when EXPLAIN shows sequential scans, lock contention rises on hot tables, or new queries need index coverage without bloating storage. The skill emphasizes maintenance and monitoring alongside creation so indexes stay aligned with real access patterns.437installs140Nosql Database Designnosql-database-design is a prompt-driven skill from aj-geddes/useful-ai-prompts that guides schema design for document, key-value, and wide-column NoSQL databases. The skill helps developers choose partition keys, secondary indexes, and query access patterns that avoid hot partitions and support predictable read/write throughput on DynamoDB, MongoDB, Cassandra, and similar stores. Reach for nosql-database-design when modeling multi-tenant SaaS data or high-volume API backends where relational normalization is a poor fit and access-pattern-first design is required. Output includes partition key recommendations, index plans, entity relationship sketches, and query pattern tables developers can implement in Terraform, CloudFormation, or ORM migration files.436installs141Uptime Monitoringuptime-monitoring is an aj-geddes/useful-ai-prompts Claude Code skill for production availability from a library of 260+ skills. It sets up shallow and deep health endpoints, uptime heartbeat monitors, public status page APIs, and Kubernetes liveness and readiness probes. The quick-start Express example exposes /health with uptime seconds and /health/deep checking database, cache, and external API dependencies with structured status objects. Five reference guides cover health check endpoints, Python health checks, uptime monitors with heartbeat, public status page APIs, and Kubernetes health probes. Best practices require checking all critical dependencies, appropriate timeouts, response time tracking, check history storage, and alerting on status changes while avoiding sensitive data exposure. Developers reach for uptime-monitoring after launch when services need SLA dashboards and incident-ready availability visibility.436installs142Accessibility Complianceaccessibility-compliance is an aj-geddes/useful-ai-prompts Claude Code skill from a library of 260+ skills and 488+ validated prompts. It implements WCAG 2.1/2.2 AA and AAA patterns including semantic HTML, ARIA usage, keyboard navigation, focus management, screen reader announcements, and color contrast validation at a 4.5:1 minimum for normal text. Six reference guides cover semantic HTML with ARIA, React accessible components, keyboard handlers, contrast validators, screen reader live regions, and focus trapping. Quick-start examples contrast non-semantic div buttons with proper button elements, tabindex handling, and labeled form fields. The skill supports audits for NVDA, JAWS, and VoiceOver compatibility and ADA or Section 508 alignment. Developers reach for accessibility-compliance before release or during pre-ship design review when components need measurable a11y remediation rather than ad-hoc fixes.434installs143Web Performance Optimizationweb-performance-optimization is an agent skill from aj-geddes/useful-ai-prompts for improving front-end load performance before launch. It guides audits of Core Web Vitals—LCP, INP, and CLS—plus JavaScript bundle weight, HTTP caching, CDN configuration, and critical render paths on mobile networks. Use it when Lighthouse or Search Console flags regressions, conversion drops trace to slow first paint, or SEO ranking depends on passing CWV thresholds. The skill connects measurement to concrete fixes: code splitting, lazy loading, cache headers, font and image delivery, and eliminating render-blocking resources rather than generic best-practice lists.434installs144Background Job Processingbackground-job-processing is a useful-ai-prompts agent skill for building robust asynchronous job systems with distributed queues, worker pools, scheduling, and monitoring. The quick-start configures a Celery app with Redis broker and result backend, JSON serializers, 30-minute hard and 25-minute soft task time limits, and named task queues via kombu Exchange and Queue objects. Five reference guides cover Python Celery and Redis, Node.js Bull Queue, Ruby Sidekiq, job retry and error handling, and monitoring observability patterns. Best practices require task timeouts, exponential backoff retries, idempotent handlers, job priorities, dead-letter queues, and queue-depth monitoring while warning against unbounded retries and blocking operations inside workers. Developers reach for background-job-processing when moving email sends, report exports, dataset processing, or recurring cron work out of synchronous HTTP handlers into durable worker infrastructure.432installs145Frontend State Managementfrontend-state-management is a useful-ai-prompts skill that helps developers choose and implement state management approaches when React, Vue, or similar UIs exceed local useState or component props. The skill evaluates shared data needs, async data flows, and feature boundaries to recommend patterns such as context providers, Zustand stores, Redux slices, or query-cache layers. Developers reach for frontend-state-management when prop drilling, stale shared state, or race conditions appear during feature growth. Output includes concrete implementation guidance—store structure, selector patterns, and async middleware choices—tailored to the project's existing framework stack.432installs146Incident Response Planincident-response-plan is a prompt-driven agent skill from aj-geddes/useful-ai-prompts that generates structured incident response runbooks for production outages and security events. The skill walks through detection signals, on-call roles, stakeholder communications, containment steps, recovery procedures, and post-incident review templates so SRE and backend teams can document repeatable response paths. Developers reach for incident-response-plan when launching or operating APIs and SaaS services that need documented escalation, comms channels, and rollback procedures rather than ad-hoc Slack threads during Sev-1 events. Output artifacts include role matrices, communication templates, containment checklists, and postmortem outlines suitable for Confluence, Notion, or internal wiki pages.432installs147Git Workflow Strategygit-workflow-strategy is a Claude Code skill from aj-geddes/useful-ai-prompts that standardizes how engineering teams use Git during active development. The skill compares GitFlow, GitHub Flow, and Trunk-Based Development, then walks through concrete commands such as git flow feature start, release finish, and hotfix finish with commit-message examples. Three reference guides cover GitFlow setup, merge-strategy scripts, and collaborative code-review workflows, plus DO/DON'T rules like keeping feature branches under three days and requiring review before merging to main. Developers reach for git-workflow-strategy when onboarding a repository, planning CI/CD branch triggers, or resolving merge-policy disagreements before they slow releases. The skill pairs procedural bash examples with structured reference markdown so agents can recommend a workflow matched to release frequency, branch protection needs, and hotfix procedures without inventing ad hoc Git conventions.431installs148Cross Platform Compatibilitycross-platform-compatibility is an aj-geddes/useful-ai-prompts agent skill for writing and auditing code that works across Windows, macOS, and Linux desktop environments plus mobile considerations. It covers platform-independent path construction with Node path and os modules, environment and architecture detection, platform-specific dependencies, shell command portability, line endings, file permissions, process management, character encoding, and cross-platform build configuration. The skill ships quick-start TypeScript examples contrasting hardcoded C:\ and /home paths with path.join and path.resolve patterns, plus 11 reference guides in references/ including file-path-handling, platform-detection, shell-commands, and testing-across-platforms. Developers reach for cross-platform-compatibility when building CLI tools, desktop apps, or release pipelines that must not break on path separators, shells, or OS-specific APIs across target platforms.430installs149Model Hyperparameter Tuningmodel-hyperparameter-tuning is an ML experimentation prompt skill in aj-geddes/useful-ai-prompts for data scientists and ML engineers improving model performance during training. The skill structures hyperparameter search strategies, configures cross-validation folds to detect overfitting, and sets up reproducible experiment tracking so accuracy gains are validated rather than lucky splits. Developers reach for model-hyperparameter-tuning when baseline model metrics plateau and systematic tuning—learning rates, regularization, tree depth, or architecture knobs—needs disciplined search and logged comparisons before selecting a production candidate.430installs150Aws Cloudfront Cdnaws-cloudfront-cdn is a useful-ai-prompts skill that guides developers through AWS CloudFront CDN setup for production web and API workloads. The skill covers distribution creation, origin configuration for S3 or custom backends, TLS certificate attachment, cache behavior tuning, and cache invalidation workflows so static assets and API responses reach users faster at the edge. Developers reach for aws-cloudfront-cdn when a SaaS or API app is ready to leave single-region hosting and needs global edge caching with controlled cache keys and HTTPS termination. The skill focuses on AWS-native CDN patterns rather than generic caching theory.429installs151Dns Managementdns-management is an aj-geddes/useful-ai-prompts skill from a library of 259 specialized skills that guides agents through production DNS strategies across AWS Route53, Azure DNS, and CloudFlare. It covers domain and subdomain routing, TTL tuning, weighted canary routing, geographic load balancing, multi-region failover, CDN integration, health-check routing, and zero-downtime migrations. Reference guides include AWS Route53 configuration, DNS failover scripts, CloudFlare DNS setup, and DNS monitoring validation under the skill references directory. Install with `npx skills add aj-geddes/useful-ai-prompts --skill dns-management` for Claude Code, Cursor, or compatible agents. Developers reach for dns-management when launching a product URL, migrating regions, or standing up disaster-recovery failover—not during everyday application coding or local hostname tweaks. Best practices emphasize health checks with failover, documented change control, and avoiding risky DNS edits during active production incidents or outages.429installs152Batch Processing Jobsbatch-processing-jobs is an aj-geddes/useful-ai-prompts Claude Code skill for scalable background processing from a library of 260+ skills. It architects job queues, cron schedulers, distributed workers, and retry policies for ETL pipelines, scheduled report generation, email campaigns, data imports, image processing, and bulk database updates. The quick-start TypeScript example scaffolds a Bull Queue BatchProcessor with typed JobData, result queues, Redis backing, idempotency, exponential backoff, dead letter queues, and graceful shutdown. Three reference guides document Bull Queue for Node.js, Celery-style Python workers, and cron job schedulers. Best practices warn against synchronous in-request processing, unlimited retries, and large payloads stored directly in queues. Developers reach for batch-processing-jobs when APIs need async offload patterns instead of blocking primary databases during heavy transforms.428installs153Deployment Automationdeployment-automation is a DevOps skill from aj-geddes/useful-ai-prompts that designs repeatable deployment pipelines with rollbacks, environment promotion, health checks, and infrastructure-as-code. Developers invoke it when releases need to move from staging to production with automated verification, audit trails, and fast rollback paths instead of manual SSH deploys. The skill covers pipeline stages, promotion gates, post-deploy health probes, and IaC integration so releases stay low-drama under load. Reach for deployment-automation when formalizing CI/CD for the first time or replacing ad-hoc deploy scripts with auditable workflows.428installs154Xss Preventionxss-prevention is a useful-ai-prompts security skill for web applications displaying user-generated content, rich text editors, comment systems, search results, and dynamic HTML templates. It provides Node.js quick-start patterns using DOMPurify and he HTML entity encoding, with four reference guides covering Node.js, Python, React XSS prevention, and Content Security Policy configuration. Best practices emphasize encoding output by default, sanitizing rich HTML, validating URLs, using HTTPOnly cookies, and avoiding innerHTML and eval. Developers reach for xss-prevention before launch when auditing templates, comment forms, or search pages for reflected, stored, or DOM-based XSS vectors across JavaScript, Python, and React stacks.428installs155Api Changelog Versioningapi-changelog-versioning is a focused prompt skill in the aj-geddes/useful-ai-prompts collection for backend developers shipping REST or GraphQL API changes. The skill guides semver decision-making, drafts deprecation notices for retiring fields or routes, and writes changelog entries that document endpoint additions, breaking changes, and response contract updates. Developers reach for api-changelog-versioning when a PR touches public API surfaces and release notes must communicate version bumps, migration paths, and sunset timelines to API consumers before merge or tag.427installs156Csrf Protectioncsrf-protection is an aj-geddes/useful-ai-prompts skill for securing cookie-authenticated forms and state-changing HTTP operations against cross-site request forgery. The quick-start demonstrates a Node.js CSRFProtection class generating crypto.randomBytes(32) hex tokens with one-hour expiry, paired with guidance on csurf middleware integration. Five reference guides cover Node.js and Express CSRF protection, double-submit cookie pattern, Python Flask CSRF protection, frontend token wiring, and Origin or Referer header validation. Best practices require CSRF tokens on all POST, PUT, and DELETE operations, SameSite=Strict cookies, HTTPS-only transport, secure random tokens with expiration, and explicit AJAX header inclusion while warning against skipping protection for authenticated routes or storing tokens in localStorage. Developers reach for csrf-protection when building login forms, account settings, payment actions, or reviewing SPA fetch calls that mutate server state with session cookies.427installs157File Upload Handlingfile-upload-handling is a backend development skill from aj-geddes/useful-ai-prompts that guides implementation of secure multipart file uploads with storage integration, validation rules, and client progress UX. Developers invoke it when adding avatar uploads, document intake, or media attachments to web apps and REST APIs that must validate file types, enforce size limits, and stream to object storage safely. The skill covers multipart parsing, presigned URL patterns, virus-scan hooks, and frontend progress indicators. Reach for file-upload-handling when building user file intake from scratch rather than tuning an existing CDN pipeline.427installs158Circuit Breaker Patterncircuit-breaker-pattern from aj-geddes/useful-ai-prompts guides resilient integration code for external APIs, microservices, databases, and third-party services. A quick-start TypeScript example defines CircuitState CLOSED, OPEN, and HALF_OPEN with configurable failureThreshold, successThreshold, timeout, and resetTimeout plus per-dependency stats tracking. Five reference guides cover a TypeScript circuit breaker, monitoring instrumentation, Opossum-style Node.js patterns, Python implementations, and Resilience4j-style Java setups. Best practices stress per-dependency breakers, fallback functions, exponential backoff, state-transition logging, and health checks while warning against shared breakers and skipped fallbacks. Reach for circuit-breaker-pattern when wrapping HTTP clients, message consumers, or microservice calls that need graceful degradation, rate-limit protection, and timeout handling to prevent cascading outages.426installs159Sentiment Analysissentiment-analysis is a useful-ai-prompts skill that helps developers implement sentiment classification for user reviews, support tickets, and social text feeds. The skill covers lexicon-based baselines, embedding classifiers, and hosted model API integrations, plus evaluation metrics and batch processing pipelines so scores can run at scale in production. Developers reach for sentiment-analysis when a SaaS or API product needs to route negative feedback, prioritize tickets, or aggregate opinion trends from unstructured text. The skill emphasizes measurable accuracy, pipeline design, and integration hooks rather than one-off prompt experiments.426installs160Zero Trust Architecturezero-trust-architecture is a Claude Code skill in aj-geddes/useful-ai-prompts that implements the never-trust-always-verify security model for cloud-native applications. The skill bundles 3 reference guides covering a JavaScript ZeroTrustGateway with JWT RS256 verification, service mesh microsegmentation patterns, and a Python policy engine, plus validate-pipeline.sh and a pipeline.yaml CI template. Agents walk through identity verification, least-privilege access, continuous monitoring, and microsegmentation when teams ship microservices, APIs, or multi-cloud workloads facing compliance or enterprise security reviews. Developers reach for zero-trust-architecture when replacing perimeter VPN trust with identity-centric gates, hardening API paths, or documenting segmentation before regulated deployments. The SKILL.md quick start includes working gateway code and 8 DO / 5 DON'T practices so outputs become concrete access models, mesh policies, and verification flows rather than generic security checklists.426installs161Cloud Security Configurationcloud-security-configuration is a useful-ai-prompts skill that implements defense-in-depth cloud security across AWS, Azure, and GCP for developers shipping regulated or internet-facing workloads. Quick-start commands enable AWS GuardDuty threat detection, multi-region CloudTrail audit logging, and S3 bucket KMS encryption, with deeper patterns in four reference guides for AWS, Azure, GCP, and Terraform security configuration. The skill covers zero-trust IAM, MFA enforcement, service accounts, secrets management, network segmentation, and continuous monitoring aligned to GDPR, HIPAA, and PCI-DSS needs. Developers reach for cloud-security-configuration when hardening new cloud accounts, preparing compliance review, or securing multi-cloud deployments before production cutover. Best-practice guardrails warn against root credentials, secrets in code, over-permissive security groups, and disabled encryption.425installs162Dependency Managementdependency-management is an aj-geddes/useful-ai-prompts agent skill for comprehensive dependency management across JavaScript, Python, Ruby, Java, and related ecosystems. It documents npm init, npm install, npm ci, npm audit, npm outdated, semantic versioning, lock files such as package-lock.json and Gemfile.lock, peer dependency rules, monorepo strategies, and CI/CD best practices through ten reference guides in the references directory. Quick-start commands show exact-version installs, dev dependency separation, audit fix workflows, and dependency tree inspection with npm list. Best-practice sections distinguish committing lock files, using npm ci in pipelines, and avoiding wildcard version ranges in production. Developers reach for dependency-management when onboarding a service, resolving version conflicts, auditing CVEs, or standardizing how teams add packages—not when writing feature code unrelated to package manifests.425installs163Django Applicationdjango-application is an aj-geddes/useful-ai-prompts skill for production-grade Django web development following framework conventions. The quick-start runs django-admin startproject, then python manage.py startapp for domain apps such as users and products. Seven reference guides cover Django project setup, model design with ORM, class-based and function-based views, authentication and permissions, database query optimization, URL routing, and admin interface customization. Best practices emphasize model-driven database access, indexes on hot fields, select_related and prefetch_related for N+1 prevention, Django Forms validation, management commands for batch jobs, middleware for cross-cutting concerns, and structured logging while warning against raw SQL, secret leakage, and synchronous heavy work inside views. Developers reach for django-application when bootstrapping a new Django service, designing schemas, wiring REST-ready URL patterns, or extending the admin for internal operations dashboards.425installs164Developer Onboardingdeveloper-onboarding is an installable skill from aj-geddes/useful-ai-prompts that turns repository context into a full onboarding documentation package. It ships nine reference guides covering clone steps, environment variables, database setup, project structure, npm scripts, code style, Git workflow, and testing procedures, plus a quick-start README template with badges and table-of-contents scaffolding. The skill targets README creation, contributing guidelines, development environment setup, architecture overviews, and first-PR checklists when a repo lacks structured docs. It lives inside the useful-ai-prompts library, which badges 260+ agent skills and 488+ standardized prompts. Reach for developer-onboarding when spinning up a new repository, refreshing stale setup docs, or preparing architecture tours and testing guidelines so new contributors can clone, configure, test, and open a first pull request without tribal knowledge.424installs165Email Service Integrationemail-service-integration is a useful-ai-prompts skill that walks developers through connecting application backends to email providers such as SendGrid, Amazon SES, and Postmark. The skill covers API key setup, HTML and text template design, webhook handlers for bounces and complaints, and basic deliverability checks so password resets, receipts, and lifecycle campaigns actually reach inboxes. Developers reach for email-service-integration when a SaaS or API product needs outbound email beyond local SMTP stubs. The skill emphasizes provider-specific integration patterns, webhook verification, and template variables rather than generic email copywriting.424installs166Gcp Cloud Functionsgcp-cloud-functions is a deployment-oriented prompt skill in aj-geddes/useful-ai-prompts for backend developers shipping serverless workloads on Google Cloud. The skill walks through scaffolding Cloud Functions handlers, wiring HTTP or event-driven triggers, setting IAM permissions, configuring environment variables, and packaging for Node.js or Python runtimes. Developers reach for gcp-cloud-functions when moving a handler from local code to a production GCP deployment and need correct trigger bindings, service account roles, and deployment commands without re-reading Cloud Functions documentation.424installs167Aws Ec2 Setupaws-ec2-setup is a cloud infrastructure skill from aj-geddes/useful-ai-prompts that guides provisioning and configuration of AWS EC2 instances alongside VPC networking, security groups, and launch templates. Developers invoke it when bootstrapping compute for REST APIs, background workers, or self-hosted services that need a repeatable AWS foundation before deployment pipelines exist. The skill covers instance sizing, subnet placement, inbound and outbound security group rules, and launch template patterns for consistent instance launches. Reach for aws-ec2-setup when standing up first AWS compute rather than debugging an existing multi-region fleet.422installs168Mutation Testingmutation-testing is an agent skill from aj-geddes/useful-ai-prompts that evaluates unit test effectiveness by injecting small code mutations and checking whether tests fail. It explains mutation concepts including killed, survived, equivalent, and timed-out mutants, plus mutation operators for arithmetic, conditional, and boundary changes. The skill provides tool-specific guidance for Stryker on JavaScript and TypeScript, PITest on Java, mutmut on Python, and Infection on PHP, including setup, CI integration, and report interpretation. Developers reach for mutation-testing when line coverage looks high but tests may not verify real behavior, or before release on critical modules like billing, auth, or pricing logic. It recommends targeting critical paths rather than entire repositories and aiming for roughly 80 percent mutation scores on important code. Output is mutation reports, survived-mutant analysis, and strengthened test assertions rather than new application features.422installs169Database Monitoringdatabase-monitoring is an aj-geddes/useful-ai-prompts agent skill for comprehensive database performance and health monitoring on Postgres and MySQL workloads. It establishes performance baselines, real-time health checks, capacity planning queries, slow-query analysis, resource utilization tracking, alerting rule configuration, and incident troubleshooting playbooks. Quick-start SQL examples query pg_stat_activity for active connections, per-database connection counts, and idle transaction detection before pointing to seven detailed reference guides covering connection monitoring, query performance, table and index stats, MySQL Performance Schema, InnoDB monitoring, PostgreSQL monitoring setup, and automated dashboard creation. Developers reach for database-monitoring when standing up observability for production databases, analyzing slow queries, tracking replication lag, or building proactive alert rules instead of reacting to outages without metrics.421installs170Api Versioning Strategyapi-versioning-strategy is a useful-ai-prompts skill with reference guides on versioning approaches, backward-compatibility patterns, deprecation strategy, migration examples, and version detection routing for REST, GraphQL, and gRPC APIs. It includes Express and TypeScript quick-start examples for /api/v1 and /api/v2 routes with version-specific response transformers and recommends versioning from day one, supporting at least two simultaneous versions, and giving consumers 6–12 months deprecation notice. Developers reach for api-versioning-strategy when adding breaking fields, deprecating endpoints, writing migration documentation, or choosing between URL, header, and content-negotiation versioning before shipping API changes.419installs171Concurrency Patternsconcurrency-patterns is an aj-geddes/useful-ai-prompts skill for building safe parallel systems across TypeScript, Node.js, Python, and Go-style channel simulations. It opens with a PromisePool quick-start that limits active tasks with a configurable concurrency ceiling, then points to six reference guides: Promise Pool TypeScript, Mutex and Semaphore TypeScript, Worker Pool Node.js, Python threading patterns, Python asyncio patterns, and Go-style channels simulation. Best practices stress proper synchronization primitives, bounded concurrency, immutable data where possible, and thorough race-condition testing while warning against unlimited threads, event-loop blocking, and unsynchronized mutable shared state. Developers reach for concurrency-patterns when designing API worker pools, batch processors, async job queues, or debugging race conditions in multi-threaded services. The skill packages language-specific recipes so agents recommend concrete primitives instead of ad hoc sleep polling or unbounded Promise.all fan-out.418installs172Infrastructure Monitoringinfrastructure-monitoring in aj-geddes/useful-ai-prompts walks developers through designing and deploying an observability stack for production infrastructure. The skill covers health check endpoints, metric collection pipelines, dashboard layout for hosts and containers, and on-call alert routing across cloud services. Agents use it to structure conversations about Prometheus-style metrics, uptime probes, log aggregation touchpoints, and escalation paths when services degrade. Developers reach for infrastructure-monitoring when a new deployment lacks visibility, when on-call is flying blind during incidents, or when container and VM fleets need unified monitoring before scaling traffic. The prompt-driven workflow helps translate vague "we need monitoring" requests into concrete check definitions, dashboard panels, and alert thresholds tied to real infrastructure tiers. Triggers include observability setup, health check design, metric dashboards, on-call runbooks, and cloud host monitoring for SaaS and API backends.416installs173Regression Modelingregression modeling is a prompt-driven skill from aj-geddes/useful-ai-prompts for fast predictive baselines using linear and logistic regression. Developers use it to frame hypotheses, select features, fit interpretable models, and read coefficients and error metrics before investing in complex pipelines. Teams reach for regression modeling when exploring whether a signal exists in tabular data—churn risk, conversion likelihood, or numeric forecasts—without jumping straight to gradient boosting or deep learning. The skill emphasizes explainable outputs and go/no-go scoping so engineering only builds production ML when simple regression already demonstrates value.416installs174Spring Boot Applicationspring-boot-application is an aj-geddes/useful-ai-prompts agent skill for production-ready Spring Boot applications using annotation-based configuration, dependency injection, REST controllers, JPA data persistence, service layers, and Spring Security. Its quick-start pom.xml targets spring-boot-starter-parent 3.1.0 with spring-boot-starter-web, spring-boot-starter-data-jpa, and spring-boot-starter-security dependencies. Seven reference guides cover project setup, JPA entity models, Spring Data repositories, service-layer business logic, REST request/response handling, security configuration, and application profiles. Best practices emphasize DTO mapping, @Transactional boundaries, validated controllers, and keeping business logic out of controllers. Developers reach for spring-boot-application when bootstrapping a Java microservice, adding JPA entities, or wiring Spring Security—not for non-JVM stacks or frontend-only work.415installs175Risk Assessmentrisk-assessment is a useful-ai-prompts agent skill for systematic threat identification and prioritization before milestones or technology introductions. Its Quick Start includes a Python RiskIdentification scaffold with Technical, Resource, and Schedule category checklists covering integration complexity, security vulnerabilities, skill gaps, and scope creep. Four reference guides document identification techniques, analysis matrices, response planning, and monitoring controls. Best practices call for early cross-team involvement, monthly risk-register updates, assigned owners, and transparent stakeholder communication. Use risk-assessment when preparing launch readiness reviews or documenting mitigations for new dependencies—not for ad-hoc worry lists without scores or triggers.414installs176Angular Module Designangular-module-design is a Claude Code skill from aj-geddes/useful-ai-prompts that guides feature-module architecture for large Angular applications. The skill covers NgModule declarations, lazy-loaded UsersRoutingModule patterns, service providers, ReactiveFormsModule imports, and RxJS-based state handling. Developers reach for it when organizing enterprise frontends with clear module boundaries, shared libraries, and optimized lazy routes instead of a monolithic AppModule. Reference guides document dependency injection and implementation steps with concrete UsersModule examples including UsersListComponent, UserDetailComponent, and UsersService wiring.413installs177Pull Request Automationpull-request-automation is a Claude Code skill from aj-geddes/useful-ai-prompts that helps developers wire consistent pull request workflows across GitHub and GitLab. It scaffolds PR templates with change-type checklists, links issues, and documents testing expectations, then points to six reference guides for auto review assignment, auto-merge on approval, GitLab merge request automation, Bors merge queues, PR title validation, and code-coverage requirements. The skill encodes best practices such as requiring reviews before merge, enforcing passing CI, auto-labeling PRs, validating conventional commits, and blocking coverage drops. Developers reach for pull-request-automation when review assignment is ad hoc, PR descriptions vary wildly, or merge rules need codifying in GitHub Actions or GitLab CI instead of tribal knowledge.413installs178Query Caching Strategiesquery-caching-strategies is an aj-geddes/useful-ai-prompts agent skill for implementing multi-level query caching on high-read backend paths. The skill walks through cache-aside and write-through patterns, TTL selection, cache warming, and invalidation strategies using Redis, Memcached, CDN edge caches, and database-level caches. A Node.js quick-start shows Redis setex with a 3600-second TTL around PostgreSQL user lookups, and six reference guides cover Redis with PostgreSQL, Memcached, PostgreSQL query cache, MySQL query cache, event-based invalidation, and time-based invalidation with LRU eviction. Developers reach for query-caching-strategies when API response times spike under read load, when choosing between Redis and CDN caching, or when defining invalidation rules after writes.413installs179Error Trackingerror-tracking in aj-geddes/useful-ai-prompts guides Sentry integration for automatic exception capture, release tracking, and performance issue detection in production applications. The skill includes a quick start with @sentry/cli, @sentry/node, and sentry init, plus six reference guides: Sentry setup, Express middleware integration, Python integration, source maps and release management, custom error context, and performance monitoring. Best practices cover sample rate tuning, breadcrumb usage, user context, sensitive data filtering, and CI/CD release creation while warning against 100% error sampling and PII in context. Reference markdown files in references/ provide stack-specific implementation steps agents can follow sequentially during production rollout. Developers reach for error-tracking when launching services without observability, debugging production stability, or correlating exceptions with deploy versions. Triggers include Sentry setup, production bug tracking, and application stability analysis for Node.js and Python backends.412installs180Serverless Architectureserverless-architecture is an agent skill from aj-geddes/useful-ai-prompts that guides design of event-driven, function-based backends. The skill maps HTTP and async triggers to compute units, connects queues and streams for decoupled workers, and selects managed databases and object stores for minimal operations overhead. Developers reach for serverless-architecture when scoping APIs, webhooks, or batch pipelines that should scale on demand without maintaining servers. Outputs include component diagrams, trigger-to-function mappings, and cost-versus-ops tradeoff notes for the chosen cloud primitives.412installs181Session Managementsession-management is an aj-geddes/useful-ai-prompts agent skill for building secure authentication state in SaaS and ecommerce backends. It covers JWT access tokens with 1-hour expiry and 7-day refresh tokens, server-side Redis session storage, secure httpOnly SameSite cookies, CSRF token protection, session fixation defenses, rotation, and logout cleanup across Flask, Express, and related frameworks. Seven reference guides address JWT generation, Node.js Express JWT setup, Redis session storage, CSRF protection, middleware chains, token refresh endpoints, and session cleanup jobs. Developers reach for session-management when adding login to a new API, hardening cookie flags, implementing refresh-token rotation, or defending against session fixation and CSRF on state-changing routes.411installs182Transaction Managementtransaction-management is an aj-geddes/useful-ai-prompts agent skill for implementing ACID-compliant database transactions on PostgreSQL and MySQL. It teaches BEGIN/COMMIT/ROLLBACK patterns for multi-statement transfers, isolation level selection, explicit row locking, deadlock detection, timeout configuration, and distributed transaction coordination for financial and inventory updates. Seven reference guides cover PostgreSQL and MySQL transactions, isolation levels, explicit locking, and deadlock prevention strategies. Developers reach for transaction-management when payment transfers must be atomic, inventory decrements race under concurrency, or partial failures require deterministic rollback instead of orphaned rows.411installs183Profiling Optimizationprofiling-optimization is a prompt-driven skill from aj-geddes/useful-ai-prompts for systematic performance investigation before shipping. It guides developers through collecting CPU, memory, and I/O profiles, reading flame graphs, isolating hot paths, and prioritizing fixes that reduce latency or cloud spend. Teams invoke profiling-optimization when benchmarks slip, p99 latency spikes, or infra bills climb after recent changes. The skill emphasizes evidence-backed tuning—measure first, optimize second—so changes target real bottlenecks instead of speculative micro-optimizations across the codebase.410installs184Code Metrics Analysiscode-metrics-analysis is a useful-ai-prompts skill that helps developers quantify code health before merge or release. It guides measurement of cyclomatic complexity, cognitive complexity, maintainability index, lines of code, function counts, and nesting depth using TypeScript AST analysis and Python radon tooling. The skill ships 4 reference guides covering a TypeScript complexity analyzer, Python radon metrics, an ESLint complexity plugin, and CI/CD quality gate patterns. Developers reach for code-metrics-analysis when assessing technical debt, identifying refactoring candidates, automating review gates, or tracking complexity trends across legacy modules. The skill emphasizes trends over absolute thresholds and combining multiple metrics rather than relying on a single score.409installs185Health Check Endpointshealth-check-endpoints is an agent skill from aj-geddes/useful-ai-prompts that guides design of production health probe APIs. The skill separates liveness versus readiness routes, defines JSON response schemas, sets dependency check timeouts, and documents how orchestrators should interpret status codes. Developers reach for health-check-endpoints when shipping services behind Kubernetes, load balancers, or external uptime monitors that require predictable probe contracts. Outputs include endpoint paths, check matrices for databases and queues, and failure semantics so traffic only routes to healthy instances.409installs186Webhook Integrationwebhook-integration is a Claude Code skill from aj-geddes/useful-ai-prompts for implementing production webhook pipelines between your app and external services. The SKILL.md walks through TypeScript patterns for sending signed events, receiving callbacks on Express, queuing deliveries with Bull, and testing webhook flows end to end. It ships four reference guides covering webhook senders, Express receivers, Bull queues, and testing utilities, plus a quick-start TypeScript example with HMAC signing and delivery-attempt tracking. Developers reach for webhook-integration when wiring Stripe payment callbacks, GitHub CI notifications, Shopify order events, or microservice event buses that need reliable at-least-once delivery without blocking HTTP responses.409installs187Security Documentationsecurity-documentation is a useful-ai-prompts skill for producing structured security and compliance documentation. It guides creation of security policies, access-control guidelines, incident response plans, vulnerability disclosure policies, and audit-ready evidence covering authentication, data protection, application security, and infrastructure controls. Reference guides cover password requirements, MFA, RBAC, secure coding practices, security headers, and API security patterns. Developers and security engineers reach for security-documentation when preparing SOC 2, GDPR, or HIPAA documentation, onboarding assessors, or standardizing secure development practices across teams. The skill ships policy templates with version, review schedule, and ownership metadata plus best-practice checklists for least privilege, encryption, logging, and employee training.407installs188Aws Rds Databaseaws-rds-database is a prompt-driven skill from aj-geddes/useful-ai-prompts that walks developers through provisioning AWS RDS for production-grade PostgreSQL or MySQL. The workflow covers instance sizing, subnet and parameter groups, backup retention, security groups, and application connection settings so services can persist data without self-managing database servers. Developers reach for aws-rds-database when standing up a new backend, migrating off a local database, or hardening RDS configuration before launch. The skill emphasizes managed-database best practices—high availability options, backup policies, and tunable parameters—rather than generic cloud overviews.406installs189Deployment Documentationdeployment-documentation is an agent skill from aj-geddes/useful-ai-prompts that structures CI/CD and infrastructure release docs from bundled reference guides and templates. The SKILL.md workflow walks through prerequisites, environment URLs, deployment methods (manual, automated, blue-green, canary), and operational guardrails, while four reference files cover GitHub Actions workflows, Dockerfiles, docker-compose.yml, and Kubernetes deployment manifests. A config-starter.yaml template and validate-config.sh script help validate configuration before docs land in the repo. Reach for deployment-documentation when a service ships to dev, staging, and production but lacks a written runbook covering secrets, health checks, rollback, and emergency procedures.406installs190Idempotency Handlingidempotency-handling is an agent skill in aj-geddes/useful-ai-prompts for designing safe retry behavior in backend systems. The skill covers idempotent API endpoints, payment flows, and webhook handlers so duplicate client submits and network retries never double-charge or corrupt application state. Developers reach for idempotency-handling when integrating Stripe-like payments, webhook consumers, or write APIs that clients may retry after timeouts. The patterns focus on deterministic keys, deduplication, and state transitions rather than frontend routing or operational runbooks. Use it while building backend integrations that must stay correct under at-least-once delivery.406installs191Autoscaling Configurationautoscaling-configuration is a prompt-driven skill from aj-geddes/useful-ai-prompts for designing production autoscaling policies on cloud platforms. It covers metric triggers—CPU utilization, queue depth, request rates—plus min and max instance bounds, cooldown windows, and cost guardrails so services scale with traffic without runaway spend. Operators invoke autoscaling-configuration when traffic patterns shift seasonally, queue backlogs spike, or existing policies over-provision resources. The skill produces concrete policy parameters and rollout notes instead of generic elasticity theory, helping teams balance availability SLAs with infrastructure budgets.405installs192Secrets Rotationsecrets-rotation is a prompt-driven skill from aj-geddes/useful-ai-prompts for operational credential lifecycle management. It guides teams through inventorying secrets, staging new values, dual-write or blue-green cutover, service restarts, and verification steps so API keys, database passwords, and signing tokens rotate without outages. Security and platform engineers use secrets-rotation after leaks, policy mandates, or scheduled compliance windows. The skill emphasizes audit trails and rollback paths so rotation events remain traceable and reversible if downstream services fail authentication after cutover.404installs193Log Aggregationlog-aggregation is an agent skill from useful-ai-prompts that helps developers centralize application and infrastructure logs for production observability. The skill covers structured logging conventions, log collectors, retention policies, and searchable storage so on-call engineers can trace errors across services. Developers reach for log-aggregation when microservices or serverless functions emit scattered stdout logs, when compliance requires retention windows, or when debugging production incidents needs correlated request traces instead of SSH grepping. The skill walks through choosing aggregation backends, defining log schemas, wiring collectors, and configuring retention and access patterns suitable for staging and production environments.403installs194Runbook Creationrunbook-creation is a Claude Code skill from aj-geddes/useful-ai-prompts, a library of 260+ auto-triggering agent skills. The skill guides coding agents to produce production-ready operational runbooks, standard operating procedures (SOPs), and incident response guides for on-call engineers. It follows Progressive Disclosure Architecture: a concise SKILL.md hub with a quick-start incident response Markdown template, DO/DON'T best-practice checklists, and 6 on-demand reference guides—symptoms, investigation-steps, resolution-steps, verification, communication, and post-incident. Generated runbooks define P0–P3 severity levels, tiered response-time targets, PagerDuty escalation contacts, exact shell commands with expected outputs, rollback procedures, and stakeholder communication templates. Engineers reach for runbook-creation when formalizing tribal incident knowledge into executable playbooks for service outages, deployments, database failures, or disaster recovery after postmortems reveal documentation gaps.403installs195Stored Proceduresstored-procedures is a database skill from aj-geddes/useful-ai-prompts that guides agents through writing PostgreSQL plpgsql functions, multi-step procedures, error-handling patterns, and MySQL or PostgreSQL triggers. It opens with a PostgreSQL scalar-function quick start—calculate_order_total with IMMUTABLE semantics—and links six reference guides for simple functions, stored procedures, complex error handling, and database-specific triggers. Developers use stored-procedures when business rules belong in the database layer, when multi-step transactions need atomic server-side execution, or when audit trails and validation must run close to data. The skill stresses reusable routines, performance-aware design, and disciplined testing before deployment rather than scattering logic across application code.403installs196Frontend Routingfrontend-routing is an agent skill in aj-geddes/useful-ai-prompts for establishing navigation structure in single-page applications. The skill covers client-side or hybrid routing, nested layouts, route guards, and deep link handling when scaffolding or extending React, Vue, or comparable frontend stacks. Developers reach for frontend-routing when a new SPA needs consistent URL structure, protected routes, or layout composition before feature pages multiply. The focus is routing architecture and guard patterns rather than backend API design. Use it during frontend build work when navigation behavior must be planned alongside page components.401installs197Retrospective Facilitationretrospective-facilitation is a useful-ai-prompts skill for running effective sprint retrospectives that balance celebration, honest feedback, and committed improvements. The Quick Start template plans a 60-minute session with Went Well / Didn't Go Well / Ideas format, anonymous pre-surveys, sprint metrics review, and Miro collaboration notes. Four reference guides cover retrospective planning, facilitation techniques, action-item tracking, and reusable templates. Best practices emphasize psychological safety, whole-team inclusion, system-focused blamelessness, and reviewing prior action items at each session. Use retrospective-facilitation when a tech lead or Scrum Master needs a concrete agenda instead of improvising the same retro format every sprint.386installs198Load Balancer SetupCovers practical load balancer setup for cloud and self-hosted stacks: listener rules, backend pools, health checks, SSL offload, and routing patterns that keep APIs available under rolling deploys and instance loss.368installs199Cloud Storage OptimizationPrompt skill for cloud storage optimization: S3 tiering, lifecycle transitions, intelligent tiering, CloudFront caching, multipart uploads, and cost monitoring to keep object storage fast and affordable in production.367installs200Git Hooks SetupPrompt skill from aj-geddes/useful-ai-prompts for git hooks setup: walks through installing and configuring pre-commit tooling, linking formatters and test runners, and standardizing commit hygiene across a repo.367installs201Monorepo ManagementA developer tool for AI integration and automation. This is a developer tool for building and integrating AI-powered features.361installs202Azure App ServiceA skill for deploying and managing web apps on Azure App Service. A developer uses it to host web applications, REST APIs and mobile backends with auto-scaling, deployment slots, SSL/TLS and monitoring. It provides Azure CLI quick-start commands and reference guides for CLI and Terraform configuration.358installs