@aj-geddes

survival-analysis covers time-to-event modeling with kaplan-meier estimation, cox proportional hazards regression, log-rank testing, and risk stratification. includes model diagnostics and survival prediction for clinical and reliability applications.

system-architect transforms requirements into justified technical designs by extracting functional and non-functional requirements, selecting architectural patterns, mapping nfr categories to decisions, and defining components with clear boundaries and interfaces.

data-cleaning-pipeline covers systematic handling of missing values, outliers, duplicates, and data standardization using pandas and sklearn. includes practical python examples, quality metrics, and validation checks but lacks explicit error recovery strategies.

logging-best-practices covers structured logging implementation, log levels, pii redaction, and centralized systems. includes code examples and do/don't checklist but lacks concrete procedures for specific scenarios.

git-workflow-strategy documents branching patterns and merge workflows across gitflow, github flow, and trunk-based approaches. covers feature, release, and hotfix procedures with team collaboration guidance.

ux-designer covers wireframing, user flow definition, and wcag 2.1 compliance within a phase 2-3 planning context. executes via a single /create-ux-design command that loads requirements, produces ascii/structured mockups, and hands off design tokens to developers.

rate-limiting-implementation covers token bucket, sliding window, and distributed algorithms with code examples and best practices, but lacks concrete decision triggers and complete step-by-step procedures for integration.

cohort-analysis provides a complete python implementation for tracking user groups over time, calculating retention matrices, churn rates, and lifetime value. covers retention curves, revenue analysis, and standard visualizations but lacks guidance on real data integration.

visual-regression-testing covers automated screenshot comparison to catch css, layout, and design regressions across browsers and viewports. includes playwright, percy, chromatic, and backstopjs approaches with practical examples.

causal-inference provides python implementations of propensity scoring, regression adjustment, and doubly robust estimation to estimate treatment effects from observational data. includes worked example with synthetic confounding, heterogeneous effect analysis, and sensitivity testing but lacks guidance on assumption validation and when methods fail.

model-deployment covers training to production pipelines using fastapi, docker, and cloud platforms, with working code examples for rest apis, batch processing, monitoring, and mlflow integration.

stress-testing covers load progression, breaking point identification, and recovery validation using k6 and jmeter. includes staged load profiles and threshold monitoring.

product-manager specializes in authoring prds and tech specs with moscow/rice prioritization, epic-to-user-story decomposition, and requirements traceability. validates that requirements are testable and measurable. intended for phase 2 planning workflows.

statistical-hypothesis-testing provides python implementations of parametric and non-parametric tests (t-test, anova, chi-square, mann-whitney) with effect size calculations, confidence intervals, and power analysis. covers test selection, assumptions validation, and multiple comparison corrections.

ml-pipeline-automation covers end-to-end orchestration of data ingestion, processing, training, validation, and deployment using airflow with mlflow experiment tracking and modular python functions.

api-rate-limiting covers protection strategies for apis using token bucket, sliding window, and redis-based approaches. provides code patterns for per-user, per-ip, and per-endpoint rate limiting with tiered service plan support.

api-pagination covers offset, cursor, and keyset strategies for handling large datasets. includes code examples and best practices, though lacks concrete decision logic and failure recovery steps.

dimensionality-reduction covers pca, t-sne, umap, and feature selection techniques with working python examples on iris data. provides visualization and model comparison but lacks guidance on technique selection and failure recovery.

static-code-analysis documents automated code inspection via linters and AST tools. covers eslint, pylint, mypy, sonarqube, and pre-commit integration. lacks concrete decision logic and failure recovery patterns.

bmad-orchestrator routes users through structured ai-driven development phases, initializing projects and tracking workflow status, but lacks procedural depth and error handling specifics.

data-migration-scripts provides templates and patterns for writing reversible database migrations with knex.js and alembic, covering schema changes and data transformations. lacks concrete runnable procedures and edge case recovery detail.

csrf-protection outlines synchronizer token, double-submit cookie, and samesite approaches to prevent cross-site request forgery. covers token generation, expiration, and validation across node.js, python, and frontend contexts with best practices checklist.

