Skills by aj-geddes

Develop native iOS apps with Swift. Covers MVVM architecture, SwiftUI, URLSession for networking, Combine for reactive programming, and Core Data persistence.

This skill provides example code to build Express.js REST APIs with routing, JWT auth, and Sequelize-backed PostgreSQL integration. It reads environment variables like `process.env.JWT_SECRET` and `process.env.DB_PASS` and uses `postgres://user:pass@localhost/db` for database connections.

Design RESTful APIs following best practices for resource modeling, HTTP methods, status codes, versioning, and documentation. Use when creating new APIs, designing endpoints, or improving existing API architecture.

This skill provides guidelines, templates, and examples for writing Markdown documentation and READMEs. It includes executable shell commands such as `git clone https://github.com/user/repo.git` and `npm install package-name`, which instruct running local commands and fetching resources from external hosts.

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.

Organize CSS using BEM, SMACSS, and CSS-in-JS patterns. Use when building scalable, maintainable styling systems with proper naming conventions.

This skill provides Ansible playbooks, roles, inventory, and an `ansible-deploy.sh` script for infrastructure automation and application deployment. It executes local shell commands via `ansible-playbook`, accesses credentials such as `~/.ssh/id_rsa` and writes `/.env` files, and calls external hosts like `https://github.com/myorg/myapp.git` and `https://download.docker.com`.

Build beautiful cross-platform mobile apps with Flutter and Dart. Covers widgets, state management with Provider/BLoC, navigation, API integration, and material design.

Create system architecture diagrams using Mermaid, PlantUML, C4 model, flowcharts, and sequence diagrams. Use when documenting architecture, system design, data flows, or technical workflows.

This skill configures Nginx for reverse proxying, load balancing, SSL/TLS, caching, and monitoring. It includes a deploy script (`nginx-deploy.sh`) that runs `nginx -t`, `systemctl`, and `curl`, and references network hosts like `backend1.internal:8080` and `api1.internal:3000`.

Write effective user stories that capture requirements from the user's perspective. Create clear stories with detailed acceptance criteria to guide development and define done.

This skill provides API security hardening guidance with example configurations for Node/Express, FastAPI, and Nginx. It references `process.env.JWT_SECRET`, includes domains such as `https://example.com` and `api.example.com`, and shows `proxy_pass http://backend:3000`.

Comprehensive mobile app testing strategies for iOS and Android. Covers unit tests, UI tests, integration tests, performance testing, and test automation with Detox, Appium, and XCTest.

This skill provides examples and templates for creating and deploying AWS Lambda functions. It includes explicit shell commands (e.g., `aws`, `zip`, `npm`) and network calls to AWS (e.g., `aws lambda`, `aws iam`, `https://docs.aws.amazon.com/lambda/`), which are purpose-aligned.

This skill provides Docker containerization guidance for building optimized, secure images and docker-compose services. It contains executable commands like `docker build -t myapp:1.0.0 .` and examples that store credentials in environment variables such as `POSTGRES_PASSWORD` and `DATABASE_URL`.

Provides example FastAPI scaffolding with async routes, Pydantic models, SQLAlchemy integration, and JWT auth. Reads `DATABASE_URL` and `SECRET_KEY` from the environment and initializes a DB engine via `create_async_engine`, which can connect to external databases.

This skill provides guidance for creating wireframes and interactive prototypes, including tools, fidelity levels, example flows, and testing plans. No security-relevant behaviors detected.

Perform comprehensive code reviews with best practices, security checks, and constructive feedback. Use when reviewing pull requests, analyzing code quality, checking for security vulnerabilities, or providing code improvement suggestions.

Design for mobile devices first, then scale up to larger screens. Create responsive interfaces that work seamlessly across all device sizes.

This skill scaffolds a Ruby on Rails API with models, controllers, migrations, serializers, and JWT-based authentication. It includes setup commands like `rails new`/`rails db:create`, references `https://rubygems.org`, and uses `SECRET_KEY = Rails.application.secrets.secret_key_base`.

Provides Jenkins pipeline examples (declarative, scripted, multibranch) for building, testing, and deploying with parameters and credentials. Contains explicit shell execution via `sh` steps, uses credentials `DOCKER_CREDS`/`DOCKER_CREDS_PSW`/`DOCKER_CREDS_USR`, and references `docker.io` for image pushes.

