Testing Standards
Write tests following 3-layer pyramid (unit 95%, integration 85%, E2E critical paths) with 1:1 file mapping for unit tests. Covers test organization, coverage requirements, fixtures, and best practices. Use when writing tests, checking coverage, or validating test structure.
Vulnerability Triage & Prioritization
Assess vulnerability severity using CVSS scoring, classify vulnerability types (CVE vs compliance), detect false positives, and prioritize remediation workflows. Use when analyzing vulnerability data, calculating risk scores, or determining remediation priority.
Orchestration Workflow
Choose and execute orchestration commands (/solo for straightforward tasks, /spec for planning, /conduct for complex features with SPEC.md). Covers decision tree, sub-agents, validation standards, and best practices. Use when planning complex tasks or understanding orchestration patterns.
Agent Prompting & Delegation
Best practices for writing effective Task tool prompts that produce clear, structured outputs from sub-agents. Covers context engineering, instruction clarity, output format specification, and parallel delegation patterns. MUST BE USED PROACTIVELY when spawning sub-agents to ensure high-quality results.
python-packaging
Python package management with poetry, pip, and uv including dependency resolution, lock files, version pinning, security audits (pip-audit, safety), virtual environments, and dependency graphs. Use when managing dependencies, resolving version conflicts, setting up new projects, or investigating security vulnerabilities in packages.
MongoDB Aggregation Pipeline Optimization
General MongoDB aggregation pipeline optimization techniques including early filtering, index usage, array operators vs $unwind, $lookup optimization, and performance debugging. Use when writing aggregation queries for ANY MongoDB project, debugging slow pipelines, or analyzing query performance. For M32RIMM-specific patterns, use mongodb-m32rimm-patterns skill.
async-python
Python async/await patterns with asyncio, concurrent.futures, threading, and multiprocessing. Covers async context managers, timeouts, cancellation, common pitfalls (blocking in async, missing await, event loop issues), and choosing between async/threading/multiprocessing. Use when writing async code, debugging async issues, choosing concurrency approaches, or testing async functions.
database-design-patterns
Database schema design including normalization, denormalization, indexes, migrations, foreign keys, constraints, and query optimization. Covers PostgreSQL, MySQL, and general SQL patterns. Use when designing database schemas, optimizing queries, setting up migrations, or debugging performance issues.
AI Documentation Standards
Write AI-readable documentation following concise-over-comprehensive principle, hierarchical CLAUDE.md/AGENTS.md inheritance (100-200 line rule), structured formats (tables over prose), parallel validation, and session knowledge capture. Use when writing documentation, updating docs, or optimizing existing docs.
Code Refactoring Patterns
When and how to refactor complex functions including complexity thresholds (50+ statements, 12+ branches), extraction patterns, guard clauses, and testing strategies. Use when ruff/pylint complexity warnings appear or code becomes hard to maintain.
code-review-patterns
Code review best practices including review checklists (functionality, tests, documentation, security, performance), providing constructive feedback, automated checks integration, and handling review comments. Use when reviewing pull requests, providing code feedback, responding to review comments, or setting up review processes.
docker-optimization
Optimize Docker images for Python applications including multi-stage builds (70%+ size reduction), security scanning with Trivy, layer caching, and distroless base images. Use when creating Dockerfiles, reducing image size, improving build performance, or scanning for vulnerabilities.
api-design-patterns
REST API design patterns including versioning strategies (URL, header, content negotiation), pagination (offset, cursor, keyset), filtering and sorting, error response formats (RFC 7807), authentication (JWT, OAuth 2.0, API keys), rate limiting, and OpenAPI specification. Use when designing APIs, documenting endpoints, implementing authentication, standardizing error responses, or reviewing API implementations.
debugging-strategies
Systematic debugging including root-cause tracing (trace backward through call stack), reproduction strategies, pdb/debugpy usage, logging analysis, binary search debugging, and error pattern recognition. Use when debugging errors, tracing bugs through call stacks, investigating production issues, or reproducing intermittent bugs.
ci-cd-pipelines
GitLab CI/CD pipeline patterns including testing stages, Docker builds, caching strategies, secrets management, deployment patterns (blue-green, canary, rolling), and rollback procedures. Use when creating .gitlab-ci.yml, optimizing CI performance, setting up deployment pipelines, or troubleshooting CI failures.
pr-review-common-patterns
Common patterns in PR reviews including false positives, security vulnerabilities, N+1 queries, breaking changes, and edge cases. Use when analyzing code, verifying findings, or understanding typical issues.
Python Style Standards
Python coding standards including line length (80 chars), naming conventions (snake_case, PascalCase), type hints, docstrings, exception handling, and logging patterns. Use when writing new Python code or reviewing code quality.
mutation-testing
Validate test suite quality using mutation testing with mutmut or cosmic-ray to detect weak tests, calculate mutation scores, and improve test coverage. Use when validating test effectiveness, achieving high test quality, or detecting tests that pass but don't validate behavior.
pr-review-evidence-formats
Defines what counts as valid evidence in PR reviews including code snippets, execution traces, exploitation scenarios, and test results. Use when validating findings, writing review reports, or verifying claims.
frontend-patterns
Frontend development patterns for React, Vue, and TypeScript including component composition, state management (Redux, Zustand, Pinia), hooks patterns, performance optimization, testing with Jest/Vitest, and build tools (Vite, webpack). Use when building frontend applications, optimizing performance, managing state, or setting up testing.
MCP Integration
Set up and use MCP (Model Context Protocol) servers to extend Claude Code capabilities including PRISM semantic memory, filesystem access, and database integration. Use when setting up MCP servers, debugging MCP connections, or understanding MCP tool usage.
performance-profiling
Python performance profiling with cProfile, line_profiler, memory_profiler, and py-spy. Covers profiling workflows, interpreting results, finding bottlenecks, memory leak detection, and optimization strategies. Use when code is slow, debugging performance issues, optimizing for production, or investigating memory usage.
python-linting
Python linting and type checking using ruff (formatting + linting) and pyright (type checking). Covers common errors, configuration, fixing violations, and when to use noqa. Use when fixing linting errors, configuring ruff/pyright, or understanding Python code quality tools.
git-workflows
Advanced Git workflows including interactive rebase, bisect, worktrees, branch strategies, conflict resolution, cherry-picking, and submodules. Use when doing complex git operations, cleaning up commit history, managing multiple branches, investigating bugs with git bisect, or working on parallel features with worktrees.
pr-review-standards
Code quality standards for PR review agents including try/except rules, logging patterns, type hints, and verification requirements. Use when reviewing code, spawning PR review agents, or validating code quality.
kubernetes-patterns
Kubernetes deployment patterns including Deployments, Services, Ingress, ConfigMaps, Secrets, resource management, health checks, and horizontal pod autoscaling. Covers kubectl commands, YAML manifests, and GitOps workflows. Use when deploying to Kubernetes, managing containers, setting up services, or troubleshooting pod issues.
test-driven-development
Test-Driven Development workflows including red-green-refactor cycle, test-first implementation, outside-in vs inside-out testing, TDD for debugging, and TDD for refactoring. Use when implementing new features, refactoring existing code, using tests to drive design, or debugging with failing tests.
test-plan-formatting
Format concise, actionable test plans for Jira tickets using existing fptest tools and minimal MongoDB operations
sqlite-best-practices
SQLite best practices including WAL checkpoint timing for multiprocessing, stateful batch connections for atomicity, and performance configuration. Use when working with SQLite in Python projects requiring concurrent access, multi-table atomicity, or multiprocessing.
skill-authoring
Best practices for creating and updating Claude Code skills including YAML frontmatter structure, description patterns for discoverability, content organization, progressive disclosure, and testing strategies. Use when creating new skills or updating existing skills to follow proven patterns.