gcp-cloud-run covers containerized application deployment on google cloud run with gcloud cli commands, covering image building, service deployment, access control, and resource configuration.

background-job-processing covers distributed task queue patterns, worker pools, and job scheduling across python, node.js, and ruby. provides timeouts, retry logic, and monitoring guidance but lacks concrete implementation steps.

security-headers-configuration provides patterns for implementing http security headers across multiple frameworks (node.js, nginx, python, apache) to mitigate xss, clickjacking, and mime-sniffing attacks.

time-series-analysis covers decomposition, stationarity testing, and forecasting via arima, exponential smoothing, and related techniques. includes python implementation with sample workflows for trend extraction, seasonality detection, and confidence-interval predictions.

accessibility-testing covers automated and manual validation of wcag compliance, keyboard navigation, screen reader compatibility, and assistive technology integration using tools like axe-core and playwright.

performance-testing covers load testing, benchmarking, and throughput measurement across multiple frameworks (k6, jmeter, pytest-benchmark, jmh). provides quick-start code and best-practice checklists but lacks concrete decision logic or failure recovery guidance.

semantic-versioning establishes version numbering practices using conventional commits and automated tooling. covers configuration, changelog generation, and release automation with reference guides.

gitlab-cicd-pipeline outlines multi-stage pipeline setup with runner infrastructure, docker caching, and kubernetes deployment. structure is present but procedures lack depth and edge cases go unaddressed.

health-check-endpoints provides patterns for monitoring service health across kubernetes, load balancers, and service discovery. covers liveness and readiness probes with typescript examples and multi-framework reference guides.

anomaly-detection covers statistical, distance, isolation, density, and deep learning methods for identifying outliers in fraud, system monitoring, and sensor data. includes python implementation with five detection algorithms, ensemble voting, and time-series analysis.

concurrency-patterns covers synchronization primitives and parallel execution patterns across multiple languages, with incomplete quick-start code and reference material that lacks depth on failure modes.

aws-s3-management covers bucket creation, encryption, versioning, and access controls via aws cli and terraform. lacks procedural depth and edge case handling for production deployments.

uptime-monitoring provides foundational patterns for health checks, status pages, and incident tracking. covers nodejs and kubernetes implementations with best practices guidance but lacks concrete decision trees and failure recovery steps.

api-authentication covers jwt, oauth 2.0, api keys, and session management patterns. the quick start is incomplete (truncated mid-function) and edge cases lack explicit recovery procedures.

aws-lambda-functions covers serverless function deployment on aws with cli examples, reference guides, and best practices checklist. lacks detailed procedure steps and edge case handling.

test-data-generation covers factory and builder patterns for creating realistic, reusable test fixtures. includes code examples and best practices but lacks decision logic and failure recovery.

grpc-service-development covers protocol buffer definitions and streaming patterns for building microservices, with reference implementations across node.js and python but lacks actionable procedural depth.

ansible-automation provides a framework for infrastructure provisioning and configuration management via playbooks and roles, with a do/dont checklist but minimal procedural depth or failure recovery guidance.

exploratory-data-analysis covers dataset profiling, distribution analysis, correlation assessment, and outlier detection through python code examples, though lacks actionable decision logic and error handling.

feature-flag-system outlines use cases and data structures for implementing flags but lacks actionable procedures, concrete trigger examples, and explicit failure-mode handling. best practices are listed but not integrated into step-by-step guidance.

code-metrics-analysis provides frameworks for measuring cyclomatic and cognitive complexity, nesting depth, and function/class counts in typescript and python codebases, with guidance on threshold-setting and ci/cd integration.

stored-procedures covers design and implementation of database functions, procedures, and triggers across postgresql and mysql. includes scalar function examples, error handling patterns, and basic best practices, but lacks depth on failure modes and recovery strategies.

api-gateway-configuration covers design and setup of gateways for routing, authentication, rate limiting, and request transformation in microservice architectures, with vendor-specific reference implementations.

application-logging covers structured logging setup across node.js and python with winston and elk stack integration, including best practices for log levels, context injection, and centralized aggregation.

disaster-recovery-testing outlines a framework for validating recovery procedures, measuring rto/rpo, and training incident response teams through systematic testing exercises and checklists.