The skill provides a `technical-specification` template for system requirements, architecture, API design, data models, and testing plans. No security-relevant behaviors detected.

Verify API contracts between services to ensure compatibility and prevent breaking changes. Use for contract testing, Pact, API contract validation, schema validation, and consumer-driven contracts.

This skill provides automated security compliance audit code and guidance for SOC 2, GDPR, HIPAA, PCI-DSS, and ISO 27001. It performs TLS checks against `https://api.example.com` and writes reports to `compliance-audit-report.json` and `compliance-report.json`.

Develop lightweight Flask APIs with routing, blueprints, database integration, authentication, and request/response handling. Use when building RESTful APIs, microservices, or lightweight web services with Flask.

Implement Role-Based Access Control (RBAC), permissions management, and authorization policies. Use when building secure access control systems with fine-grained permissions.

Analyze competitive landscape to identify strengths, weaknesses, opportunities, and threats. Inform product strategy and positioning based on market insights.

Design scalable React components using functional components, hooks, composition patterns, and TypeScript. Use when building reusable component libraries and maintainable UI systems.

Provides templates and examples for GitLab CI/CD pipelines, runners, Docker/DIND builds, and Kubernetes deployments. Contains executable CI/bash commands that use or write secrets (e.g., `POSTGRES_PASSWORD`, `$CI_REGISTRY_PASSWORD`, `KUBE_CONFIG_ENCODED`), call external endpoints like `https://gitlab.com/`, and request `--docker-privileged`.

Debug issues specific to mobile applications including platform-specific problems, device constraints, and connectivity issues.

Design color palettes that are accessible to all users including those with color blindness. Ensure sufficient contrast, meaningful use of color, and inclusive design.

This skill provides guidelines, metrics, example code, and checklists to perform web performance audits and continuous monitoring. No security-relevant behaviors detected.

Implement push notifications for iOS and Android. Covers Firebase Cloud Messaging, Apple Push Notification service, handling notifications, and backend integration.

Provides step-by-step instructions to build and publish iOS and Android apps, covering signing, versioning, CI/CD, and store submission. Contains explicit shell commands (`xcodebuild`, `keytool`, `./gradlew`), uses secrets (`KEYSTORE_PASSWORD`, `APPLE_PASSWORD`, `PLAY_STORE_SERVICE_ACCOUNT`), and directs uploads (`xcrun altool`, `r0adkll/upload-google-play@v1`).

This skill provides end-to-end test examples and patterns for Playwright, Cypress, and Selenium across the full application stack. It includes network calls to `http://localhost:3000` and endpoints like `/api/auth/login`, stores auth tokens via `window.localStorage.setItem('auth_token', ...)`, and contains a `command: 'npm run start'` webServer entry.

This skill provides AWS S3 management guidance, examples, and Terraform templates for creating and configuring buckets. It includes executable `aws` CLI commands such as `aws s3api create-bucket` and references S3 URIs like `s3://my-app-bucket/`, which perform network calls.

Build compelling business cases to justify investments and secure funding. Quantify benefits, assess costs, manage risks, and present compelling ROI arguments to leadership.

Implement real-time bidirectional communication with WebSockets including connection management, message routing, and scaling. Use when building real-time features, chat systems, live notifications, or collaborative applications.

Implement API rate limiting strategies using token bucket, sliding window, and fixed window algorithms. Use when protecting APIs from abuse, managing traffic, or implementing tiered rate limits.

Deploy, manage, and scale containerized applications on Kubernetes clusters with best practices for production workloads, resource management, and rolling updates.

This skill provides security-testing guidance with runnable examples for SAST/DAST, pentesting, and dependency scanning. It instructs running commands like `npm audit` and `pip install detect-secrets`, performing network scans against `http://localhost:3000`/`http://localhost:8080`, and references secrets `SNYK_TOKEN` and `JWT_SECRET`.

Manage database migrations and schema versioning. Use when planning migrations, version control, rollback strategies, or data transformations in PostgreSQL and MySQL.

Apply appropriate design patterns (Singleton, Factory, Observer, Strategy, etc.) to solve architectural problems. Use when refactoring code architecture, implementing extensible systems, or following SOLID principles.

Implement static code analysis with linters, formatters, and security scanners to catch bugs early. Use when enforcing code standards, detecting security vulnerabilities, or automating code review.

