@aj-geddes

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.

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.

changelog-maintenance provides templates and formatting guidance for keep a changelog style version documentation, with concrete examples across multiple release formats and semantic versioning conventions.

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.

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.

classification-modeling covers binary and multiclass prediction using logistic regression, decision trees, random forests, and gradient boosting with evaluation via standard metrics and cross-validation.

jenkins-pipeline provides declarative and scripted pipeline templates for ci/cd automation, covering multi-stage builds, parameterization, and artifact management. lacks explicit trigger conditions and failure recovery strategies.

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.

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.

user-story-writing documents structured practices for writing testable user stories with acceptance criteria in given-when-then format. covers templating, estimation, and common pitfalls but lacks concrete worked examples and implementation guidance.

file-upload-handling outlines validation, sanitization, virus scanning, and cdn integration patterns for building secure upload systems. covers multiple frameworks but lacks executable procedures and concrete error handling.

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.

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.

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.

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.

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.

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.

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.

push-notification-setup provides a foundation for firebase cloud messaging integration across ios and android, with code samples and checklists but lacks actionable decision logic and failure recovery steps.

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.

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

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.

backup-disaster-recovery outlines strategy and best practices for data protection and business continuity, but lacks executable procedures and vendor-specific implementation details needed for cross-vendor skill graph integration.

terraform-infrastructure documents terraform fundamentals and multi-cloud provisioning patterns, but lacks concrete decision logic, error handling, and actionable procedural steps beyond setup.

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.

spring-boot-application provides a checklist of spring conventions and architectural patterns (layers, di, jpa) but lacks executable procedures for actual deployment or runtime scenarios.

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.

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.

web-performance-optimization covers lazy loading, code splitting, caching, and monitoring tactics for improving core web vitals, but lacks actionable procedures and concrete failure handling.

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.

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.

wireframe-prototyping provides guidance on fidelity levels and best practices for design validation, but lacks actionable procedures for agents to execute wireframing tasks or integrate with tools.

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.

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.

user-guide-creation provides a template and checklist for structuring product documentation, covering layout, content sections, and best practices for clarity and usability.

technical-roadmap-planning provides a template and checklist framework for multi-year technology strategy. lacks concrete procedures, decision criteria, and failure mode handling needed for actionable execution.

api-security-hardening lists security middleware components for rest apis, covering authentication and input validation across node.js and python frameworks. lacks concrete procedural depth and explicit failure handling.

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.

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.

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.

log-analysis covers structured logging patterns and best practices for debugging, but lacks actionable procedures, specific trigger contexts, and failure mode guidance.

websocket-implementation provides only skeletal documentation covering real-time communication architecture without actionable procedures, specific implementation guidance, or failure handling details.

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.

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.

markdown-documentation is a reference guide for syntax and formatting conventions, covering core markdown, github flavored extensions, and documentation practices. it lacks actionable procedures for actual documentation workflows.

database-migration-management provides structural scaffolding for migration workflows but lacks procedural depth, specific trigger definitions, and concrete failure handling strategies needed for production use.

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.

penetration-testing defines what pen testing is conceptually but provides no actionable steps, decision logic, input/output contracts, or failure handling needed 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…

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

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

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.

>

>

>

>

>

>

>

>

>

>

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

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

Build end-to-end ML pipelines with automated data processing, training, validation, and deployment using Airflow, Kubeflow, and Jenkins

Reduce feature dimensionality using PCA, t-SNE, and feature selection for feature reduction, visualization, and computational efficiency

>

>

>

>

>

>

>

>

>

>

>

>

>

>

Monitor model performance, detect data drift, concept drift, and anomalies in production using Prometheus, Grafana, and MLflow

>

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

intermittent-issue-debugging — an installable skill for AI agents, published by aj-geddes/useful-ai-prompts.

>

react-component-architecture — an installable skill for AI agents, published by aj-geddes/useful-ai-prompts.