webhook-integration outlines patterns for event-driven communication but lacks concrete procedural steps, actionable decision trees, and a defined outcome signal beyond best practices checklists.

github-actions-workflow documents ci/cd automation patterns for github repositories, covering testing, builds, deployments, and security scanning through yaml configuration and best practice checklists.

real-time-features covers websocket and sse patterns for bidirectional client-server communication, with reference guides and best practices checklist but incomplete implementation details.

memory-leak-detection provides heap snapshot tooling and best practices for nodejs memory profiling, but lacks executable decision logic and concrete debugging workflows.

vulnerability-scanning covers automated and manual identification of security flaws across applications, dependencies, and infrastructure using multiple tools. lacks actionable procedures and explicit failure handling.

aws-ec2-setup documents ec2 instance provisioning via aws cli and terraform with basic security group configuration, best practices checklist, and reference pointers but lacks actionable decision logic and failure handling.

aws-cloudfront-cdn documents cdn setup via aws cli and terraform with basic security guidance, but lacks actionable decision logic and explicit failure handling for common deployment scenarios.

network-analysis covers identification of communities and centrality measures within interconnected systems, but lacks concrete procedural guidance for implementation and deployment.

synthetic-monitoring provides a playwright-based framework for simulating user journeys and api flows, with best practices guidance but incomplete procedural depth and missing deployment context.

configuration-management covers environment setup, secrets handling, and 12-factor principles across environments. provides best-practice checklists but lacks executable procedures and failure-mode guidance.

sentiment-analysis provides working python code for lexicon and machine learning approaches on sample data, but lacks actionable intent, real input contracts, and failure handling. suitable as educational reference, not production skill.

capacity-planning provides overhead-adjusted capacity calculation formulas and best-practice checklists for team resource allocation, but lacks executable procedures and concrete decision logic.

cloud-storage-optimization covers cost reduction and performance tuning across multiple clouds via tiering, compression, and lifecycle policies. lacks actionable procedures and edge case handling.

oauth-implementation provides scaffolding for oauth 2.0 and openid connect flows with code examples and best practices checklists, but lacks executable step-by-step procedures and concrete failure handling.

log-aggregation provides docker-compose templates and reference guides for elk stack, logstash, and loki deployments. lacks concrete procedures, decision logic, and failure handling.

test-automation-framework outlines structural patterns for building maintainable test suites using page object model and fixtures, with code examples in typescript and python. lacks actionable procedures and specific invocation context.

react-native-app covers cross-platform mobile development patterns with navigation and state management, but lacks concrete procedures and decision logic needed for executable automation.

service-mesh-implementation provides high-level guidance on deploying istio for microservice communication, traffic management, and security, but lacks concrete procedural depth and failure-mode coverage.

artifact-management covers docker image registry operations, package publishing, and build artifact storage with multi-stage dockerfile patterns and retention policies, but lacks executable decision logic.

azure-functions covers serverless compute on azure with event-driven patterns, bindings, and scaling. lacks concrete implementation examples and explicit failure handling guidance.

caching-strategy outlines redis-based caching patterns with do/don't lists but lacks concrete decision trees, failure mode handling, and actionable procedures for cache invalidation or stampede scenarios.

design-patterns-implementation provides reference material for common architectural patterns like singleton and factory, with code examples and best practice guidance, but lacks procedural depth for actual implementation decisions.

agile-sprint-planning outlines a checklist-based approach to organizing sprint cycles, covering backlog grooming, capacity estimation, and team coordination. lacks concrete decision logic or failure handling.

kubernetes-deployment provides yaml scaffolding and best practice checklists for containerized application orchestration, but lacks procedural depth, decision logic, and failure mode guidance.

cicd-pipeline-setup outlines patterns for automated testing, building, and deployment across multiple environments. references point to vendor-specific implementations but core procedures remain incomplete.

gcp-cloud-functions documents serverless function deployment on gcp via gcloud cli and terraform, with setup guidance and best practices checklists but lacks detailed execution steps and error handling specifics.

profiling-optimization provides foundational patterns for measuring code performance via marks and timers, with reference guides covering node.js, chrome devtools, python cprofile, and flame graphs. lacks procedural depth and failure handling.