This skill provides guidance to optimize images for the web, covering compression, format conversion, responsive `srcset`, and CI/CD validation. It includes explicit shell commands such as `convert image.jpg -quality 75 optimized.jpg` and recommends external services like `Imgix` and `Cloudinary`, which requires network access.

Design database schemas with normalization, relationships, and constraints. Use when creating new database schemas, designing tables, or planning data models for PostgreSQL and MySQL.

Reduce JavaScript and CSS bundle sizes through code splitting, tree shaking, and optimization techniques. Improve load times and overall application performance.

Provides patterns for offline-first mobile apps across React Native, iOS Core Data, and Android Room. Includes explicit network calls to `https://api.example.com/items` for fetching and syncing queued actions.

Build comprehensive GitHub Actions workflows for CI/CD, testing, security, and deployment. Master workflows, jobs, steps, and conditional execution.

Create comprehensive technical roadmaps aligned with business goals. Plan technology investments, architecture evolution, and infrastructure improvements over quarters and years.

This skill provides code examples and guidance for implementing encryption with AES, RSA, TLS, and key management. It references `process.env.KEY_PASSPHRASE` and includes hard-coded secrets such as `'top-secret'` and `'encryption-key'` in sample code.

Systematically collect, document, and validate requirements from stakeholders. Ensure clarity, completeness, and agreement before development begins to reduce scope creep and rework.

Design Angular modules using feature modules, lazy loading, and dependency injection. Use when organizing large Angular applications with proper separation of concerns.

Infrastructure as Code using Terraform with modular components, state management, and multi-cloud deployments. Use for provisioning and managing cloud resources.

This skill assesses, quantifies, and prioritizes technical debt using static code analysis, metrics, and generated reports (examples provided in TypeScript). No security-relevant behaviors detected.

Build enterprise Spring Boot applications with annotations, dependency injection, data persistence, REST controllers, and security. Use when developing Spring applications, managing beans, implementing services, and configuring Spring Boot projects.

This skill provides templates and step-by-step user guides, installation instructions, and troubleshooting for product documentation. It includes explicit shell commands like `wget https://example.com/downloads/product-name.deb` and `sudo dpkg -i product-name.deb` and directs visits to `https://example.com/download`, enabling local command execution and network requests.

This skill documents caching strategies and supplies sample implementations for Redis, Memcached, CDN, and cache invalidation. It includes code that connects to `redis://localhost:6379` and `Redis(host='localhost', port=6379, db=0)`; no other security-relevant behaviors detected.

Analyze user conversion funnels, identify drop-off points, and optimize conversion rates for conversion optimization and user flow analysis

Implement internationalization (i18n) and localization including message extraction, translation catalogs, pluralization rules, date/time/number formatting, RTL language support, and i18n libraries like i18next and gettext. Use for multi-language, translation, or localization needs.

Test web applications for WCAG compliance and ensure usability for users with disabilities. Use for accessibility test, a11y, axe, ARIA, keyboard navigation, screen reader compatibility, and WCAG validation.

Implement secure OAuth 2.0, OpenID Connect (OIDC), JWT authentication, and SSO integration. Use when building secure authentication systems for web and mobile applications.

Build high-performance gRPC services with Protocol Buffers, bidirectional streaming, and microservice communication. Use when building gRPC servers, defining service contracts, or implementing inter-service communication.

Plan and execute effective sprints using Agile methodologies. Define sprint goals, estimate user stories, manage sprint backlog, and facilitate daily standups to maximize team productivity and deliver value incrementally.

Improve database query performance through indexing, query optimization, and execution plan analysis. Reduce response times and database load.

Implement structured logging across applications with log aggregation and centralized analysis. Use when setting up application logging, implementing ELK stack, or analyzing application behavior.

Design and implement microservices architecture including service boundaries, communication patterns, API gateways, service mesh, service discovery, and distributed system patterns. Use when building microservices, distributed systems, or service-oriented architectures.

This skill implements API authentication patterns (JWT, OAuth 2.0, API keys, session management). It references secrets in `process.env.JWT_SECRET` and related vars and integrates Google OAuth routes such as `passport.authenticate('google')`, which implies external network calls.

Conduct systematic root cause analysis to identify underlying problems. Use structured methodologies to prevent recurring issues and drive improvements.

Implement semantic versioning (SemVer) with automated release management. Use conventional commits, semantic-release, and version bumping strategies.

