aj-geddes
312 verified skills55,493 total stars
bmad-epics-and-stories
Solutioning flagship — shards a PRD + architecture into epics.md and individual {epic}.{story}.{slug}.story.md context objects, the LAST planning artifact before external dev handoff. Each story is a self-contained ~8K-token compiled context object: Dev Notes with SOURCE CITATIONS back to prd.md/architecture.md, Acceptance Criteria, Tasks/Subtasks mapped to ACs, Testing strategy, Dependency Maps, an explicit Owned File/Module Scope list (the lever for parallel-conflict-free scheduling), and Learnings from Previous Stories. Sized to one dev-day; split if larger; NO story points. Use when the user says "shard the PRD", "create epics", "break the PRD into epics", "break this epic into stories", "create stories", "create a story", "draft story files", "generate the story for X", "prepare stories for dev", "mark the story ready for dev", "validate this story", or "what stories are in this epic". Three intents: Create new epics/stories, Update an existing story, or Validate a draft against the contract.
development451
bmad-document-project
BROWNFIELD planning input. Scans an existing codebase READ-ONLY and writes project-documentation.md — ground truth for stack, structure, key flows, conventions, and integration points — so downstream BMAD planning skills start from reality. Does NOT modify code; produces only the doc artifact. Use when the user says: "document this codebase", "document the project", "document my app", "scan the existing code", "brownfield planning", "we have existing code, start planning", "map what's already built", "document current state", "capture the current architecture", "understand the existing system before planning", "write project-documentation.md", or before a PRD or architecture doc when the user already has code written. Three intents: Create (initial scan), Update (re-scan changed areas), Validate (check completeness). Plans only — reads code but never writes it, runs no tests, no linters, no build tools, no application code.
tools451
bmad-readiness-check
SOLUTIONING GATE — validates cohesion across planning artifacts before any implementation begins. Cross-references PRD (or tech-spec), architecture document, and epics/stories for coverage consistency and missing pieces. Returns a verdict of PASS, CONCERNS, or FAIL with specifics. Does NOT touch code. Use when the user says: - "check if we're ready to build" / "are we ready to implement?" - "validate planning" / "gate check" / "readiness check" - "run the solutioning gate" / "check implementation readiness" - "is the architecture complete?" / "do requirements match architecture?" - "sign off on planning" / "planning done, check it" - "validate PRD against architecture" / "cross-reference planning docs" Intents supported: Validate (primary). Track-adaptive: works for Quick Flow (tech-spec + architecture), BMad Method (PRD + architecture + epics), and Enterprise (all of the above + optional security/DevOps addenda).
development451
bmad-help
Orchestration spine and "what do I do next?" router for the BMAD Planning & Orchestrator plugin. Detects current planning state by scanning the output folder for which artifacts exist (project-context.md, decision-log.md, product-brief, prd/tech-spec, architecture, ux, epics, stories), infers the current phase and track, then recommends the next BMAD skill to run — skipping optional phases (Analysis is always optional; UX only when there is a UI). Use when the user asks "what's next", "what do I do next", "where am I", "what's my status", "continue", "resume planning", "which skill should I run", "what BMAD step is next", or types "/bmad-help" / "/status". Auto-invoke at the start of any BMAD planning session to orient. This skill ROUTES only — it never writes planning documents itself.
tools451
bmad-builder
Meta-skill for scaffolding and validating custom PLANNING/ORCHESTRATION skills within the BMAD Planning & Orchestrator plugin. Produces the full skill directory: SKILL.md, scripts, and templates — all pre-targeted at this plugin's path conventions. Includes a scope-violation checker so newly created skills never drift into dev/lint/build/coverage territory. Use when the user says "create a skill", "scaffold a skill", "build a new planning skill", "add a skill to the orchestrator", "extend BMAD planning", "custom orchestration skill", "validate this skill", "check this skill for scope violations", "new skill for the planner", or "bmad-builder". Supports three intents: Create (new skill skeleton), Validate (check an existing SKILL.md), Scaffold (directory structure only). This skill plans and scaffolds only — it NEVER writes application code, runs tests, lints, or builds.
tools451
bmad-architecture
Solutioning skill (Winston, the Architect). Produces architecture.md with ADRs and systematic NFR coverage, mapping every FR/NFR from the PRD to a concrete design decision. ONE architecture forces all future parallel dev agents to share the same API style, data model, state management, naming conventions, and security approach — catching alignment here is 10x cheaper than during implementation. Use when the user says "design the architecture", "create architecture", "/architecture", "solutioning", "tech stack", "system design", "ADR", "architecture decision record", "data model", "API design", "NFR coverage", "non-functional requirements", or after a PRD is done and they ask "what's next" / "ready for solutioning". Supports Create (new architecture.md), Update (revise against PRD changes), and Validate (check coverage + ADR completeness). PLANS only — never writes application code, runs tests, lints, or builds.
development451
bmad-tech-spec
Quick Flow lightweight technical specification for small-scope work (1-15 stories). Replaces the full PRD + architecture pair when scope is small and requirements are clear. Produces bmad-output/tech-spec.md as the single planning artifact before story creation. Use when the user says: "write a tech spec", "create a technical specification", "I need a tech spec for this feature", "quick spec", "small project spec", "we don't need a full PRD", "just a tech spec", "spec out this change", "document this feature". QUICK FLOW TRACK ONLY (1-15 stories). If scope grows beyond ~15 stories or involves multiple teams / external integrations at scale, stop and redirect to bmad-prd + bmad-architecture instead — those skills are built for that complexity. Supports three intents: Create (new spec), Update (revise an existing tech-spec.md), Validate (review a draft for completeness against BMAD criteria).
testing451
bmad-correct-course
CROSS-PHASE mid-stream scope correction. Re-enters planning when requirements, features, architecture, or constraints change after planning has started. Re-shards affected epics/stories, re-sequences sprint-status.yaml, appends rationale to decision-log.md. Routes to bmad-epics-and-stories, bmad-sprint-planning, or bmad-parallel-plan as needed. Changes the PLAN, never code. Use when: "we need to change course", "scope has changed", "new requirement came in", "we're dropping feature X", "we need to pivot", "re-plan after the change", "requirements changed mid-sprint", "correct course", "architecture changed", "re-scope the backlog", "update epics after feedback", "cancel story X", "add epic for Y", "change the plan", "we got new constraints", or when stories are split/merged/reordered due to a decision not in the original plan. Produces: updated epics.md (affected only), revised/new story files, updated sprint-status.yaml, new decision-log.md entry. NEVER writes code or runs tests.
development451
bmad-product-brief
Lean facilitator for creating, updating, and validating a product brief — the Analysis-phase foundation of the BMAD Method. Captures problem statement, target users, core features, goals, constraints, and success metrics. Use when the user says: "create a product brief", "I need a product brief", "let's do discovery", "help me define my product", "what problem are we solving", "capture our product vision", "update the product brief", "validate the brief", "check if the brief is complete", "run discovery", "start a product brief", "brainstorm the product", or "I want to plan a product". Supports three intents: - Create — guided discovery conversation that fills and writes the brief - Update — amends one or more sections in an existing brief - Validate — completeness check against all required sections Output is a planning artifact only — no code is written or run.
development451
bmad-parallel-plan
Turns a sequential, ready-for-dev story backlog into conflict-free CONCURRENT WAVES. Builds a dependency DAG from epic order, per-story dependency maps, and Owned File/Module Scope overlaps, then topologically sorts it into parallel waves of mutually disjoint, dependency-satisfied stories (capped by maxParallel), and emits a parallelization-plan.md with per-story git-worktree branch names and an ordered merge sequence. Use when the user says "plan parallel work", "which stories can run in parallel", "parallelize the backlog", "build the wave plan", "parallelization plan", "conflict-free workstreams", "what can we run concurrently", "split into worktrees", "dependency graph for the stories", "merge order", or "how do I fan this backlog out to multiple dev agents". Run AFTER stories are ready-for-dev (scrum-master) and an architecture exists. This skill PLANS parallelism only — it does NOT run agents, spawn worktrees, write code, run tests, or perform git operations.
development451
bmad-prd
PRD facilitator (John the PM). Authors and maintains the Product Requirements Document — functional requirements (FR-###), non-functional requirements (NFR-###), an epics outline, user stories, acceptance criteria, and MoSCoW/RICE prioritization. Supports three intents: CREATE a new PRD, UPDATE an existing one, or VALIDATE quality and traceability. Emits prd.md plus addendum.md (overflow/notes) and appends decisions to decision-log.md. Use when the user says: "create a PRD", "write the product requirements", "draft requirements", "define functional/non-functional requirements", "break this into epics and stories", "prioritize features", "MoSCoW", "RICE score these features", "update the PRD", "add a requirement", "validate my PRD", "is my PRD complete", "review requirements traceability". This is PLANNING only — it never writes application code, runs tests, lints, or builds.
development451
bmad-brainstorm
Facilitates structured ideation sessions using proven brainstorming techniques (SCAMPER, SWOT, 5 Whys, Mind Mapping, Six Thinking Hats, Reverse Brainstorming, Starbursting, Brainwriting). Produces a brainstorming-report.md of organized ideas and actionable insights. Operates in three intents: Create (new session), Update (add techniques or deepen coverage), Validate (confirm insights align with project goals). Use when the user says: "brainstorm", "ideate", "generate ideas", "explore options", "SCAMPER", "SWOT analysis", "mind map", "Six Thinking Hats", "5 Whys", "creative session", "what if we", "let's explore", "think through possibilities", "find alternatives", or "problem-solve". This skill PLANS only — it never writes application code or runs tests.
development451
bmad-handoff
Emits a dev-tool-agnostic handoff manifest from ready-for-dev stories so an external dev plugin or runner can pick up and execute the work. Use when the user says "generate a handoff", "create handoff manifest", "export stories for dev", "hand off to dev tool", "produce handoff manifest", "ready to hand off", "prepare handoff for external tool", "export ready-for-dev stories", or "create the handoff package". Also trigger when the user asks "what stories are ready for dev?" and wants an exportable artifact rather than a status report. Produces: handoff-manifest.json listing all ready-for-dev stories with id, story file path, status, owned file/module scope, wave/parallel_set, dependencies, acceptance-criteria summary, locked-sections note, and a schemaVersion field. See REFERENCE.md (bundled) for the full manifest schema and adapter notes for git-worktree parallel development and autonomous dependency-graph orchestrators.
tools451
bmad-prfaq
Amazon-style Working-Backwards PRFAQ: a future press release plus internal and external FAQs that stress-test a product concept before any building begins. Produces prfaq.md in the configured output folder. Use when the user says: "write a PRFAQ", "working backwards", "press release", "future press release", "stress-test the concept", "validate the idea before building", "internal FAQ", "external FAQ", "Amazon-style product brief", or "PRFAQ for [product/feature]". Also use when someone wants to clarify or update an existing PRFAQ, or validate a draft against the Working-Backwards criteria. Supports three intents: Create / Update / Validate.
development451
bmad-spec
Distills ANY messy input — brain dump, transcript, long PRD, stakeholder notes, feature request, voice memo — into a tight five-field SPEC.md kernel that any downstream planning skill can consume. The five fields are: Problem, Capabilities, Constraints, Non-Goals, Success Metrics. Use when the user says "create a spec", "write a spec for", "distill this into a spec", "I have a brain dump", "turn this into something structured", "clean up these notes", "make a SPEC from", "I want to define the problem", "help me scope this", "summarize what we're building", "I have a PRD but need a kernel", "what are we actually solving?", or drops raw text/transcript and asks for structure. Also use when starting any new initiative and a clean shared definition is missing.
development451
bmad-ux
Solutioning-phase UX planning skill (optional; activate when the project has a UI). Produces TWO planning documents: DESIGN.md (the visual system — design tokens, color palette, typography, spacing, component specs, WCAG 2.1 AA contract) and EXPERIENCE.md (user journeys, flow diagrams, screen states, error/empty/loading handling). Use when the user says "design the UX", "create UX planning docs", "define the design system", "map the user flows", "UX for this feature", "wireframe the flows", "what are the user journeys", "accessibility design", "WCAG compliance", "design tokens", "responsive design plan", "mobile-first design", or "create DESIGN.md / EXPERIENCE.md". Runs after architecture is drafted and before stories are created. Supports Create / Update / Validate intents.
testing451
bmad-investigate
Forensic bug and issue triage. Produces a graded investigation case file: symptoms, evidence (graded A/B/C by confidence), ranked hypotheses, suspected components, and a recommended planning response. INVESTIGATES and DOCUMENTS only — does NOT fix code, run tests, or implement. Hands off as a story to an external dev tool. Use when the user says: - "investigate this bug" / "triage this issue" / "debug triage" - "what's causing [symptom]" / "why is [feature] broken" - "something's wrong with [component]" / "users are reporting [problem]" - "figure out what happened" / "root cause this" - "I need a bug report" / "create an investigation case file" - "forensic analysis" / "diagnose this" - "error triage" / "issue investigation" - "what do we know about [incident/issue]" Three intents: Create (new case file), Update (add evidence to open case), Validate (check draft for completeness before handoff). Output lands in bmad-output/; a fix story is drafted on handoff.
tools451
bmad-init
Initialize a BMAD planning workspace: pick a scale-adaptive TRACK (Quick Flow / BMad Method / Enterprise) interactively, then scaffold the output folder, a config file, an empty decision-log.md, and a project-context.md "constitution". Use when the user says "initialize BMAD", "set up BMAD", "start a new BMAD project", "scaffold the planning workspace", "bmad init", "create the bmad config", or is beginning planning and has no bmad-output/ folder yet. Also use when the user asks "which track should I use?" or "what scale is my project?". This is the FIRST skill to run before any other planning workflow (brief, PRD, architecture, stories).
testing451
bmad-research
Conducts market, competitive, domain, and technical research using live web sources, producing a cited research-report.md to inform BMAD planning decisions. Use when the user says: - "research [topic/market/technology]" - "competitive analysis" or "who are the competitors" - "market size" or "market landscape" - "technical research" or "evaluate [technology/framework]" - "domain research" or "industry analysis" - "what does the market look like" - "find out about [technology/space]" - "I need research before we plan" - "gather information on [topic]" Supports three modes: Create (new research), Update (refresh existing report with new sources), Validate (cross-check claims in an existing report against live sources). Output lands in bmad-output/ as a cited research-report.md ready for downstream planning skills (business-analyst, product-manager, system-architect).
development451
bmad-sprint-planning
Orchestration handoff bridge: emits and maintains sprint-status.yaml as the project's sequencing system-of-record. Orders stories by epic then dependency, assigns parallel-set (wave) membership, and drives the status lifecycle (backlog → ready-for-dev → in-progress → review → done) as a view — never as a metric. Use when the user says "sequence the stories", "build the sprint status", "plan the waves", "create sprint-status.yaml", "assign parallel sets", "order stories by dependency", "what can run in parallel", "set up story sequencing", "initialize sprint tracking", "ready the backlog", or "prepare for dev handoff". Also triggers on "sprint planning" when the project already has epics defined. SCOPE: SEQUENCING AND ORCHESTRATION ONLY. No velocity, no burndown, no committed points, no coverage metrics. Capacity is expressed as wave width (concurrent story count), not points. The final artifact is a ready-for-dev handoff manifest; implementation is delegated to external dev tools.
tools451
Product Manager
Product requirements and planning specialist
testing360
Builder
Custom agent and workflow creation specialist
development360
Creative Intelligence
Brainstorming and research automation specialist
tools360
business-analyst
Product discovery and requirements analysis specialist. Conducts stakeholder interviews, market research, problem discovery, and creates product briefs. Use for product brief, brainstorm, research, discovery, requirements gathering, problem analysis, user needs, competitive analysis, and setting foundation before product planning. Hands off to product manager when analysis complete.
testing360
creative-intelligence
Facilitates structured brainstorming sessions, conducts comprehensive research, and generates creative solutions using proven frameworks. Trigger keywords - brainstorm, ideate, research, SCAMPER, SWOT, mind map, creative, explore ideas, market research, competitive analysis, innovation, problem solving, feature generation
development360
scrum-master
Sprint planning and agile workflow specialist. Breaks epics into user stories, estimates complexity using story points, plans sprint iterations, and tracks velocity. Trigger keywords - sprint planning, user story, story points, velocity, backlog, sprint, epic breakdown, estimation, burndown, agile planning.
testing360
Business Analyst
Product discovery and requirements analysis specialist
testing360
Scrum Master
Sprint planning and agile workflow specialist
testing360
system-architect
Designs system architecture, selects tech stacks, defines components and interfaces, addresses non-functional requirements. Trigger words - architecture, system design, tech stack, components, scalability, security, API design, data model, NFR, patterns, microservices, monolith
development360
BMad Master
Core BMAD Method orchestrator and workflow manager
tools360
bmad-orchestrator
Orchestrates BMAD workflows for structured AI-driven development. Use when initializing BMAD in projects, checking workflow status, or routing between 4 phases (Analysis, Planning, Solutioning, Implementation). Manages project configs, tracks progress through project levels 0-4, and coordinates with specialized workflows. Trigger on /workflow-init, /workflow-status, or when users need BMAD setup.
development360
builder
Creates custom agents, workflows, and templates for BMAD. Extends BMAD functionality with domain-specific components. Trigger keywords - create agent, create workflow, custom skill, extend BMAD, new template, customize, scaffold skill
development360
ux-designer
Designs user experiences, creates wireframes, defines user flows, ensures accessibility. Trigger keywords - UX design, wireframe, user flow, accessibility, WCAG, mobile-first, responsive, UI design, user journey, interface design, user experience, design system, component design, interaction design
content-media360
Developer
Story implementation and code development specialist
development360
UX Designer
User experience and interface design specialist
testing360
developer
Implements user stories, writes clean tested code, follows best practices. Trigger keywords implement story, dev story, code, implement, build feature, fix bug, write tests, code review, refactor
development360
System Architect
System architecture and technical design specialist
testing360
product-manager
Product requirements and planning specialist. Creates PRDs and tech specs with functional/non-functional requirements, prioritizes features using MoSCoW/RICE frameworks, breaks down epics into user stories, and ensures requirements are testable and traceable. Use for PRD creation, requirements definition, feature prioritization, tech specs, epics, user stories, and acceptance criteria.
development360
Network Analysis
Analyze network structures, identify communities, measure centrality, and visualize relationships for social networks and organizational structures
testing154
network-debugging
Debug network issues using browser tools and network analysis. Diagnose connection problems, latency, and data transmission issues.
tools154
nodejs-express-server
Build production-ready Express.js servers with middleware, authentication, routing, and database integration. Use when creating REST APIs, managing requests/responses, implementing middleware chains, and handling server logic.
development154
performance-testing
Design and execute performance tests to measure response times, throughput, and resource utilization. Use for performance test, load test, JMeter, k6, benchmark, latency testing, and scalability analysis.
testing154
process-mapping
Visualize and document current and future business processes. Identify inefficiencies, dependencies, and improvement opportunities through detailed process mapping and analysis.
testing154
pull-request-automation
Automate pull request workflows with templates, checklists, auto-merge rules, and review assignments. Reduce manual overhead and improve consistency.
tools154
Recommendation System
Build collaborative and content-based recommendation engines for product recommendations, personalization, and improving user engagement
development154
Regression Modeling
Build predictive models using linear regression, polynomial regression, and regularized regression for continuous prediction, trend forecasting, and relationship quantification
development154
requirements-gathering
Systematically collect, document, and validate requirements from stakeholders. Ensure clarity, completeness, and agreement before development begins to reduce scope creep and rework.
development154
security-compliance-audit
Conduct comprehensive security compliance audits for SOC 2, GDPR, HIPAA, PCI-DSS, and ISO 27001. Use when preparing for certification, annual audits, or compliance validation.
testing154
Sentiment Analysis
Classify text sentiment using NLP techniques, lexicon-based analysis, and machine learning for opinion mining, brand monitoring, and customer feedback analysis
research154
sql-injection-prevention
Prevent SQL injection attacks using prepared statements, parameterized queries, and input validation. Use when building database-driven applications securely.
development154
stress-testing
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.
testing154
terraform-infrastructure
Infrastructure as Code using Terraform with modular components, state management, and multi-cloud deployments. Use for provisioning and managing cloud resources.
development154
test-data-generation
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.
development154
transaction-management
Manage database transactions for data consistency. Use when implementing ACID compliance, handling concurrency, or managing transaction isolation levels.
testing154
user-persona-creation
Create detailed user personas based on research and data. Develop realistic representations of target users to guide product decisions and ensure user-centered design.
development154
user-story-writing
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.
development154
webhook-development
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.
development154
troubleshooting-guide
Create comprehensive troubleshooting guides, FAQ documents, known issues lists, and debug guides. Use when documenting common problems, error messages, or debugging procedures.
development154
api-filtering-sorting
Implement advanced filtering and sorting capabilities for APIs with query parsing, field validation, and optimization. Use when building search features, complex queries, or flexible data retrieval endpoints.
development154
A/B Test Analysis
Design and analyze A/B tests, calculate statistical significance, and determine sample sizes for conversion optimization and experiment validation
testing154
agile-sprint-planning
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.
development154
android-kotlin-development
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.
development154
api-authentication
Implement secure API authentication with JWT, OAuth 2.0, API keys, and session management. Use when securing APIs, managing tokens, or implementing user authentication flows.
development154
api-changelog-versioning
Document API changes, breaking changes, migration guides, and version history for APIs. Use when documenting API versioning, breaking changes, or creating API migration guides.
development154
api-pagination
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.
development154
api-response-optimization
Optimize API response times through caching, compression, and efficient payloads. Improve backend performance and reduce network traffic.
development154
api-security-hardening
Secure REST APIs with authentication, rate limiting, CORS, input validation, and security middleware. Use when building or hardening API endpoints against common attacks.
development154
api-versioning-strategy
Implement API versioning strategies including URL versioning, header versioning, backward compatibility, deprecation strategies, and migration guides. Use when dealing with API versions, deprecating endpoints, or managing breaking changes.
development154
architecture-diagrams
Create system architecture diagrams using Mermaid, PlantUML, C4 model, flowcharts, and sequence diagrams. Use when documenting architecture, system design, data flows, or technical workflows.
documentation154
artifact-management
Manage build artifacts, Docker images, and package registries. Configure artifact repositories, versioning, and distribution strategies.
development154
aws-cloudfront-cdn
Distribute content globally using CloudFront with caching, security headers, WAF integration, and origin configuration. Use for low-latency content delivery.
testing154
aws-lambda-functions
Create and deploy serverless functions using AWS Lambda with event sources, permissions, layers, and environment configuration. Use for event-driven computing without managing servers.
devops154
aws-s3-management
Manage S3 buckets with versioning, encryption, access control, lifecycle policies, and replication. Use for object storage, static sites, and data lakes.
testing154
azure-app-service
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.
development154
azure-functions
Create serverless functions on Azure with triggers, bindings, authentication, and monitoring. Use for event-driven computing without managing infrastructure.
devops154
react-component-architecture
Design scalable React components using functional components, hooks, composition patterns, and TypeScript. Use when building reusable component libraries and maintainable UI systems.
development154
bundle-size-optimization
Reduce JavaScript and CSS bundle sizes through code splitting, tree shaking, and optimization techniques. Improve load times and overall application performance.
development154
business-case-development
Build compelling business cases to justify investments and secure funding. Quantify benefits, assess costs, manage risks, and present compelling ROI arguments to leadership.
development154
canary-deployment
Implement canary deployment strategies to gradually roll out new versions to subset of users with automatic rollback based on metrics.
devops154
rate-limiting-implementation
Implement rate limiting, throttling, API quotas, and backpressure mechanisms to protect services from abuse and ensure fair resource usage. Use when building APIs, preventing DOS attacks, or managing system load.
development154
risk-assessment
Identify, analyze, and prioritize project risks using qualitative and quantitative methods. Develop mitigation strategies to minimize impact and maximize project success probability.
development154
capacity-planning
Analyze team capacity, plan resource allocation, and balance workload across projects. Forecast staffing needs and optimize team utilization while maintaining sustainable pace.
testing154
changelog-maintenance
Maintain comprehensive changelogs and release notes following Keep a Changelog format. Use when documenting version history, release notes, or tracking changes across versions.
development154
cloud-cost-management
Optimize and manage cloud costs across AWS, Azure, and GCP using reserved instances, spot pricing, and cost monitoring tools.
tools154
code-documentation
Write comprehensive code documentation including JSDoc, Python docstrings, inline comments, function documentation, and API comments. Use when documenting code, writing docstrings, or creating inline documentation.
development154
code-metrics-analysis
Analyze code complexity, cyclomatic complexity, maintainability index, and code churn using metrics tools. Use when assessing code quality, identifying refactoring candidates, or monitoring technical debt.
tools154
code-review-analysis
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.
development154
health-check-endpoints
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.
testing154
competitor-analysis
Analyze competitive landscape to identify strengths, weaknesses, opportunities, and threats. Inform product strategy and positioning based on market insights.
research154
concurrency-patterns
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.
development154
container-registry-management
Manage container registries (Docker Hub, ECR, GCR) with image scanning, retention policies, and access control.
testing154
continuous-testing
Integrate automated testing into CI/CD pipelines for continuous quality feedback. Use for continuous testing, CI testing, automated testing pipelines, test orchestration, and DevOps quality practices.
development154
correlation-tracing
Implement distributed tracing with correlation IDs, trace propagation, and span tracking across microservices. Use when debugging distributed systems, monitoring request flows, or implementing observability.
development154
cpu-profiling
Profile CPU usage to identify hot spots and bottlenecks. Optimize code paths consuming most CPU time for better performance and resource efficiency.
development154
cross-platform-compatibility
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.
development154
css-architecture
Organize CSS using BEM, SMACSS, and CSS-in-JS patterns. Use when building scalable, maintainable styling systems with proper naming conventions.
development154
database-backup-restore
Implement backup and restore strategies for disaster recovery. Use when creating backup plans, testing restore procedures, or setting up automated backups.
testing154
database-migration-management
Manage database migrations and schema versioning. Use when planning migrations, version control, rollback strategies, or data transformations in PostgreSQL and MySQL.
development154
database-monitoring
Monitor database performance and health. Use when setting up monitoring, analyzing metrics, or troubleshooting database issues.
data-ai154
database-schema-design
Design database schemas with normalization, relationships, and constraints. Use when creating new database schemas, designing tables, or planning data models for PostgreSQL and MySQL.
data-ai154
database-schema-documentation
Document database schemas, ERD diagrams, table relationships, indexes, and constraints. Use when documenting database schema, creating ERD diagrams, or writing table documentation.
documentation154
data-encryption
Implement strong encryption using AES, RSA, TLS, and proper key management. Use when securing data at rest, in transit, or implementing end-to-end encryption.
data-ai154
data-migration-scripts
Create safe, reversible database migration scripts with rollback capabilities, data validation, and zero-downtime deployments. Use when changing database schemas, migrating data between systems, or performing large-scale data transformations.
development154
Data Visualization
Create effective visualizations using matplotlib and seaborn for exploratory analysis, presenting insights, and communicating findings with business stakeholders
data-ai154
dependency-management
Manage project dependencies across languages including npm install, package versioning, dependency conflicts, security scanning, and lock files. Use when dealing with dependencies, version pinning, semantic versioning, or resolving conflicts.
testing154
design-handoff
Prepare designs for development handoff. Document specifications, interactions, and assets to enable efficient development and maintain design quality.
development154
design-patterns-implementation
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.
development154
developer-onboarding
Create comprehensive developer onboarding documentation including setup guides, README files, contributing guidelines, and getting started tutorials. Use when onboarding new developers or creating setup documentation.
development154
disaster-recovery-testing
Execute comprehensive disaster recovery tests, validate recovery procedures, and document lessons learned from DR exercises.
testing154
distributed-tracing
Implement distributed tracing with Jaeger and Zipkin for tracking requests across microservices. Use when debugging distributed systems, tracking request flows, or analyzing service performance.
development154
django-application
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.
development154
dns-management
Manage DNS records, routing policies, and failover configurations for high availability and disaster recovery.
testing154
documentation-site-setup
Set up documentation websites using Docusaurus, MkDocs, VitePress, GitBook, or static site generators. Use when creating docs sites, setting up documentation portals, or building static documentation.
development154
error-tracking
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.
tools154
Exploratory Data Analysis
Discover patterns, distributions, and relationships in data through visualization, summary statistics, and hypothesis generation for exploratory data analysis, data profiling, and initial insights
data-ai154
flask-api-development
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.
development154
form-validation
Implement form validation using React Hook Form, Formik, Vee-Validate, and custom validators. Use when building robust form handling with real-time validation.
development154
frontend-routing
Implement client-side routing using React Router, Vue Router, and Angular Router. Use when building multi-page applications with navigation and route protection.
tools154
frontend-state-management
Manage application state using Redux, MobX, Zustand, and Context API. Use when centralizing state for complex applications with multiple components.
development154
gap-analysis
Identify differences between current state and desired future state. Analyze gaps in capabilities, processes, skills, and technology to plan improvements and investments.
research154
gcp-cloud-run
Deploy containerized applications on Google Cloud Run with automatic scaling, traffic management, and service mesh integration. Use for container-based serverless computing.
development154
git-workflow-strategy
Master Git workflows including GitFlow, GitHub Flow, Trunk-Based Development. Configure branches, merge strategies, and collaboration patterns for team environments.
development154
graceful-shutdown
Implement graceful shutdown procedures to handle SIGTERM signals, drain connections, complete in-flight requests, and clean up resources properly. Use when deploying containerized applications, handling server restarts, or ensuring zero-downtime deployments.
devops154
graphql-implementation
Design and implement GraphQL APIs with schema design, resolvers, queries, mutations, subscriptions, and best practices. Use when building GraphQL servers, designing schemas, or migrating from REST to GraphQL.
development154
grpc-service-development
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.
development154
image-optimization
Optimize images for web to reduce file size without sacrificing quality. Use compression, modern formats, and responsive techniques for faster loading.
development154
information-architecture
Organize and structure information for clarity and discoverability. Design navigation systems, hierarchies, and mental models that match user needs.
development154
infrastructure-cost-optimization
Optimize cloud infrastructure costs through resource rightsizing, reserved instances, spot instances, and waste reduction strategies.
devops154
interaction-design
Design meaningful interactions and microinteractions. Create delightful user experiences through thoughtful animation, feedback, and responsive interface design.
content-media154
intermittent-issue-debugging
Debug issues that occur sporadically and are hard to reproduce. Use monitoring and systematic investigation to identify root causes of flaky behavior.
development154
internationalization-i18n
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.
development154
ios-swift-development
Develop native iOS apps with Swift. Covers MVVM architecture, SwiftUI, URLSession for networking, Combine for reactive programming, and Core Data persistence.
development154
jenkins-pipeline
Build Jenkins declarative and scripted pipelines with stages, agents, parameters, and plugins. Implement multi-branch pipelines and deployment automation.
tools154
log-aggregation
Implement centralized logging with ELK Stack, Loki, or Splunk for log collection, parsing, storage, and analysis across infrastructure.
devops154
markdown-documentation
Master markdown formatting, GitHub Flavored Markdown, README files, and documentation formatting. Use when writing markdown docs, READMEs, or formatting documentation.
development154
memory-leak-detection
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.
tools154
ML Model Explanation
Interpret machine learning models using SHAP, LIME, feature importance, partial dependence, and attention visualization for explainability
data-ai154
ML Model Training
Build and train machine learning models using scikit-learn, PyTorch, and TensorFlow for classification, regression, and clustering tasks
development154
mobile-app-debugging
Debug issues specific to mobile applications including platform-specific problems, device constraints, and connectivity issues.
development154
mobile-app-testing
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.
tools154
Model Deployment
Deploy machine learning models to production using Flask, FastAPI, Docker, cloud platforms (AWS, GCP, Azure), and model serving frameworks
development154
Model Monitoring
Monitor model performance, detect data drift, concept drift, and anomalies in production using Prometheus, Grafana, and MLflow
data-ai154
multi-cloud-strategy
Design and implement multi-cloud strategies spanning AWS, Azure, and GCP with vendor lock-in avoidance, hybrid deployments, and federation.
devops154
mutation-testing
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.
development154
network-security-groups
Configure network security groups and firewall rules to control inbound/outbound traffic and implement network segmentation.
testing154
nginx-configuration
Configure Nginx web server for high-performance reverse proxy, load balancing, SSL/TLS, caching, and API gateway functionality.
development154
performance-regression-debugging
Identify and debug performance regressions from code changes. Use comparison and profiling to locate what degraded performance and restore baseline metrics.
development154
nosql-database-design
Design NoSQL database schemas for MongoDB and DynamoDB. Use when modeling document structures, designing collections, or planning NoSQL data architectures.
development154
oauth-implementation
Implement secure OAuth 2.0, OpenID Connect (OIDC), JWT authentication, and SSO integration. Use when building secure authentication systems for web and mobile applications.
development154
penetration-testing
Ethical hacking and security testing methodologies using penetration testing tools, exploit frameworks, and manual security validation. Use when assessing application security posture and identifying exploitable vulnerabilities.
tools154
polyglot-integration
Integrate multiple programming languages using FFI, native bindings, gRPC, or language bridges. Use when combining strengths of different languages or integrating legacy systems.
tools154
profiling-optimization
Profile application performance, identify bottlenecks, and optimize hot paths using CPU profiling, flame graphs, and benchmarking. Use when investigating performance issues or optimizing critical code paths.
development154
progressive-web-app
Build progressive web apps using service workers, web manifest, offline support, and installability. Use when creating app-like web experiences.
development154
property-based-testing
Design property-based tests that verify code properties hold for all inputs using automatic test case generation. Use for property-based, QuickCheck, hypothesis testing, generative testing, and invariant verification.
development154
push-notification-setup
Implement push notifications for iOS and Android. Covers Firebase Cloud Messaging, Apple Push Notification service, handling notifications, and backend integration.
development154
reactive-programming
Implement reactive programming patterns using RxJS, streams, observables, and backpressure handling. Use when building event-driven UIs, handling async data streams, or managing complex data flows.
development154
react-native-app
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.
development154
real-time-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.
development154
Recommendation Engine
Build recommendation systems using collaborative filtering, content-based filtering, matrix factorization, and neural network approaches
development154
refactor-legacy-code
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.
development154
release-planning
Plan, coordinate, and execute software releases across environments. Manage versioning, rollout strategies, rollback procedures, and stakeholder communication for smooth deployments.
devops154
rest-api-design
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.
development154
retrospective-facilitation
Facilitate effective retrospectives to capture lessons learned, celebrate successes, and identify actionable improvements for future iterations.
testing154
root-cause-analysis
Conduct systematic root cause analysis to identify underlying problems. Use structured methodologies to prevent recurring issues and drive improvements.
research154
ruby-rails-application
Develop Ruby on Rails applications with models, controllers, views, Active Record ORM, authentication, and RESTful routes. Use when building Rails applications, managing database relationships, and implementing MVC architecture.
development154
runbook-creation
Create operational runbooks, playbooks, standard operating procedures (SOPs), and incident response guides. Use when documenting operational procedures, on-call guides, or incident response processes.
testing154
secrets-management
Implement secrets management with HashiCorp Vault, AWS Secrets Manager, or Kubernetes Secrets for secure credential storage and rotation.
devops154
security-audit-logging
Implement comprehensive security audit logging for compliance, forensics, and SIEM integration. Use when building audit trails, compliance logging, or security monitoring systems.
development154
security-documentation
Create security policies, guidelines, compliance documentation, and security best practices. Use when documenting security policies, compliance requirements, or security guidelines.
testing154
security-headers-configuration
Configure HTTP security headers including CSP, HSTS, X-Frame-Options, and XSS protection. Use when hardening web applications against common attacks.
development154
security-testing
Identify security vulnerabilities through SAST, DAST, penetration testing, and dependency scanning. Use for security test, vulnerability scanning, OWASP, SQL injection, XSS, CSRF, and penetration testing.
testing154
serverless-architecture
Design and implement serverless applications using AWS Lambda, Azure Functions, and GCP Cloud Functions with event-driven patterns and orchestration.
devops154
service-mesh-implementation
Implement service mesh (Istio, Linkerd) for service-to-service communication, traffic management, security, and observability.
testing154
session-management
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.
development154
sql-query-optimization
Analyze and optimize SQL queries for performance. Use when improving slow queries, reducing execution time, or analyzing query performance in PostgreSQL and MySQL.
testing154
stored-procedures
Implement stored procedures and functions for database logic. Use when creating reusable database routines, complex queries, or server-side calculations.
data-ai154
synthetic-monitoring
Implement synthetic monitoring and automated testing to simulate user behavior and detect issues before users. Use when creating end-to-end test scenarios, monitoring API flows, or validating user workflows.
development154
technical-roadmap-planning
Create comprehensive technical roadmaps aligned with business goals. Plan technology investments, architecture evolution, and infrastructure improvements over quarters and years.
development154
Time Series Analysis
Analyze temporal data patterns including trends, seasonality, autocorrelation, and forecasting for time series decomposition, trend analysis, and forecasting models
data-ai154
unit-testing-framework
Write comprehensive unit tests with high coverage using testing frameworks like Jest, pytest, JUnit, or RSpec. Use when writing tests for functions, classes, components, or establishing testing standards.
development154
uptime-monitoring
Implement uptime monitoring and status page systems for tracking service availability. Use when monitoring application uptime, creating status pages, or implementing health checks.
testing154
user-guide-creation
Create comprehensive user guides, tutorials, how-to documentation, and step-by-step instructions with screenshots and examples. Use when writing user documentation, tutorials, or getting started guides.
documentation154
visual-regression-testing
Detect unintended visual changes in UI by comparing screenshots across versions. Use for visual regression, screenshot diff, Percy, Chromatic, UI testing, and visual validation.
testing154
vulnerability-scanning
Automated vulnerability detection using OWASP tools, CVE databases, and security scanners. Use when performing security audits, compliance checks, or continuous security monitoring.
tools154
web-performance-optimization
Optimize web application performance using code splitting, lazy loading, caching, compression, and monitoring. Use when improving Core Web Vitals and user experience.
development154
wireframe-prototyping
Create wireframes and interactive prototypes to visualize user interfaces and gather feedback early. Use tools and techniques to communicate design ideas before development.
tools154
xss-prevention
Prevent Cross-Site Scripting (XSS) attacks through input sanitization, output encoding, and Content Security Policy. Use when handling user-generated content in web applications.
development154
zero-trust-architecture
Implement Zero Trust security model with identity verification, microsegmentation, least privilege access, and continuous monitoring. Use when building secure cloud-native applications.
development154
batch-processing-jobs
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.
data-ai154
e2e-testing-automation
Build end-to-end automated tests that simulate real user interactions across the full application stack. Use for E2E test, Selenium, Cypress, Playwright, browser automation, and user journey testing.
tools154
email-service-integration
Integrate email services with backends using SMTP, third-party providers, templates, and asynchronous sending. Use when implementing email functionality, sending transactional emails, and managing email workflows.
development154
payment-gateway-integration
Integrate payment gateways like Stripe, PayPal, and Square with backends for payment processing, subscription management, and webhook handling. Use when building e-commerce platforms, implementing billing systems, and handling payments securely.
development154
server-side-rendering
Implement server-side rendering with template engines, view layers, and dynamic content generation. Use when building server-rendered applications, implementing MVC architectures, and generating HTML on the server.
development154
spring-boot-application
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.
development154
websocket-implementation
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.
development154
database-performance-debugging
Debug database performance issues through query analysis, index optimization, and execution plan review. Identify and fix slow queries.
development154
accessibility-testing
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.
development154
api-gateway-configuration
Configure API gateways for routing, authentication, rate limiting, and request/response transformation. Use when deploying microservices, setting up reverse proxies, or managing API traffic.
development154
Statistical Hypothesis Testing
Conduct statistical tests including t-tests, chi-square, ANOVA, and p-value analysis for statistical significance, hypothesis validation, and A/B testing
testing154
technical-debt-assessment
Assess, quantify, and prioritize technical debt using code analysis, metrics, and impact analysis. Use when planning refactoring, evaluating codebases, or making architectural decisions.
development154
technical-specification
Create detailed technical specifications, requirements documents, design documents, and system architecture specs. Use when writing technical specs, requirements docs, or design documents.
testing154
webhook-integration
Implement secure webhook systems for event-driven integrations, including signature verification, retry logic, and delivery guarantees. Use when building third-party integrations, event notifications, or real-time data synchronization.
development154
angular-module-design
Design Angular modules using feature modules, lazy loading, and dependency injection. Use when organizing large Angular applications with proper separation of concerns.
content-media154
api-contract-testing
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.
development154
api-rate-limiting
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.
development154
application-logging
Implement structured logging across applications with log aggregation and centralized analysis. Use when setting up application logging, implementing ELK stack, or analyzing application behavior.
research154
autoscaling-configuration
Configure autoscaling for Kubernetes, VMs, and serverless workloads based on metrics, schedules, and custom indicators.
devops154
aws-rds-database
Deploy and manage relational databases using RDS with Multi-AZ, read replicas, backups, and encryption. Use for PostgreSQL, MySQL, MariaDB, and Oracle.
devops154
backup-disaster-recovery
Implement backup strategies, disaster recovery plans, and data restoration procedures for protecting critical infrastructure and data.
devops154
browser-debugging
Debug client-side issues using browser developer tools. Identify JavaScript errors, styling issues, and performance problems in the browser.
tools154
Causal Inference
Determine cause-and-effect relationships using propensity scoring, instrumental variables, and causal graphs for policy evaluation and treatment effects
tools154
circuit-breaker-pattern
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.
testing154
cloud-migration-planning
Plan and execute cloud migrations with assessment, database migration, application refactoring, and cutover strategies across AWS, Azure, and GCP.
development154
cloud-storage-optimization
Optimize cloud storage across AWS S3, Azure Blob, and GCP Cloud Storage with compression, partitioning, lifecycle policies, and cost management.
testing154
Clustering Analysis
Identify groups and patterns in data using k-means, hierarchical clustering, and DBSCAN for cluster discovery, customer segmentation, and unsupervised learning
data-ai154
code-generation-template
Generate code from templates and patterns including scaffolding, boilerplate generation, AST-based code generation, and template engines. Use when generating code, scaffolding projects, creating boilerplate, or using templates.
development154
color-accessibility
Design color palettes that are accessible to all users including those with color blindness. Ensure sufficient contrast, meaningful use of color, and inclusive design.
testing154
configuration-management
Manage application configuration including environment variables, settings management, configuration hierarchies, secret management, feature flags, and 12-factor app principles. Use for config, environment setup, or settings management.
testing154
csrf-protection
Implement Cross-Site Request Forgery (CSRF) protection using tokens, SameSite cookies, and origin validation. Use when building forms and state-changing operations.
development154
Data Cleaning Pipeline
Build robust processes for data cleaning, missing value imputation, outlier handling, and data transformation for data preprocessing, data quality, and data pipeline automation
tools154
dependency-tracking
Map, track, and manage project dependencies across teams, systems, and organizations. Identify critical path items and prevent blocking issues through proactive dependency management.
testing154
event-sourcing
Implement event sourcing and CQRS patterns using event stores, aggregates, and projections. Use when building audit trails, temporal queries, or systems requiring full history.
development154
feature-flag-system
Implement feature flags (toggles) for controlled feature rollouts, A/B testing, canary deployments, and kill switches. Use when deploying new features gradually, testing in production, or managing feature lifecycles.
testing154
file-upload-handling
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.
development154
frontend-accessibility
Implement WCAG compliance using semantic HTML, ARIA, keyboard navigation, and screen reader support. Use when building inclusive applications for all users.
development154
frontend-testing
Implement comprehensive frontend testing using Jest, Vitest, React Testing Library, and Cypress. Use when building robust test suites for UI and integration tests.
development154
git-hooks-setup
Implement Git hooks using Husky, pre-commit, and custom scripts. Enforce code quality, linting, and testing before commits and pushes.
development154
gitlab-cicd-pipeline
Design and implement GitLab CI/CD pipelines with stages, jobs, artifacts, and caching. Configure runners, Docker integration, and deployment strategies.
testing154
grafana-dashboard
Create professional Grafana dashboards with visualizations, templating, and alerts. Use when building monitoring dashboards, creating data visualizations, or setting up operational insights.
development154
kpi-dashboard-design
Design and build dashboards that track key performance indicators. Select relevant metrics, visualize data effectively, and communicate insights to stakeholders.
development154
kubernetes-deployment
Deploy, manage, and scale containerized applications on Kubernetes clusters with best practices for production workloads, resource management, and rolling updates.
devops154
log-analysis
Analyze application and system logs to identify errors, patterns, and root causes. Use log aggregation tools and structured logging for effective debugging.
tools154
logging-best-practices
Implement structured logging with JSON formats, log levels (DEBUG, INFO, WARN, ERROR), contextual logging, PII handling, and centralized logging. Use for logging, observability, log levels, structured logs, or debugging.
development154
microservices-architecture
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.
development154
ML Pipeline Automation
Build end-to-end ML pipelines with automated data processing, training, validation, and deployment using Airflow, Kubeflow, and Jenkins
tools154
mobile-offline-support
Implement offline-first mobile apps with local storage, sync strategies, and conflict resolution. Covers AsyncStorage, Realm, SQLite, and background sync patterns.
data-ai154
Model Hyperparameter Tuning
Optimize hyperparameters using grid search, random search, Bayesian optimization, and automated ML frameworks like Optuna and Hyperopt
development154
monorepo-management
Manage monorepo architectures using Lerna, Turborepo, and Nx. Configure workspaces, dependency versioning, and cross-package testing.
testing154
Natural Language Processing
Build NLP applications using transformers library, BERT, GPT, text classification, named entity recognition, and sentiment analysis
development154
Neural Network Design
Design and architect neural networks with various architectures including CNNs, RNNs, Transformers, and attention mechanisms using PyTorch and TensorFlow
content-media154
project-estimation
Estimate project scope, timeline, and resource requirements using multiple estimation techniques including bottom-up, top-down, and analogous estimation methods for accurate project planning.
development154
query-caching-strategies
Implement query caching strategies to improve performance. Use when setting up caching layers, configuring Redis, or optimizing database query response times.
data-ai154
responsive-web-design
Create responsive layouts using CSS Grid, Flexbox, media queries, and mobile-first design. Use when building adaptive interfaces that work across all devices.
development154
ssl-certificate-management
Manage SSL/TLS certificates with automated provisioning, renewal, and monitoring using Let's Encrypt, ACM, or Vault.
tools154
stakeholder-communication
Manage stakeholder expectations and engagement through targeted communication, regular updates, and relationship building. Tailor messaging for different stakeholder groups and priorities.
development154
static-code-analysis
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.
development154
test-automation-framework
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.
tools154
third-party-integration
Integrate external APIs and services with error handling, retry logic, and data transformation. Use when connecting to payment processors, messaging services, analytics platforms, or other third-party providers.
development154
vue-application-structure
Structure Vue 3 applications using Composition API, component organization, and TypeScript. Use when building scalable Vue applications with proper separation of concerns.
development154
web-performance-audit
Conduct comprehensive web performance audits. Measure page speed, identify bottlenecks, and recommend optimizations to improve user experience and SEO.
development154
secrets-rotation
Implement automated secrets rotation for API keys, credentials, certificates, and encryption keys. Use when managing secrets lifecycle, compliance requirements, or security hardening.
development154
accessibility-compliance
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.
development154
alert-management
Implement comprehensive alert management with PagerDuty, escalation policies, and incident coordination. Use when setting up alerting systems, managing on-call schedules, or coordinating incident response.
testing154
Anomaly Detection
Identify unusual patterns, outliers, and anomalies in data using statistical methods, isolation forests, and autoencoders for fraud detection and quality monitoring
development154
api-error-handling
Implement comprehensive API error handling with standardized error responses, logging, monitoring, retry logic, and validation patterns. Use when building resilient APIs, debugging issues, improving error reporting, implementing retry logic, handling HTTP error codes, managing API timeouts, designing error response handling, or adding circuit breaker patterns.
development154
api-reference-documentation
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.
development154
app-store-deployment
Deploy iOS and Android apps to App Store and Google Play. Covers signing, versioning, build configuration, submission process, and release management.
development154
aws-ec2-setup
Launch and configure EC2 instances with security groups, IAM roles, key pairs, AMIs, and auto-scaling. Use for virtual servers and managed infrastructure.
testing154
background-job-processing
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.
data-ai154
blue-green-deployment
Implement blue-green deployment strategies for zero-downtime releases with instant rollback capability and traffic switching between environments.
devops154
caching-strategy
Implement efficient caching strategies using Redis, Memcached, CDN, and cache invalidation patterns. Use when optimizing application performance, reducing database load, or improving response times.
testing154
cicd-pipeline-setup
Design and implement CI/CD pipelines with GitHub Actions, GitLab CI, Jenkins, or CircleCI. Use for automated testing, building, and deployment workflows.
development154
Classification Modeling
Build binary and multiclass classification models using logistic regression, decision trees, and ensemble methods for categorical prediction and classification
development154
cloud-security-configuration
Implement comprehensive cloud security across AWS, Azure, and GCP with IAM, encryption, network security, compliance, and threat detection.
testing154
Cohort Analysis
Track and analyze user cohorts over time, calculate retention rates, and identify behavioral patterns for customer lifecycle and retention analysis
research154
Computer Vision
Implement computer vision tasks including image classification, object detection, segmentation, and pose estimation using PyTorch and TensorFlow
content-media154
container-debugging
Debug Docker containers and containerized applications. Diagnose deployment issues, container lifecycle problems, and resource constraints.
development154
Correlation Analysis
Measure relationships between variables using correlation coefficients, correlation matrices, and association tests for correlation measurement, relationship analysis, and multicollinearity detection
testing154
data-replication-setup
Set up database replication for high availability and disaster recovery. Use when configuring master-slave replication, multi-master setups, or replication monitoring.
data-ai154
database-indexing-strategy
Design and implement database indexing strategies. Use when creating indexes, choosing index types, or optimizing index performance in PostgreSQL and MySQL.
data-ai154
database-query-optimization
Improve database query performance through indexing, query optimization, and execution plan analysis. Reduce response times and database load.
data-ai154
database-sharding
Implement database sharding for horizontal scalability. Use when scaling large databases, distributing data across multiple servers, or designing sharded architectures.
data-ai154
deployment-automation
Automate deployments across environments using Helm, Terraform, and ArgoCD. Implement blue-green deployments, canary releases, and rollback strategies.
tools154
deployment-documentation
Document deployment processes, infrastructure setup, CI/CD pipelines, and configuration management. Use when creating deployment guides, infrastructure docs, or CI/CD documentation.
testing154
design-system-creation
Build comprehensive design systems with components, patterns, and guidelines. Enable consistent design, faster development, and better collaboration across teams.
development154
Dimensionality Reduction
Reduce feature dimensionality using PCA, t-SNE, and feature selection for feature reduction, visualization, and computational efficiency
testing154
docker-containerization
Create optimized Docker containers with multi-stage builds, security best practices, and minimal image sizes. Use when containerizing applications, creating Dockerfiles, optimizing container images, or setting up Docker Compose services.
development154
fastapi-development
Build high-performance FastAPI applications with async routes, validation, dependency injection, security, and automatic API documentation. Use when developing modern Python APIs with async support, automatic OpenAPI documentation, and high performance requirements.
development154
Feature Engineering
Create and transform features using encoding, scaling, polynomial features, and domain-specific transformations for improved model performance and interpretability
development154
flutter-development
Build beautiful cross-platform mobile apps with Flutter and Dart. Covers widgets, state management with Provider/BLoC, navigation, API integration, and material design.
development154
Funnel Analysis
Analyze user conversion funnels, identify drop-off points, and optimize conversion rates for conversion optimization and user flow analysis
research154
gcp-cloud-functions
Deploy serverless functions on Google Cloud Platform with triggers, IAM roles, environment variables, and monitoring. Use for event-driven computing on GCP.
development154
github-actions-workflow
Build comprehensive GitHub Actions workflows for CI/CD, testing, security, and deployment. Master workflows, jobs, steps, and conditional execution.
development154
idempotency-handling
Implement idempotency keys and handling to ensure operations can be safely retried without duplicate effects. Use when building payment systems, APIs with retries, or distributed transactions.
development154
infrastructure-monitoring
Set up comprehensive infrastructure monitoring with Prometheus, Grafana, and alerting systems for metrics, health checks, and performance tracking.
testing154
load-balancer-setup
Configure and deploy load balancers (HAProxy, AWS ELB/ALB/NLB) for distributing traffic, session management, and high availability.
devops154
memory-optimization
Profile and optimize application memory usage. Identify memory leaks, reduce memory footprint, and improve efficiency for better performance and reliability.
testing154
mocking-stubbing
Create and manage mocks, stubs, spies, and test doubles for isolating unit tests from external dependencies. Use for mock, stub, spy, test double, Mockito, Jest mocks, and dependency isolation.
testing154
user-research-analysis
Analyze user research data to uncover insights, identify patterns, and inform design decisions. Synthesize qualitative and quantitative research into actionable recommendations.
testing154
integration-testing
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.
development154
mobile-first-design
Design for mobile devices first, then scale up to larger screens. Create responsive interfaces that work seamlessly across all device sizes.
development154
incident-response-plan
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.
testing154
Survival Analysis
Analyze time-to-event data, calculate survival probabilities, and compare groups using Kaplan-Meier and Cox proportional hazards models
data-ai154
semantic-versioning
Implement semantic versioning (SemVer) with automated release management. Use conventional commits, semantic-release, and version bumping strategies.
tools154
access-control-rbac
Implement Role-Based Access Control (RBAC), permissions management, and authorization policies. Use when building secure access control systems with fine-grained permissions.
development154
prometheus-monitoring
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.
development154
ansible-automation
Infrastructure automation and configuration management using Ansible playbooks, roles, and inventory. Use for deploying applications, patching, and managing servers.
tools154
long-running
Orchestrates long-running, multi-iteration tasks with Fable-5-style checkpointing, resume packs, self-paced scheduling, and per-iteration enforcement gates. ALWAYS trigger on "long running task", "keep working", "work overnight", "autonomous loop", "checkpoint", "resume where we left off", "iterate until done", "multi-session task", "self-pacing", "background build". Use when a task spans multiple iterations, sessions, or context windows. Different from orchestrator which routes a single pass -- this skill manages state, pacing, and enforcement across iterations.
development8
orchestrator
Coordinates the 10X Unicorn agent team with cost-aware model tiering, MCP-aware routing, and workflow fan-out. ALWAYS trigger on "implement", "build", "create", "design system", "deploy", "learn new language", "refactor", "fix bug", "set up CI", "code review", "how long will this take", "estimate", "architecture", "add feature", "write code", "debug", "review PR", "set up pipeline", "migrate", "optimize". Use for any multi-step task, implementation request, architecture decision, or quality enforcement. Different from individual agent skills which handle execution -- this skill handles coordination, routing, model selection, and quality gates.
tools8
javascript
Guides JavaScript and TypeScript development with modern tooling and patterns. ALWAYS trigger on "typescript", "javascript", "tsconfig", "eslint", "prettier", "vitest", "jest", "react", "node.js", "express", "npm", "package.json", "type error", "ts error", "js project setup", "frontend testing", "react hooks", "discriminated union", "type guard". Use when configuring TS/JS tooling, writing tests, structuring React or Node apps, or debugging type issues. Different from testing skill which covers general strategy; this covers JS/TS-specific test patterns and framework configs.
tools7
estimation
Guides the user through risk-based task estimation using decomposition, three-point estimates, and PERT formula. ALWAYS trigger on "estimate", "how long will this take", "time to complete", "sizing", "scope this", "effort estimate", "how many hours", "story points", "project timeline", "when will this be done", "cost estimate", "level of effort". Use when sizing any work item, feature, or project.
documentation7
hvs-skill-buddy
HVS Skill Buddy is the meta-skill for the entire HVS skill ecosystem. It keeps skills current with the latest Anthropic patterns, audits the skill library for drift and inconsistency, and creates new skills that fit the HVS system standard. ALWAYS trigger when the user mentions "skill buddy", "audit my skills", "skill drift", "create a new skill", "build a skill", "update my skills", "skill system", "are my skills consistent", "hvs skill", "skill conflicts", "skill overlap", "new skill for", or any request to inspect, improve, create, or manage skills in the HVS library. Also trigger when someone asks Claude to "make a skill like my other ones" or "keep this consistent with my existing skills."
development7
code-reading
Strategic code comprehension protocol for navigating existing codebases. ALWAYS trigger on "understand this code", "how does this work", "refactor", "before changing", "legacy code", "code review", "what does this do", "explain this codebase", "walk me through", "unfamiliar code", "read through". Use when exploring unfamiliar code, preparing to modify legacy systems, debugging complex issues, or conducting code reviews. Different from pattern-transfer which maps known solutions across domains -- this skill builds accurate mental models of existing code.
development7
domain-devops
Guides the user through containerization, CI/CD pipelines, Kubernetes deployments, observability, and infrastructure management. ALWAYS trigger on "dockerize", "CI/CD", "kubernetes", "deploy", "monitoring", "logging", "metrics", "helm", "infrastructure", "observability", "rollback", "scaling", "pipeline", "container", "k8s", "GitOps", "Dockerfile", "health check", "troubleshoot deployment". Use when containerizing applications, building pipelines, deploying services, setting up monitoring, or debugging infrastructure issues. Different from the DevOps agent (agents/devops.md) which handles orchestration and runbook execution rather than pattern guidance.
development7
language-learning
Guides rapid acquisition of new programming languages, frameworks, and paradigms through a structured 5-phase protocol. ALWAYS trigger on "learn Rust", "learn Go", "new language", "pick up a language", "never used X before", "getting started with", "how does X work", "teach me Y", "unfamiliar technology", "language comparison", "evaluate language", "switch to X", "polyglot", "first time using". Use when encountering unfamiliar technology, evaluating language choices, or onboarding to a new stack. Delegates to Polyglot agent for execution.
development7
pattern-transfer
Recognizes problem classes and transfers proven solutions across domains. ALWAYS trigger on "I've seen this before", "this is like X but in Y", "there must be a pattern", "how do I do X in Y", "equivalent of", "similar to", "same concept", "translate this approach", "port this to", "cross-language", "idiomatic way". Use when encountering familiar problems in unfamiliar contexts or applying concepts across languages/frameworks. Different from code-reading which builds mental models of existing code -- this skill maps known solutions to new domains.
development7
python
Guides Python development with modern idioms, tooling, and project structure. ALWAYS trigger on "python project", "pyproject.toml", "ruff", "mypy", "pytest", "poetry", "python setup", "type hints", "pydantic", "dataclass", "async python", "asyncio", "python anti-pattern", "python best practices", "python tooling", "python lint". Use when setting up Python projects, configuring tooling, choosing data modeling approaches, or writing tests. Different from testing skill which covers general test strategy; this covers Python-specific pytest patterns and tooling configs.
tools7
testing
Guides the user through test-first development and test strategy decisions. ALWAYS trigger on "write tests", "TDD", "test coverage", "mock", "test fails", "flaky test", "how to test", "unit test", "integration test", "e2e test", "test structure", "what to test", "test organization", "coverage report", "testing strategy", "arrange act assert". Use when writing new tests, choosing test types, setting up mocking, debugging flaky tests, improving coverage, or designing testable code. Different from qa-security agent which focuses on code review and security audits rather than test authoring.
development7
technical-debt
Guides deliberate management of technical debt: recognition, tracking, prioritization, and paydown. ALWAYS trigger on "technical debt", "code shortcut", "pay down debt", "debt tracking", "just for now", "temporary hack", "hardcoded value", "copy-paste code", "missing tests", "TODO cleanup", "refactor plan", "debt priority", "interest cost", "boy scout rule", "code quality backlog". Use when taking a shortcut, discovering suboptimal code, planning debt paydown, or quantifying ongoing cost of compromises.
development7
security
Guides secure development using defense-in-depth and attacker's mindset. ALWAYS trigger on "security review", "vulnerability", "authentication", "authorization", "input validation", "XSS", "SQL injection", "CSRF", "secrets management", "OWASP", "threat model", "security scan", "path traversal", "mass assignment", "privilege escalation", "security headers", "bandit", "dependency audit", "hardening". Use when implementing auth, handling user input, storing secrets, reviewing code for vulnerabilities, or preparing for production deployment. Different from devops skill which covers infrastructure; this covers application-level security patterns.
development7
self-verification
Guides the user through systematic pre-commit quality verification. ALWAYS trigger on "review my code", "check my work", "before commit", "self-review", "quality check", "am I ready to commit", "pre-commit review", "code quality", "verify my changes", "sanity check", "review before merge", "is this ready". Use before any commit, merge, or code review submission.
development7
go
Guides Go development with idiomatic patterns, tooling, and project structure. ALWAYS trigger on "go project", "go module", "go mod", "goroutine", "channel", "go test", "go build", "golangci-lint", "go interface", "go error handling", "go concurrency", "go struct", "go anti-pattern", "go best practices", "go tooling", "go lint". Use when setting up Go projects, writing idiomatic Go, choosing concurrency patterns, or configuring tooling. Different from testing skill which covers general test strategy; this covers Go-specific testing patterns and tooling configs.
tools7