code-review-analysis outlines a systematic review framework covering quality, security, and performance, but lacks actionable procedures and decision logic for actual implementation.

model-monitoring provides conceptual coverage of drift detection and performance tracking in production ml systems, though lacks actionable procedures or concrete implementation steps.

container-debugging covers docker and kubernetes troubleshooting for startup failures, crashes, resource limits, and networking. provides basic command reference without systematic diagnosis methodology.

reactive-programming covers rxjs observables and streams for async data handling. outlines when-to-use patterns and lists reference guides without concrete procedural steps or decision logic.

computer vision covers image classification, object detection, semantic segmentation, and pose estimation via pytorch and tensorflow implementations. provides architecture overviews and synthetic data examples but lacks procedural clarity on when and how to apply each approach.

django-application provides reference guides and best practices for building django web applications, covering models, views, authentication, and admin interfaces. lacks specific procedural steps and concrete decision trees.

dependency-management documents npm workflows, semantic versioning, lock file handling, and security auditing across multiple language ecosystems. lacks actionable decision logic and concrete failure scenarios.

xss-prevention outlines input sanitization and output encoding tactics across multiple languages, but lacks concrete procedures and decision logic for context-specific threat scenarios.

color-accessibility documents wcag contrast standards and best practices for accessible color design, but lacks actionable implementation steps and specific tool integration procedures.

project-estimation covers techniques like pert, bottom-up, and analogous estimation for planning realistic timelines and budgets. includes best practices but lacks executable workflow clarity.

transaction-management documents acid compliance, isolation levels, and locking strategies across postgresql and mysql, with basic examples but lacks actionable procedures and explicit failure handling.

aws-rds-database documents rds deployment patterns across multiple engines with cli examples and best practice checklists, but lacks concrete decision logic and failure handling.

event-sourcing documents the pattern of storing state as immutable event sequences, with code examples and best practices but lacks actionable procedures for implementation and edge case handling.

risk-assessment provides a categorical framework for identifying project threats across technical, resource, and schedule domains, with best practice guidance but lacks executable procedures and concrete decision logic.

security-audit-logging provides a foundational audit logging pattern with winston-based structured logging, elasticsearch integration, and compliance checklists, but lacks concrete procedures for retention, siem workflows, and failure recovery.

graphql-implementation covers schema design, resolver patterns, and performance optimization for graphql apis. provides reference guides and best practices but lacks actionable procedural depth.

accessibility-compliance documents wcag principles and best practices for building accessible web applications, but lacks concrete decision trees, failure recovery procedures, and testable acceptance criteria.

database-performance-debugging provides cross-vendor query logging and execution plan analysis for mysql, postgresql, and sql server, but lacks actionable debugging workflow and concrete recovery procedures.

flutter-development covers mobile app construction with dart and flutter's widget system, including navigation, state management, and api integration patterns, but lacks executable procedures and failure handling specifics.

query-caching-strategies covers redis, memcached, and database-level caching with ttl management and invalidation patterns. provides a node.js redis example but lacks concrete implementations for most advertised techniques.

frontend-testing provides a shallow overview of test frameworks and patterns for react/vue applications, with code examples but minimal procedural depth or failure mode analysis.

css-architecture covers three naming and organization methodologies (BEM, SMACSS, CSS-in-JS) for building maintainable styling systems at scale, with reference guides but limited procedural depth.

database-schema-design covers normalization forms, relationship patterns, and constraint strategies for postgresql schema definition. lacks concrete decision criteria and deployment guidance.

load-balancer-setup provides skeletal guidance on deploying load balancers for traffic distribution and high availability, but lacks procedural depth and concrete trigger conditions.

secrets-rotation outlines automated credential and key rotation with zero-downtime deployment, but lacks concrete procedural steps and specific trigger conditions for practical implementation.

polyglot-integration documents strategies for calling code across language boundaries (node native addons, python, rust, grpc, java) with incomplete procedures and vague decision criteria.

blue-green-deployment outlines a pattern for zero-downtime releases across two identical production environments with traffic switching, but lacks concrete, complete procedures and edge case handling.