Document database schemas, ERD diagrams, table relationships, indexes, and constraints. Use when documenting database schema, creating ERD diagrams, or writing table documentation.

Build cross-platform mobile apps with React Native. Covers navigation with React Navigation, state management with Redux/Context API, API integration, and platform-specific features.

Implement real-time functionality using WebSockets, Server-Sent Events (SSE), or long polling. Use when building chat applications, live dashboards, collaborative editing, notifications, or any feature requiring instant updates.

Debug client-side issues using browser developer tools. Identify JavaScript errors, styling issues, and performance problems in the browser.

Build comprehensive design systems with components, patterns, and guidelines. Enable consistent design, faster development, and better collaboration across teams.

Analyze application and system logs to identify errors, patterns, and root causes. Use log aggregation tools and structured logging for effective debugging.

This skill provides performance-testing examples and runnable scripts for `k6`, `JMeter`, `pytest-benchmark`, `JMH`, and related tools. It includes explicit commands like `k6 run load-test.js` and network targets such as `https://api.example.com` and `http://localhost:8086/k6`.

Design and implement integration tests that verify component interactions, API endpoints, database operations, and external service communication. Use for integration test, API test, end-to-end component testing, and service layer validation.

This skill automates Kubernetes deployments using Helm, ArgoCD, and GitHub Actions. It runs shell/CLI steps (e.g., `helm`, `kubectl`), reads/stores secrets such as `${{ secrets.KUBE_CONFIG }}` into ` $HOME/.kube/config`, and references external endpoints like `https://github.com/myorg/helm-charts`.

Design and implement CI/CD pipelines with GitHub Actions, GitLab CI, Jenkins, or CircleCI. Use for automated testing, building, and deployment workflows.

This skill documents database backup and restore procedures for PostgreSQL and MySQL, including scripts, cron entries, and restore examples. It includes shell commands and env-var usage (`MYSQL_PWD`) plus remote uploads to `s3://backup-bucket/postgres/`, enabling local execution and network transfers.

Implement background job processing systems with task queues, workers, scheduling, and retry mechanisms. Use when handling long-running tasks, sending emails, generating reports, and processing large datasets asynchronously.

Analyze and optimize SQL queries for performance. Use when improving slow queries, reducing execution time, or analyzing query performance in PostgreSQL and MySQL.

Provides integration examples for Stripe, PayPal, and Square to handle payments, subscriptions, and webhooks. Uses environment variables like `STRIPE_SECRET_KEY` and SDK calls such as `const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);` that make purpose-aligned network requests and present low risk.

Create detailed user personas based on research and data. Develop realistic representations of target users to guide product decisions and ensure user-centered design.

Create professional Grafana dashboards with visualizations, templating, and alerts. Use when building monitoring dashboards, creating data visualizations, or setting up operational insights.

This skill documents visual regression testing workflows for Playwright, Percy, Chromatic, Cypress, BackstopJS, and CI. It includes explicit shell commands like `npx chromatic --project-token=<TOKEN>` and `npx percy exec -- npm run test:visual` and uses the `PERCY_TOKEN` CI secret, enabling network calls and credential usage.

Implement webhook systems for event-driven integration with retry logic, signature verification, and delivery guarantees. Use when creating event notification systems, integrating with external services, or building event-driven architectures.

Profile and optimize application memory usage. Identify memory leaks, reduce memory footprint, and improve efficiency for better performance and reliability.

Estimate project scope, timeline, and resource requirements using multiple estimation techniques including bottom-up, top-down, and analogous estimation methods for accurate project planning.

Detect and fix memory leaks using heap snapshots, memory profiling, and leak detection tools. Use when investigating memory growth, OOM errors, or optimizing memory usage.

Monitor database performance and health. Use when setting up monitoring, analyzing metrics, or troubleshooting database issues.

This skill provides developer onboarding and README/templates for setting up a Node/Postgres/Redis project. It includes runnable shell commands like `git clone`/`npm install`, instructs creating and populating ` .env` entries such as `DATABASE_URL` and `JWT_SECRET`, and references external URLs like `https://github.com/username/repo.git`.

This skill provides API error-handling guidance and code samples for Node.js and Flask, including standardized error responses, logging, recovery patterns, and monitoring. It instructs initializing Sentry with `process.env.SENTRY_DSN` and calling `Sentry.captureException`, which sends error data to the Sentry service.