zero-trust-architecture outlines identity-centric security principles and microsegmentation patterns for cloud-native systems, with incomplete code examples and generic best practice checklists.

ml-model-explanation lists explainability techniques (shap, lime, feature importance, partial dependence, attention maps) but provides no actionable procedure, trigger conditions, or concrete implementation guidance for applying them.

webhook-development provides a skeleton outline for event delivery and retry logic but lacks concrete procedural steps, failure mode analysis, or actionable trigger conditions. the quick-start example is inert boilerplate.

fastapi-development provides high-level overview of fastapi capabilities including async support, type validation, and orm integration, but lacks actionable procedures and concrete trigger conditions.

database-query-optimization provides a framework for identifying and resolving slow queries through explain analysis, indexing strategy, and caching techniques. covers detection, diagnosis, and common remediation patterns.

code-documentation outlines language-specific standards for function, class, and api documentation with best practices checklists, but lacks actionable procedures for implementation and skill orchestration.

frontend-state-management catalogs patterns and libraries for managing application state, covering redux, zustand, context api, and mobx with boilerplate examples but minimal actionable guidance.

user-persona-creation outlines research-driven persona development with interview templates and best practices, but lacks actionable procedural steps and concrete decision criteria for synthesis.

bundle-size-optimization provides analysis tools and high-level guidance for reducing javascript/css payload. lacks concrete procedures, error handling, and specific trigger conditions.

api-response-optimization addresses payload bloat and caching through general best practices, but lacks concrete implementation steps and decision criteria for when to apply each technique.

data-replication-setup outlines replication topology options (master-slave, multi-master) and monitoring considerations for disaster recovery and availability scenarios, but lacks concrete implementation steps and vendor-specific guidance.

performance-regression-debugging covers detecting and resolving performance degradation after code changes, with baseline comparison and metric monitoring, but lacks actionable procedural detail.

information-architecture outlines user research and structural planning for navigational design, covering card sorting, taxonomy, and validation through testing. scope is broad but lacks implementation depth.

infrastructure-monitoring provides a template-based approach to setting up prometheus, alertmanager, and grafana stacks. covers config generation and deployment patterns but lacks specificity on operational procedures and failure scenarios.

form-validation covers client and server-side input validation with typescript type safety, but lacks concrete decision logic, failure recovery paths, and actionable step-by-step procedures.

mocking-stubbing defines the conceptual difference between test doubles but stops short of actionable guidance. it sketches a table of contents without delivering the promised content sections.

process-mapping documents workflow visualization techniques across current-state, future-state, and value-stream approaches. lacks specific procedures and actionable steps for execution.

multi-cloud-strategy outlines architectural principles for leveraging multiple cloud providers, covering cost optimization, vendor lock-in avoidance, and geographic distribution. lacks concrete decision trees and actionable runbooks.

mobile-app-testing outlines testing categories (unit, ui, integration, performance) but lacks concrete procedures, trigger conditions, and decision logic to guide actual test execution.

infrastructure-cost-optimization provides aws and kubernetes cost analysis patterns via shell scripts and yaml configs, but lacks concrete decision logic, failure handling, and actionable step sequences.

kpi-dashboard-design provides a checklist-style overview of dashboard creation with best practices listed, but lacks actionable step-by-step procedures, specific trigger scenarios, and failure mode handling.

interaction-design documents common ui patterns like swipe, tap-hold, and drag-drop with general guidance on feedback and accessibility, but lacks executable procedures and concrete implementation paths.

network-debugging covers identification of connectivity and latency issues, but lacks procedural depth, actionable steps, and concrete failure recovery guidance. the skill is incomplete.

sql-query-optimization provides high-level guidance on analyzing query bottlenecks and applying indexing strategies, but lacks concrete procedural steps, decision logic, and actionable recovery patterns.

user-research-analysis covers synthesis of qualitative and quantitative research data into themes and insights. the skill prescribes thematic coding and affinity mapping but lacks executable procedural depth and concrete decision logic.

deployment-documentation provides a template structure and checklist for creating deployment guides, but lacks actionable procedures, specific trigger phrases, and concrete decision logic needed to execute deployments.

database-schema-documentation provides a template structure for organizing schema artifacts (erd, data dictionaries, migration scripts) but lacks procedural steps for actually generating or maintaining documentation across schema changes.