Set up comprehensive infrastructure monitoring with Prometheus, Grafana, and alerting systems for metrics, health checks, and performance tracking.

Implement robust batch processing systems with job queues, schedulers, background tasks, and distributed workers. Use when processing large datasets, scheduled tasks, async operations, or resource-intensive computations.

This skill provides code examples for client- and server-side form validation using React Hook Form, Formik, Vee-Validate, and custom validators. It includes example network calls to `'/api/login'`, `'/api/register'`, and `'/api/validate/*'`.

Organize and structure information for clarity and discoverability. Design navigation systems, hierarchies, and mental models that match user needs.

The skill `code-documentation` provides templates and guidelines for generating JSDoc, Python docstrings, JavaDoc, and inline comments across languages. No security-relevant behaviors detected.

Configure HTTP security headers including CSP, HSTS, X-Frame-Options, and XSS protection. Use when hardening web applications against common attacks.

Create and execute incident response procedures for security breaches, data leaks, and cyber attacks. Use when handling security incidents, creating response playbooks, or conducting forensic analysis.

This skill provides vulnerability scanning examples and CI integration for OWASP tools and automated scanners. It runs local CLI scanners (`npm audit`, `trufflehog`, `bandit`, `trivy`) and CI actions and uses the `SNYK_TOKEN` secret.

Dangerous skill that reads cluster `secret` objects via `kubectl get ... -A -o yaml` and uploads them and other backups to `s3://my-backups`. It presents itself as a `backup-disaster-recovery` helper while explicitly using `POSTGRES_*` and `AWS_*` secrets and executing backup/restore shell commands.

Deploy and manage web apps using Azure App Service with auto-scaling, deployment slots, SSL/TLS, and monitoring. Use for hosting web applications on Azure.

This skill provides penetration-testing examples and automation scripts for web security assessments. It runs local CLI tools (`testssl.sh`), makes network requests to targets like `https://example.com` and `http://127.0.0.1:1337`, and performs credential tests using default credentials.

Debug database performance issues through query analysis, index optimization, and execution plan review. Identify and fix slow queries.

Design and implement scalable test automation frameworks with Page Object Model, fixtures, and reporting. Use for test framework, page object pattern, test architecture, test organization, and automation infrastructure.

Set up Prometheus monitoring for applications with custom metrics, scraping configurations, and service discovery. Use when implementing time-series metrics collection, monitoring applications, or building observability infrastructure.

Configure API gateways for routing, authentication, rate limiting, and request/response transformation. Use when deploying microservices, setting up reverse proxies, or managing API traffic.

Implement event sourcing and CQRS patterns using event stores, aggregates, and projections. Use when building audit trails, temporal queries, or systems requiring full history.

Implement secure file upload handling with validation, virus scanning, storage management, and serving files efficiently. Use when building file upload features, managing file storage, and implementing file download systems.

This skill provides frontend testing examples and configurations for `Jest`, `Vitest`, `React Testing Library`, and `Cypress`, including sample tests and a `jest.config.js`. No security-relevant behaviors detected.

This skill provides templates and guidance to maintain `CHANGELOG.md` and release notes, plus migration and upgrade instructions. It includes purpose-aligned instructions to run local commands like `npm run migrate`/`pg_dump`, set env vars such as `JWT_SECRET`, and call endpoints like `https://api.example.com/graphql`.

Prevent SQL injection attacks using prepared statements, parameterized queries, and input validation. Use when building database-driven applications securely.

Create and transform features using encoding, scaling, polynomial features, and domain-specific transformations for improved model performance and interpretability

Analyze user research data to uncover insights, identify patterns, and inform design decisions. Synthesize qualitative and quantitative research into actionable recommendations.

Implement WCAG compliance using semantic HTML, ARIA, keyboard navigation, and screen reader support. Use when building inclusive applications for all users.

This skill provides cloud security configuration examples for AWS, Azure, and GCP. It includes executable CLI and Terraform commands (`aws`, `az`, `gcloud`, `security.tf`) that perform networked cloud operations and shows over-permissive examples such as `--cidr 0.0.0.0/0`.

This skill provides Docker/Kubernetes debugging guidance and concrete CLI examples for container lifecycle, logs, networking, resource limits, and builds. It instructs executing runtime commands such as `docker exec -it <container-id> /bin/bash` and `docker cp <container-id>:/path/to/file /local/path`, enabling shell-level operations.

Provides code-generation templates and scaffolding (Handlebars, EJS, AST/TypeScript generators, CLI scaffolding, OpenAPI and GraphQL clients). No security-relevant behaviors detected; it operates on local files such as `templates/component.hbs` and `./src/generated/graphql.ts`.

Optimize API response times through caching, compression, and efficient payloads. Improve backend performance and reduce network traffic.

High-risk skill for deploying GCP Cloud Functions that includes shell commands which fetch and run remote code (`curl https://sdk.cloud.google.com | bash`) and many `gcloud` CLI operations. It also instructs setting credentials via `--set-env-vars NODE_ENV=production,API_KEY=xxx` and interacts with `logging.googleapis.com/projects/${var.project_id}/logs/my-http-function`.

This skill provides templates and best practices for writing unit tests across Jest, pytest, and JUnit. It includes example shell commands such as `npm test -- --coverage`, `pytest --cov=src --cov-report=html`, and `mvn test jacoco:report` for running coverage tools.

This skill automates EC2 provisioning and configuration using `aws` CLI, `user-data.sh`, and Terraform. It performs local file read/write (`~/.ssh/id_rsa.pub`, `my-app-key.pem`) and downloads from `github.com` and `s3.amazonaws.com`.

Modernize and improve legacy codebases while maintaining functionality. Use when you need to refactor old code, reduce technical debt, modernize deprecated patterns, or improve code maintainability without breaking existing behavior.

This skill provides deployment guidance for Google Cloud Run with `gcloud`, `docker`, a `Dockerfile`, Node.js sample code, and Terraform configuration. It instructs running shell commands (e.g., `gcloud`, `docker`), network interactions with `gcr.io`/`run.googleapis.com`, setting env vars like `DATABASE_URL`, and granting `allUsers` IAM access.

This skill provides deployment and CI/CD documentation and templates for infrastructure, Kubernetes, Docker, and GitHub Actions. It includes executable commands like `docker`/`kubectl` and example secret names such as `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`, which are purpose-aligned and not malicious.

Implement comprehensive health check endpoints for liveness, readiness, and dependency monitoring. Use when deploying to Kubernetes, implementing load balancer health checks, or monitoring service availability.

Implement efficient pagination strategies for large datasets using offset/limit, cursor-based, and keyset pagination. Use when returning collections, managing large result sets, or optimizing query performance.

This skill analyzes code quality metrics and includes example implementations in TypeScript, Python, ESLint, and a CI workflow. It contains explicit shell execution steps such as `npx ts-node analyze-metrics.ts` and a CI `run` block using `cat metrics.json | jq` that instruct running shell commands.

Create comprehensive API reference documentation with OpenAPI/Swagger specs, REST endpoints, authentication, examples, and SDKs. Use when documenting REST APIs, GraphQL APIs, endpoint documentation, or OpenAPI specifications.

Provides automated SSL/TLS certificate provisioning, renewal, monitoring, and Kubernetes/AWS ACM integration. Includes executable shell scripts that run `kubectl` and `aws`, read Kubernetes TLS secret field `tls.crt`, and configure the ACME endpoint `https://acme-v02.api.letsencrypt.org/directory`.

Design and implement database indexing strategies. Use when creating indexes, choosing index types, or optimizing index performance in PostgreSQL and MySQL.

Implement secure session management systems with JWT tokens, session storage, token refresh, logout handling, and CSRF protection. Use when managing user authentication state, handling token lifecycle, and securing sessions.

Optimize web application performance using code splitting, lazy loading, caching, compression, and monitoring. Use when improving Core Web Vitals and user experience.

Identify unusual patterns, outliers, and anomalies in data using statistical methods, isolation forests, and autoencoders for fraud detection and quality monitoring

Design NoSQL database schemas for MongoDB and DynamoDB. Use when modeling document structures, designing collections, or planning NoSQL data architectures.

Debug network issues using browser tools and network analysis. Diagnose connection problems, latency, and data transmission issues.

Handle cross-platform compatibility including file paths, environment detection, platform-specific dependencies, and testing across Windows, macOS, and Linux. Use when dealing with platform-specific code or OS compatibility.

This skill provides RxJS-based reactive programming examples for streams, state management, debounced search, WebSocket reconnection, and backpressure handling. It contains explicit network calls such as `fetch('/api/search?q=${query}')` and a WebSocket connection to `wss://api.example.com/ws`.