memory-optimization provides general guidance on profiling tools and best practices for reducing memory consumption, but lacks concrete procedures and decision logic.

progressive-web-app documents pwa fundamentals including manifests, service workers, and offline support, but lacks actionable procedures and decision logic needed for skill execution.

design-handoff outlines a checklist and best practices framework for transferring design specifications to development, but lacks concrete procedural steps, specific trigger contexts, and failure mode handling.

api-reference-documentation is a template for writing api docs, not a skill. it lists what should go in openapi specs and best practices, but provides no actionable procedure for generating, validating, or publishing documentation.

gap-analysis provides a taxonomy of capability categories and a stub implementation for comparing current versus future states, but lacks concrete procedural steps, trigger conditions, and failure mode handling.

angular-module-design documents feature module patterns, lazy loading, and service architecture for scaling angular applications, but lacks actionable procedures and edge case handling.

root-cause-analysis documents a conceptual framework for identifying failure origins using the 5 whys iterative questioning method, paired with templated reporting structure and best practices guidance.

security-documentation provides a template structure for writing security policies and compliance documentation, but lacks procedural depth and actionable guidance for implementation or enforcement.

database-backup-restore outlines backup types and recovery strategies with postgresql examples, but lacks actionable procedures, failure mode documentation, and vendor-specific trigger guidance.

internationalization-i18n outlines concepts for multi-language apps but lacks executable procedures, concrete examples, and failure mode guidance. structure is skeletal.

architecture-diagrams provides a skeletal outline for generating system diagrams via mermaid and plantuml, but lacks actionable procedure, specific trigger phrases, and substantive guidance beyond tool names.

email-service-integration is a skeleton outline covering smtp and third-party providers, but lacks executable procedure, trigger examples, and concrete implementation guidance.

ruby-rails-application is a high-level framework overview that names key rails concepts (models, controllers, active record, authentication) but provides no executable procedure, trigger conditions, or implementation guidance.

incomplete skill definition for ios swift development. the file declares intent but lacks actionable procedure, specific trigger phrases, failure modes, or decision points needed for cross-vendor automation.

stakeholder-communication outlines communication principles without actionable procedures, inputs, or output contracts required for skill automation.

continuous-testing describes an integration pattern for automated quality feedback across the development lifecycle, but lacks executable procedure detail and concrete implementation guidance.

Product discovery and requirements analysis specialist. Conducts stakeholder interviews, market research, problem discovery, and creates product briefs. Use…

android-kotlin-development — an installable skill for AI agents, published by aj-geddes/useful-ai-prompts.

rest-api-design — an installable skill for AI agents, published by aj-geddes/useful-ai-prompts.

>

>

>

Build predictive models using linear regression, polynomial regression, and regularized regression for continuous prediction, trend forecasting, and…

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

Identify groups and patterns in data using k-means, hierarchical clustering, and DBSCAN for cluster discovery, customer segmentation, and unsupervised learning

>

>

Measure relationships between variables using correlation coefficients, correlation matrices, and association tests for correlation measurement, relationship…

>

>

>

>

>

>

>

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

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

Create effective visualizations using matplotlib and seaborn for exploratory analysis, presenting insights, and communicating findings with business…

>

Brainstorming and research automation specialist

>

>

>

Build recommendation systems using collaborative filtering, content-based filtering, matrix factorization, and neural network approaches

>

Build NLP applications using transformers library, BERT, GPT, text classification, named entity recognition, and sentiment analysis

Build collaborative and content-based recommendation engines for product recommendations, personalization, and improving user engagement

>

>

database-indexing-strategy — an installable skill for AI agents, published by aj-geddes/useful-ai-prompts.

frontend-routing — an installable skill for AI agents, published by aj-geddes/useful-ai-prompts.

>

dns-management — an installable skill for AI agents, published by aj-geddes/useful-ai-prompts.

Design and architect neural networks with various architectures including CNNs, RNNs, Transformers, and attention mechanisms using PyTorch and TensorFlow

Build and train machine learning models using scikit-learn, PyTorch, and TensorFlow for classification, regression, and clustering tasks

>