This skill provides rate-limiting implementation guidance with code examples in `TypeScript`, `Python`, and `Redis`-based patterns. No security-relevant behaviors detected.

Generate realistic, consistent test data using factories, fixtures, and fake data libraries. Use for test data, fixtures, mock data, faker, test builders, and seed data generation.

Provides example implementations for sending transactional emails via SMTP, SendGrid, FastMail, and MJML templates, including the file `templates/welcome.mjml` and URLs like `https://example.com`. The code reads environment secrets such as `MAIL_PASSWORD` and `SENDGRID_API_KEY` and performs outbound network calls to `smtp.gmail.com`/SendGrid for delivery.

Implement error tracking with Sentry for automatic exception monitoring, release tracking, and performance issues. Use when setting up error monitoring, tracking bugs in production, or analyzing application stability.

This skill provides cloud migration planning guidance and example automation for AWS, Azure, and GCP. It contains runnable shell commands such as `aws dms create-replication-instance` and `nc -zv target-db.rds.amazonaws.com 5432`, and examples that store/use credentials (`secret_string = jsonencode({ source_db_password = var.source_db_password })`).

Implement uptime monitoring and status page systems for tracking service availability. Use when monitoring application uptime, creating status pages, or implementing health checks.

Implement WCAG 2.1/2.2 accessibility standards, screen reader compatibility, keyboard navigation, and a11y testing. Use when building inclusive web applications, ensuring regulatory compliance, or improving user experience for people with disabilities.

Implement circuit breaker patterns for fault tolerance, automatic failure detection, and fallback mechanisms. Use when calling external services, handling cascading failures, or implementing resilience patterns.

This skill documents dependency management across languages and provides concrete shell commands, lockfile guidance, CI snippets, and security-scanning examples. It instructs running shell commands (`npm install`, `pip install`, `npm audit`), contacting registries like `https://registry.npmjs.org/` and `https://npm.pkg.github.com/`, and authenticating with `snyk`.

Dangerous skill: provides cloud cost-management scripts but includes shell commands that execute a downloaded installer (`curl -sL https://aka.ms/InstallAzureCLIDeb | bash`) and numerous CLI calls (`aws`, `az`, `gcloud`) that perform network operations. It supplies AWS/Azure/GCP examples and a Python `boto3` monitor for cost reporting.

Test system behavior under extreme load conditions to identify breaking points, capacity limits, and failure modes. Use for stress test, capacity testing, breaking point analysis, spike test, and system limits validation.

Distribute content globally using CloudFront with caching, security headers, WAF integration, and origin configuration. Use for low-latency content delivery.

Develop production-grade Django applications with models, views, ORM queries, authentication, and admin interfaces. Use when building web applications, managing databases with Django ORM, and implementing authentication systems.

Master Git workflows including GitFlow, GitHub Flow, Trunk-Based Development. Configure branches, merge strategies, and collaboration patterns for team environments.

Implement client-side routing using React Router, Vue Router, and Angular Router. Use when building multi-page applications with navigation and route protection.

This skill provides security documentation templates and best-practice examples for policies, encryption, MFA, RBAC, and incident response. It includes example shell commands such as `iptables -P INPUT DROP` and `iptables -A INPUT -p tcp -s 203.0.113.0/24 --dport 22 -j ACCEPT`, which, if executed, modify firewall rules; no other confirmed risky behaviors were found.

Implement thread-safe code, mutexes, semaphores, async/await patterns, and concurrent data structures. Use when handling parallel operations, race conditions, or building high-performance concurrent systems.

Visualize and document current and future business processes. Identify inefficiencies, dependencies, and improvement opportunities through detailed process mapping and analysis.

Discover patterns, distributions, and relationships in data through visualization, summary statistics, and hypothesis generation for exploratory data analysis, data profiling, and initial insights

Evaluate test suite quality by introducing code mutations and verifying tests catch them. Use for mutation testing, test quality, mutant detection, Stryker, PITest, and test effectiveness analysis.

Identify differences between current state and desired future state. Analyze gaps in capabilities, processes, skills, and technology to plan improvements and investments.

Manage stakeholder expectations and engagement through targeted communication, regular updates, and relationship building. Tailor messaging for different stakeholder groups and priorities.