# Engineering Skills

**Total Skills:** 266

## Risk Distribution

| Risk Level  | Count |
| ----------- | ----- |
| 🔴 Review   | 141   |
| 🟡 Elevated | 6     |
| 🔵 Standard | 3     |
| 🟢 Low      | 116   |

---

## Skills

| #   | Skill ID                                     | Risk        | Job to be Done                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| --- | -------------------------------------------- | ----------- |   |
| 1   | `elg_eql_scoring`                            | 🔴 Review   | Identifies and scores Ecosystem-Qualified Leads (EQLs) from partner and integration signals.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 2   | `elg_channel_enablement`                     | 🔴 Review   | Manages partner enablement programs including training, certification, content delivery, and readiness tracking.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 3   | `prodops_incident_analyzer`                  | 🔴 Review   | Analyzes production incidents to extract learnings, identify patterns, and drive reliability improvements.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 4   | `prodops_release_notes_generator`            | 🔴 Review   | Automatically generates user-friendly release notes from commits, PRs, and tickets with audience-appropriate messaging.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 5   | `prodops_competitive_feature_tracker`        | 🔴 Review   | Monitors competitor feature releases and market positioning to inform product strategy and differentiation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 6   | `devex_changelog_tracker`                    | 🔴 Review   | Tracks API changes and proactively notifies developers about updates relevant to their integrations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 7   | `devex_support_deflector`                    | 🟡 Elevated | Provides instant answers to common developer questions, reducing support ticket volume while improving developer satisfaction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 8   | `devex_oauth_helper`                         | 🔴 Review   | Guides developers through OAuth configuration with step-by-step setup, token management, and troubleshooting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 9   | `devex_code_sample_generator`                | 🔴 Review   | Generates working code samples for API endpoints in multiple languages with best practices and error handling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 10  | `devex_webhook_tester`                       | 🔴 Review   | Helps developers test, debug, and validate webhook integrations with payload inspection and delivery verification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 11  | `devex_migration_assistant`                  | 🔴 Review   | Guides developers through API version migrations with automated code analysis and transformation suggestions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 12  | `devex_error_explainer`                      | 🔴 Review   | Provides human-readable explanations for API errors with contextual troubleshooting steps and code fixes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 13  | `devex_api_onboarding`                       | 🔴 Review   | Creates personalized API getting-started guides based on developer's tech stack and use case for faster time-to-first-call.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 14  | `support_first_response`                     | 🔴 Review   | Generates personalized, context-aware first responses to support tickets using AI and knowledge base retrieval.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 15  | `support_ticket_triage`                      | 🔴 Review   | Auto-prioritizes and routes support tickets using AI classification based on urgency, customer tier, and issue complexity.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 16  | `support_bug_linker`                         | 🟡 Elevated | Automatically links support tickets to existing bug reports and creates new bug reports when patterns emerge.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 17  | `development/playwright`                     | 🔴 Review   | Complete browser automation with Playwright. Auto-detects dev servers, writes clean test scripts to /tmp. Test pages, fill forms, take screenshots, check responsive design, validate UX, test login flows, check links, automate any browser task. Use when user wants to test websites, automate browser interactions, validate web functionality, or perform any browser-based testing.                                                                                                                                                                                                                                                                                                |
| 18  | `development/code-review-checklist`          | 🔴 Review   | Systematic code review checklist covering correctness, security, performance, maintainability, and style. Use when reviewing PRs, doing code audits, or before merging changes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 19  | `development/d3js`                           | 🔴 Review   | Creating interactive data visualisations using d3.js. This skill should be used when creating custom charts, graphs, network diagrams, geographic visualisations, or any complex SVG-based data visualisation that requires fine-grained control over visual elements, transitions, or interactions. Use this for bespoke visualisations beyond standard charting libraries, whether in React, Vue, Svelte, vanilla JavaScript, or any other environment.                                                                                                                                                                                                                                 |
| 20  | `development/codebase-onboarding`            | 🔴 Review   | Systematic approach to understanding a new codebase. Use when joining a project, exploring unfamiliar code, or helping someone understand a repo structure.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 21  | `governance_context_sync`                    | 🔴 Review   | Checks if project context is stale (>24 hours) and transparently offers to sync governance patterns with user consent                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 22  | `compliance_access_reviewer`                 | 🔴 Review   | Orchestrates periodic user access reviews and certifications to ensure least-privilege access and compliance                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 23  | `vcf_stakeholder_mapping`                    | 🔴 Review   | Maps the buying chain using the Miller Heiman model to identify User Buyers, Technical Buyers, Champions, and Economic Buyers. Foundation for Value Creation Framework deals.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 24  | `people_onboarding_checklist`                | 🔴 Review   | Manages new hire onboarding with automated checklists, task assignments, and progress tracking to ensure a smooth first 90 days.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 25  | `anthropic_official/theme-factory`           | 🟢 Low      | Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 26  | `anthropic_official/doc-coauthoring`         | 🔴 Review   | Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.                                                                                                                                                                                                                                              |
| 27  | `anthropic_official/skill-creator`           | 🔴 Review   | Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 28  | `anthropic_official/pptx`                    | 🔴 Review   | "Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks"                                                                                                                                                                                                                                                                                                                                                                                                         |
| 29  | `anthropic_official/mcp-builder`             | 🔴 Review   | Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).                                                                                                                                                                                                                                                                                                                                                                                                     |
| 30  | `anthropic_official/web-artifacts-builder`   | 🔴 Review   | Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.                                                                                                                                                                                                                                                                                                                                                                                          |
| 31  | `community_hackathon_manager`                | 🔴 Review   | Plans, manages, and executes community hackathons including registration, team formation, judging, and prizes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 32  | `ai_response_suggester`                      | 🟡 Elevated | Suggests contextual responses for support agents and sales reps based on conversation context.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 33  | `ai_ops/prompt-engineering`                  | 🔴 Review   | Best practices for writing effective AI prompts. Use when crafting prompts for LLMs, creating system prompts, designing agent instructions, or optimizing AI outputs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 34  | `ai_translation_localizer`                   | 🟡 Elevated | Translates and localizes content while preserving context, tone, and cultural nuances.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 35  | `ai_knowledge_synthesizer`                   | 🔵 Standard | Synthesizes information from multiple knowledge sources to provide comprehensive, accurate answers.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 36  | `ai_ticket_classifier`                       | 🔴 Review   | Automatically classifies, prioritizes, and routes support tickets using AI analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 37  | `ai_data_quality_agent`                      | 🔴 Review   | Monitors, validates, and improves data quality across systems using AI-powered analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 38  | `revops_activity_capture`                    | 🔴 Review   | Automatically captures and enriches sales activities from email, calendar, and calls for complete deal visibility.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 39  | `superpowers/using-git-worktrees`            | 🔴 Review   | Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 40  | `superpowers/test-driven-development`        | 🔴 Review   | Use when implementing any feature or bugfix, before writing implementation code                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 41  | `superpowers/systematic-debugging`           | 🔴 Review   | Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 42  | `superpowers/dispatching-parallel-agents`    | 🔴 Review   | Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 43  | `superpowers/executing-plans`                | 🔴 Review   | Use when you have a written implementation plan to execute in a separate session with review checkpoints                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 44  | `superpowers/finishing-a-development-branch` | 🔴 Review   | Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 45  | `superpowers/writing-plans`                  | 🔴 Review   | Use when you have a spec or requirements for a multi-step task, before touching code                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 46  | `superpowers/requesting-code-review`         | 🔵 Standard | Use when completing tasks, implementing major features, or before merging to verify work meets requirements                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 47  | `superpowers/receiving-code-review`          | 🔴 Review   | Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 48  | `superpowers/writing-skills`                 | 🔴 Review   | Use when creating new skills, editing existing skills, or verifying skills work before deployment                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 49  | `superpowers/verification-before-completion` | 🔴 Review   | Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 50  | `plgf_activation_metrics`                    | 🔴 Review   | Setup/Aha/Habit moments framework (Shaun Clowes), aha moment identification, and time-to-value optimization                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 51  | `boyce_sidecar_product_builder`              | 🔴 Review   | Designs PLG-friendly sidecar products when the core product isn't PLG-ready. Based on Dave Boyce's FREEMIUM framework (Chapter 17): Create adjacent tools that become pipeline builders.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 52  | `cursor_rules/aws-dynamodb`                  | 🟢 Low      | Provides definitive best practices and actionable code examples for interacting with AWS DynamoDB using the AWS SDK v3, focusing on data modeling, performance, security, and common pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 53  | `cursor_rules/unreal-engine`                 | 🟢 Low      | Definitive guidelines for writing consistent, performant, and maintainable C++ and Blueprint code in Unreal Engine 5.x projects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 54  | `cursor_rules/selenium`                      | 🟢 Low      | Definitive guidelines for writing robust, maintainable, and readable Selenium automation scripts in Python, focusing on modern best practices for testing and web scraping.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 55  | `cursor_rules/keras`                         | 🟢 Low      | Definitive guidelines for writing robust, maintainable, and high-performance Keras 3 models, emphasizing the functional API, modern training patterns, and multi-backend compatibility.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 56  | `cursor_rules/springboot`                    | 🟢 Low      | Enforces modern Spring Boot best practices for Java applications, covering code structure, dependency injection, API design, error handling, and testing to ensure maintainable, performant, and secure microservices.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 57  | `cursor_rules/aiohttp`                       | 🟢 Low      | This guide defines definitive best practices for using aiohttp, focusing on efficient, robust, and maintainable asynchronous HTTP client code.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 58  | `cursor_rules/unity`                         | 🟢 Low      | This guide provides opinionated, actionable best practices for Unity C# development, focusing on code organization, performance, and common pitfalls to ensure a clean, maintainable, and performant codebase.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 59  | `cursor_rules/deno`                          | 🟢 Low      | This guide defines definitive Deno best practices for our team, focusing on secure, maintainable, and idiomatic code using Deno's built-in tooling and modern web standards.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 60  | `cursor_rules/ffmpeg`                        | 🟢 Low      | This guide defines best practices for integrating and utilizing FFmpeg within our applications, emphasizing API-first development, secure and reproducible builds, and optimal multimedia encoding techniques for quality and performance.                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 61  | `cursor_rules/codemirror`                    | 🟢 Low      | This guide defines best practices for building and maintaining CodeMirror 6-based editors, focusing on modularity, immutable state, extension-driven configuration, and modern JavaScript/TypeScript patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 62  | `cursor_rules/ros`                           | 🟢 Low      | Definitive guidelines for writing high-quality, performant, and maintainable ROS 2 code, leveraging modern C++ and Python best practices, `ament` tooling, and efficient architectural patterns like node composition and multithreaded executors.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 63  | `cursor_rules/flask-restful`                 | 🟢 Low      | This guide defines definitive best practices for building robust, maintainable, and modern REST APIs using Flask-RESTful, emphasizing Pydantic for validation and clear architectural patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 64  | `cursor_rules/pylint`                        | 🟢 Low      | Definitive guidelines for configuring and using pylint for deep semantic analysis and code quality in Python projects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 65  | `cursor_rules/docker`                        | 🟢 Low      | Definitive guidelines for writing efficient, secure, and maintainable Dockerfiles and Docker Compose configurations, ensuring fast builds and reliable deployments.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 66  | `cursor_rules/svelte`                        | 🟢 Low      | Definitive guide for writing clean, performant, and maintainable Svelte 5 applications using the runes API and modern TypeScript practices.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 67  | `cursor_rules/opencv-python`                 | 🟢 Low      | This guide provides definitive, opinionated best practices for writing high-performance, maintainable, and robust `opencv-python` code in Python applications.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 68  | `cursor_rules/streamlit`                     | 🟢 Low      | Enforce modern, performant, and maintainable Streamlit development practices, focusing on caching, modularity, and robust dependency management.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 69  | `cursor_rules/go`                            | 🟢 Low      | Definitive guidelines for writing clear, simple, performant, and maintainable Go code, adhering to Google's style and modern best practices.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 70  | `cursor_rules/aws-rds`                       | 🟢 Low      | Definitive guidelines for secure, performant, and maintainable database development and operations with AWS RDS, emphasizing modern best practices and common anti-patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 71  | `cursor_rules/vercel`                        | 🟢 Low      | This guide outlines definitive best practices for developing and deploying applications on Vercel, ensuring optimal performance, security, and cost-efficiency.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 72  | `cursor_rules/servemux`                      | 🟢 Low      | This rule file provides definitive guidelines for using Go's `http.ServeMux` effectively, leveraging Go 1.22+ features for robust, maintainable, and secure API development.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 73  | `cursor_rules/heroku`                        | 🟢 Low      | This guide outlines essential Heroku best practices, focusing on the Twelve-Factor App methodology, runtime principles, and modern cloud-native development patterns for building robust, scalable, and maintainable applications.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 74  | `cursor_rules/fabric-js`                     | 🟢 Low      | This guide outlines definitive best practices for using fabric-js (v6.9.0+) in JavaScript/TypeScript projects, focusing on performance, maintainability, and modern API usage.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 75  | `cursor_rules/three-js`                      | 🟢 Low      | Enforce modern, performant, and maintainable three-js development practices, focusing on WebGL error handling, efficient asset management, and render loop optimization.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 76  | `cursor_rules/notion-api`                    | 🟢 Low      | Definitive guidelines for building secure, typed, and maintainable integrations with the Notion API using modern best practices and official SDKs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 77  | `cursor_rules/pdoc`                          | 🟢 Low      | This guide provides definitive rules for writing Python docstrings and type hints to maximize clarity and utility with pdoc, ensuring accurate and maintainable API documentation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 78  | `cursor_rules/pytest`                        | 🟢 Low      | This guide defines our team's definitive best practices for writing fast, reliable, and maintainable tests using pytest, ensuring consistency and high code quality across projects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 79  | `cursor_rules/dask`                          | 🟢 Low      | This guide provides opinionated, actionable best practices for writing performant, maintainable, and idiomatic Dask code, focusing on real-world scenarios and modern patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 80  | `cursor_rules/puppeteer`                     | 🟢 Low      | This guide provides opinionated, actionable best practices for writing robust, performant, and maintainable Puppeteer scripts for web scraping, automation, and testing. It emphasizes modern patterns like `page.locator()` and efficient resource management.                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 81  | `cursor_rules/python`                        | 🟢 Low      | This guide defines the definitive Python best practices for our team, focusing on readability, maintainability, and modern development standards. Adhere to these rules for consistent, high-quality Python code.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 82  | `cursor_rules/flake8`                        | 🟢 Low      | This guide provides definitive, actionable best practices for configuring and using flake8 to enforce Python code quality, style, and catch common errors.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 83  | `cursor_rules/azure`                         | 🟢 Low      | Definitive guidelines for developing, deploying, and operating applications on Azure, focusing on Well-Architected Framework principles, secure coding, and efficient resource management.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 84  | `cursor_rules/insomnia`                      | 🟢 Low      | This guide provides opinionated, actionable best practices for using Insomnia IDE, focusing on modern API testing, collaboration, and CI/CD integration as of 2025.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 85  | `cursor_rules/tinygrad`                      | 🟢 Low      | This guide provides opinionated, actionable best practices for developing with tinygrad, focusing on lazy execution, performance, and code structure.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 86  | `cursor_rules/nose2`                         | 🟢 Low      | This rule file provides opinionated best practices for writing, organizing, and configuring tests using nose2, emphasizing modern Python development workflows and common pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 87  | `cursor_rules/trpc`                          | 🟢 Low      | Definitive guidelines for building robust, type-safe, and maintainable tRPC APIs, emphasizing modularity, Zod validation, and efficient error handling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 88  | `cursor_rules/nltk`                          | 🟢 Low      | This guide provides definitive, actionable best practices for writing maintainable, performant, and type-safe NLTK code in Python, emphasizing modern patterns and avoiding common pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 89  | `cursor_rules/vitest`                        | 🟢 Low      | This guide provides opinionated, actionable best practices for writing fast, reliable, and maintainable unit and integration tests using Vitest in modern JavaScript and TypeScript projects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 90  | `cursor_rules/xgboost`                       | 🟢 Low      | Definitive guidelines for writing robust, performant, and maintainable Python code using the xgboost library, focusing on modern best practices and common pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 91  | `cursor_rules/maven`                         | 🟢 Low      | This guide provides opinionated, actionable best practices for Maven projects, focusing on reproducible builds, efficient dependency management, and high code quality.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 92  | `cursor_rules/cuda`                          | 🟢 Low      | Definitive guidelines for writing high-performance, maintainable, and error-resistant CUDA C++ code, focusing on modern practices, memory management, kernel optimization, and robust error handling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 93  | `cursor_rules/kivy`                          | 🟢 Low      | Definitive guide for building modern, maintainable Kivy applications using best practices, focusing on KV language, KivyMD, and clear code organization.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 94  | `cursor_rules/tauri`                         | 🟢 Low      | This guide provides definitive, actionable best practices for writing robust, performant, and secure Rust backend code in Tauri applications, focusing on modern patterns and common pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 95  | `cursor_rules/vue`                           | 🟢 Low      | This guide provides definitive, opinionated best practices for writing clean, performant, and maintainable Vue 3 applications using modern patterns like the Composition API and Pinia.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 96  | `cursor_rules/digitalocean`                  | 🟢 Low      | Definitive guidelines for building, deploying, and managing cloud-native applications on DigitalOcean, focusing on secure, scalable, and cost-efficient practices.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 97  | `cursor_rules/rust`                          | 🟢 Low      | Definitive guidelines for writing idiomatic, performant, and maintainable Rust code, focusing on modern best practices for structure, patterns, and error handling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 98  | `cursor_rules/jquery`                        | 🟢 Low      | Definitive guidelines for writing performant, maintainable, and modern jQuery code, emphasizing best practices for DOM manipulation, event handling, and compatibility with jQuery 4.0 and ES6+.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 99  | `cursor_rules/shadcn`                        | 🔵 Standard | This guide defines definitive best practices for developing with shadcn/ui, ensuring consistent code organization, robust TypeScript, optimal performance, and accessible, maintainable components.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 100 | `cursor_rules/android-sdk`                   | 🟢 Low      | This guide provides definitive best practices for Android SDK development in Java, focusing on modern architecture, Jetpack libraries, performance, security, and testing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 101 | `cursor_rules/customtkinter`                 | 🟢 Low      | Definitive guidelines for writing clean, maintainable, and performant customtkinter applications. This rule file enforces best practices for code structure, theming, component architecture, and common pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 102 | `cursor_rules/llvm`                          | 🟢 Low      | This guide provides definitive, actionable best practices for developing with LLVM, focusing on code quality, performance, and robust testing using modern tools like LIT and TableGen.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 103 | `cursor_rules/railway`                       | 🟢 Low      | This guide provides definitive best practices for developing and deploying applications on Railway, focusing on stateless services, reproducible builds with Nixpacks, secure configuration, and optimal performance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 104 | `cursor_rules/postman`                       | 🟢 Low      | This guide defines definitive best practices for structuring, scripting, and testing APIs using Postman, ensuring maintainable, robust, and collaborative API workflows.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 105 | `cursor_rules/google-maps-js`                | 🟢 Low      | This guide provides definitive best practices for integrating and managing the Google Maps JavaScript API in modern web applications, focusing on security, performance, and maintainability.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 106 | `cursor_rules/angular`                       | 🟢 Low      | Provides definitive guidelines for modern Angular development (2025), focusing on best practices for code structure, component architecture, state management with signals, performance, and type safety.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 107 | `cursor_rules/vllm`                          | 🟢 Low      | Definitive guidelines for writing high-performance, maintainable, and production-ready LLM inference code using vLLM.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 108 | `cursor_rules/java`                          | 🟢 Low      | Definitive guidelines for writing high-quality, maintainable, and performant Java code, adhering to modern best practices (Java 21/25) and enterprise standards like Google Java Style.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 109 | `cursor_rules/c-sharp`                       | 🟢 Low      | This guide defines definitive C# coding standards and best practices for our team, covering naming, formatting, modern language features, performance, security, and error handling to ensure consistent, maintainable, and high-quality code.                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 110 | `cursor_rules/gcp`                           | 🟢 Low      | This guide provides definitive best practices for developing, deploying, and operating applications on Google Cloud Platform (GCP), emphasizing security, performance, and maintainability.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 111 | `cursor_rules/php`                           | 🟢 Low      | This guide provides definitive best practices for writing clean, secure, and maintainable PHP code, strictly adhering to PSR-12 and modern PHP 8.4+ features.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 112 | `cursor_rules/scrapy`                        | 🟢 Low      | This guide provides opinionated, actionable best practices for building robust, high-performance, and maintainable Scrapy web crawlers, emphasizing modern Python standards and ethical scraping.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 113 | `cursor_rules/numpy`                         | 🟢 Low      | This guide provides definitive, actionable best practices for writing high-performance, maintainable, and correct NumPy code, emphasizing vectorization, explicit dtypes, and modern GPU acceleration.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 114 | `cursor_rules/emacs`                         | 🟢 Low      | Definitive guidelines for writing clean, maintainable, and performant Emacs Lisp code and configurations, emphasizing modern best practices, robust organization, and effective tooling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 115 | `cursor_rules/bash`                          | 🟢 Low      | Enforces modern, robust, and maintainable bash scripting practices, focusing on error handling, quoting, variable management, and code organization.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 116 | `cursor_rules/solidity`                      | 🟢 Low      | Definitive guidelines for writing secure, maintainable, and gas-efficient Solidity smart contracts, emphasizing modern best practices and security-first development.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 117 | `cursor_rules/gensim`                        | 🟢 Low      | This guide outlines definitive best practices for using the gensim library, focusing on reproducibility, efficient corpus construction, robust model training, and maintainable code for NLP topic modeling tasks.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 118 | `cursor_rules/amazon-ec2`                    | 🟢 Low      | This guide provides definitive best practices for deploying and managing Amazon EC2 instances, focusing on security, cost optimization, and operational excellence through Infrastructure as Code (IaC).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 119 | `cursor_rules/requests`                      | 🟢 Low      | This guide outlines definitive best practices for using the `requests` library in Python, focusing on performance, reliability, and maintainability for API clients and web interactions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 120 | `cursor_rules/tailwind`                      | 🟢 Low      | Provides definitive best practices for using Tailwind CSS, focusing on maintainability, performance, and scalability in modern web development.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 121 | `cursor_rules/ansible`                       | 🟢 Low      | This guide defines definitive best practices for writing maintainable, performant, and robust Ansible code, focusing on modern YAML hygiene, role design, and CI/CD integration.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 122 | `cursor_rules/netlify`                       | 🟢 Low      | This guide provides opinionated, actionable best practices for building, deploying, and maintaining high-performance, secure, and scalable Jamstack applications on Netlify. It focuses on modern workflows, code quality, and leveraging Netlify's edge-first architecture.                                                                                                                                                                                                                                                                                                                                                                                                              |
| 123 | `cursor_rules/anyio`                         | 🟢 Low      | Definitive guidelines for writing robust, maintainable, and backend-agnostic asynchronous Python code using AnyIO. Prioritize structured concurrency and native AnyIO primitives.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 124 | `cursor_rules/django-rest-framework`         | 🟢 Low      | Enforces modern, secure, and performant `django-rest-framework` best practices for API development, focusing on maintainability and scalability.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 125 | `cursor_rules/webpack`                       | 🟢 Low      | This guide provides opinionated, actionable best practices for configuring webpack, focusing on performance, maintainability, and modern development workflows in 2025.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 126 | `cursor_rules/discord-api`                   | 🟢 Low      | Definitive guidelines for building robust, scalable, and compliant Discord applications using the discord-api, emphasizing REST over Gateway, strong typing, and modern interaction patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 127 | `cursor_rules/aws-amplify`                   | 🟢 Low      | This guide provides opinionated, actionable best practices for building scalable, maintainable full-stack applications using AWS Amplify Gen 2, focusing on TypeScript-first development and efficient cloud resource management.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 128 | `cursor_rules/scikit-image`                  | 🟢 Low      | This guide defines the definitive best practices for developing with scikit-image, ensuring maintainable, performant, and robust image processing code.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 129 | `cursor_rules/vue3`                          | 🟢 Low      | Definitive guidelines for building maintainable, performant, and type-safe Vue 3 applications using modern best practices, Composition API, and TypeScript.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 130 | `cursor_rules/vite`                          | 🟢 Low      | This guide provides definitive best practices for developing high-performance, maintainable applications with Vite, focusing on optimal configuration, code structure, and testing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 131 | `cursor_rules/transformers`                  | 🟢 Low      | Definitive guidelines for writing high-quality, maintainable, and performant code with 🤗 Transformers, ensuring consistency and adherence to 2025 best practices.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 132 | `cursor_rules/tqdm`                          | 🟢 Low      | This guide defines best practices for using the `tqdm` library to implement clear, efficient, and robust progress bars in Python applications, ensuring consistent user feedback and maintainable code.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 133 | `cursor_rules/peewee`                        | 🟢 Low      | Definitive guidelines for writing robust, maintainable, and performant Peewee ORM code in Python, covering data modeling, querying, and application structure.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 134 | `cursor_rules/graphql`                       | 🟢 Low      | Enforce modern, performant, and secure GraphQL schema design and operation best practices for maintainable and scalable APIs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 135 | `cursor_rules/d3`                            | 🟢 Low      | This guide provides definitive, actionable best practices for writing modern D3.js v7+ code, focusing on modularity, performance, and maintainability.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 136 | `cursor_rules/hardhat`                       | 🟢 Low      | Ensure Hardhat projects follow modern best practices for configuration, testing, deployment, and security using TypeScript and Hardhat 3's Rust runtime.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 137 | `cursor_rules/fastapi`                       | 🟢 Low      | Definitive guidelines for building high-performance, maintainable, and secure FastAPI applications using modern Python best practices.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 138 | `cursor_rules/riverpod`                      | 🟢 Low      | Definitive guidelines for using Riverpod in Flutter projects, focusing on modern, opinionated best practices for state management, code organization, performance, and testing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 139 | `cursor_rules/tensorflow`                    | 🔴 Review   | This guide defines the definitive best practices for writing TensorFlow code, focusing on `tf.keras` for models, `tf.data` for input pipelines, and `@tf.function` for performance, ensuring reproducible, scalable, and production-ready ML systems.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 140 | `cursor_rules/datadog`                       | 🟢 Low      | Enforce Datadog best practices for structured logging, consistent tagging, metric governance, and CI/CD integration to ensure reliable and actionable observability across all services.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 141 | `cursor_rules/aws-ecs`                       | 🔴 Review   | Definitive guidelines for building, deploying, and operating applications on AWS ECS, emphasizing immutable containers, secure secrets management, and robust operational patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 142 | `cursor_rules/pyright`                       | 🟢 Low      | This guide provides definitive, actionable best practices for configuring and using pyright (and basedpyright) to ensure robust, type-safe Python codebases in 2025.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 143 | `cursor_rules/matplotlib`                    | 🟢 Low      | This guide outlines definitive best practices for writing clean, performant, and maintainable matplotlib code, emphasizing the object-oriented API and modern data science workflows.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 144 | `cursor_rules/amazon-s3`                     | 🟢 Low      | This guide provides definitive best practices for interacting with Amazon S3, focusing on security, performance, cost optimization, and maintainable code in modern AWS applications.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 145 | `cursor_rules/aws`                           | 🟢 Low      | This guide provides opinionated, actionable best practices for developing and deploying applications on AWS, emphasizing CDK v2, serverless patterns, and Well-Architected principles.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 146 | `cursor_rules/eslint`                        | 🟢 Low      | This guide defines the definitive ESLint configuration and best practices for our team, ensuring consistent code quality, early error detection, and seamless integration with modern JavaScript and TypeScript workflows.                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 147 | `cursor_rules/numba`                         | 🟢 Low      | Definitive guidelines for writing high-performance, maintainable, and robust Numba-accelerated Python code, covering CPU and GPU targets.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 148 | `cursor_rules/zustand`                       | 🟢 Low      | Definitive guidelines for using Zustand in React projects, focusing on type safety, modularity, performance, and maintainability with practical code examples.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 149 | `cursor_rules/huggingface`                   | 🟢 Low      | Definitive guidelines for writing robust, performant, and maintainable Python code using Hugging Face Transformers and the Hugging Face Hub.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 150 | `cursor_rules/django-orm`                    | 🟢 Low      | This guide provides opinionated, actionable best practices for writing efficient, maintainable, and performant Django ORM code, focusing on common pitfalls and modern patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 151 | `cursor_rules/spacy`                         | 🟢 Low      | This guide provides definitive, opinionated best practices for writing maintainable, performant, and robust spaCy code in Python, focusing on modern patterns and avoiding common pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 152 | `cursor_rules/pytorch`                       | 🟢 Low      | Definitive guidelines for writing clean, performant, and maintainable PyTorch code, emphasizing modern best practices, explicit device management, and efficient training patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 153 | `cursor_rules/jax`                           | 🟢 Low      | Definitive guidelines for writing high-performance, functionally pure, and maintainable JAX code, focusing on common pitfalls and optimal patterns for accelerators.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 154 | `cursor_rules/kubernetes`                    | 🟢 Low      | This guide defines definitive best practices for writing, organizing, and securing Kubernetes manifests and Operators, ensuring maintainable, performant, and reliable cloud-native deployments.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 155 | `cursor_rules/statsmodels`                   | 🟢 Low      | This guide provides opinionated, actionable best practices for using statsmodels in Python, focusing on code organization, common patterns, performance, and modern development workflows to ensure robust and reproducible statistical analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 156 | `cursor_rules/beautifulsoup4`                | 🟢 Low      | This guide provides opinionated, actionable, and example-driven best practices for using beautifulsoup4 in Python web scraping projects, focusing on modern techniques and common pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 157 | `cursor_rules/black`                         | 🟢 Low      | Enforce consistent Python code formatting using Black, automate style checks, and integrate seamlessly into development workflows to eliminate style debates and speed up code reviews.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 158 | `cursor_rules/django`                        | 🟢 Low      | Definitive guidelines for writing maintainable, performant, and secure Django applications, emphasizing modern best practices, clear code organization, and efficient patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 159 | `cursor_rules/asyncio`                       | 🟢 Low      | Definitive guidelines for writing robust, performant, and maintainable asynchronous Python code using the asyncio standard library.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 160 | `cursor_rules/scipy`                         | 🟢 Low      | This guide provides opinionated, actionable best practices for writing robust, performant, and maintainable Python code using SciPy, aligning with modern scientific computing standards.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 161 | `cursor_rules/cheerio`                       | 🟢 Low      | Definitive guidelines for using cheerio effectively in Node.js projects, focusing on robust web scraping, performance, and maintainable code.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 162 | `cursor_rules/elasticsearch`                 | 🟢 Low      | This rule file guides developers on best practices for using Elasticsearch, focusing on data modeling, query optimization, performance, and code structure for robust, high-performance search applications.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 163 | `cursor_rules/ruby`                          | 🟢 Low      | This guide provides opinionated, actionable best practices for writing modern Ruby code, focusing on maintainability, performance, and security, with a strong emphasis on RuboCop and Rails conventions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 164 | `cursor_rules/scikit-learn`                  | 🟢 Low      | Definitive guidelines for writing robust, maintainable, and performant scikit-learn code, emphasizing consistent preprocessing, API adherence, and data leakage prevention.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 165 | `cursor_rules/pyqt`                          | 🟢 Low      | Enforce modern, maintainable, and performant PyQt application development standards by leveraging Qt Designer, Model-View architecture, and responsive threading.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 166 | `cursor_rules/git`                           | 🟢 Low      | This guide defines the definitive Git best practices for our team, ensuring clean history, efficient collaboration, and high code quality through structured workflows, commit standards, and automated hooks.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 167 | `cursor_rules/godot`                         | 🟢 Low      | This guide provides opinionated, actionable best practices for Godot 4.x development, focusing on code organization, common patterns, performance, and avoiding pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 168 | `cursor_rules/pandas`                        | 🟢 Low      | This guide outlines definitive best practices for writing high-performance, maintainable, and robust pandas code, focusing on modern patterns and avoiding common pitfalls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 169 | `cursor_rules/stripe`                        | 🔴 Review   | Definitive guidelines for building robust, secure, and efficient Stripe integrations using modern API practices (v2, Checkout Sessions, Payment Intents, Elements) and essential safeguards like idempotency and webhook verification.                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 170 | `cursor_rules/boto3`                         | 🟢 Low      | This rule file guides developers on writing idiomatic, high-performance, and type-safe boto3 code, emphasizing client reuse, proper pagination, batch operations, and robust testing strategies.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 171 | `scientific/scikit-survival`                 | 🔴 Review   | Comprehensive toolkit for survival analysis and time-to-event modeling in Python using scikit-survival. Use this skill when working with censored survival data, performing time-to-event analysis, fitting Cox models, Random Survival Forests, Gradient Boosting models, or Survival SVMs, evaluating survival predictions with concordance index or Brier score, handling competing risks, or implementing any survival analysis workflow with the scikit-survival library.                                                                                                                                                                                                            |
| 172 | `scientific/qiskit`                          | 🔴 Review   | IBM quantum computing framework. Use when targeting IBM Quantum hardware, working with Qiskit Runtime for production workloads, or needing IBM optimization tools. Best for IBM hardware execution, quantum error mitigation, and enterprise quantum computing. For Google hardware use cirq; for gradient-based quantum ML use pennylane; for open quantum system simulations use qutip.                                                                                                                                                                                                                                                                                                 |
| 173 | `scientific/uspto-database`                  | 🔴 Review   | Access USPTO APIs for patent/trademark searches, examination history (PEDS), assignments, citations, office actions, TSDR, for IP analysis and prior art searches.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 174 | `scientific/kegg-database`                   | 🔴 Review   | Direct REST API access to KEGG (academic use only). Pathway analysis, gene-pathway mapping, metabolic pathways, drug interactions, ID conversion. For Python workflows with multiple databases, prefer bioservices. Use this for direct HTTP/REST work or KEGG-specific control.                                                                                                                                                                                                                                                                                                                                                                                                          |
| 175 | `scientific/paper-2-web`                     | 🔴 Review   | This skill should be used when converting academic papers into promotional and presentation formats including interactive websites (Paper2Web), presentation videos (Paper2Video), and conference posters (Paper2Poster). Use this skill for tasks involving paper dissemination, conference preparation, creating explorable academic homepages, generating video abstracts, or producing print-ready posters from LaTeX or PDF sources.                                                                                                                                                                                                                                                 |
| 176 | `scientific/perplexity-search`               | 🔴 Review   | Perform AI-powered web searches with real-time information using Perplexity models via LiteLLM and OpenRouter. This skill should be used when conducting web searches for current information, finding recent scientific literature, getting grounded answers with source citations, or accessing information beyond the model knowledge cutoff. Provides access to multiple Perplexity models including Sonar Pro, Sonar Pro Search (advanced agentic search), and Sonar Reasoning Pro through a single OpenRouter API key.                                                                                                                                                              |
| 177 | `scientific/research-lookup`                 | 🔴 Review   | Look up current research information using Perplexity Sonar Pro Search or Sonar Reasoning Pro models through OpenRouter. Automatically selects the best model based on query complexity. Search academic papers, recent studies, technical documentation, and general research information with citations.                                                                                                                                                                                                                                                                                                                                                                                |
| 178 | `scientific/shap`                            | 🔴 Review   | Model interpretability and explainability using SHAP (SHapley Additive exPlanations). Use this skill when explaining machine learning model predictions, computing feature importance, generating SHAP plots (waterfall, beeswarm, bar, scatter, force, heatmap), debugging models, analyzing model bias or fairness, comparing models, or implementing explainable AI. Works with tree-based models (XGBoost, LightGBM, Random Forest), deep learning (TensorFlow, PyTorch), linear models, and any black-box model.                                                                                                                                                                     |
| 179 | `scientific/zinc-database`                   | 🔴 Review   | Access ZINC (230M+ purchasable compounds). Search by ZINC ID/SMILES, similarity searches, 3D-ready structures for docking, analog discovery, for virtual screening and drug discovery.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 180 | `scientific/umap-learn`                      | 🔴 Review   | UMAP dimensionality reduction. Fast nonlinear manifold learning for 2D/3D visualization, clustering preprocessing (HDBSCAN), supervised/parametric UMAP, for high-dimensional data.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 181 | `scientific/imaging-data-commons`            | 🔴 Review   | Query and download public cancer imaging data from NCI Imaging Data Commons using idc-index. Use for accessing large-scale radiology (CT, MR, PET) and pathology datasets for AI training or research. No authentication required. Query by metadata, visualize in browser, check licenses.                                                                                                                                                                                                                                                                                                                                                                                               |
| 182 | `scientific/sympy`                           | 🔴 Review   | Use this skill when working with symbolic mathematics in Python. This skill should be used for symbolic computation tasks including solving equations algebraically, performing calculus operations (derivatives, integrals, limits), manipulating algebraic expressions, working with matrices symbolically, physics calculations, number theory problems, geometry computations, and generating executable code from mathematical expressions. Apply this skill when the user needs exact symbolic results rather than numerical approximations, or when working with mathematical formulas that contain variables and parameters.                                                      |
| 183 | `scientific/vaex`                            | 🔴 Review   | Use this skill for processing and analyzing large tabular datasets (billions of rows) that exceed available RAM. Vaex excels at out-of-core DataFrame operations, lazy evaluation, fast aggregations, efficient visualization of big data, and machine learning on large datasets. Apply when users need to work with large CSV/HDF5/Arrow/Parquet files, perform fast statistics on massive datasets, create visualizations of big data, or build ML pipelines that do not fit in memory.                                                                                                                                                                                                |
| 184 | `scientific/alphafold-database`              | 🔴 Review   | Access AlphaFold 200M+ AI-predicted protein structures. Retrieve structures by UniProt ID, download PDB/mmCIF files, analyze confidence metrics (pLDDT, PAE), for drug discovery and structural biology.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 185 | `scientific/dask`                            | 🔴 Review   | Distributed computing for larger-than-RAM pandas/NumPy workflows. Use when you need to scale existing pandas/NumPy code beyond memory or across clusters. Best for parallel file processing, distributed ML, integration with existing pandas code. For out-of-core analytics on single machine use vaex; for in-memory speed use polars.                                                                                                                                                                                                                                                                                                                                                 |
| 186 | `scientific/get-available-resources`         | 🔴 Review   | This skill should be used at the start of any computationally intensive scientific task to detect and report available system resources (CPU cores, GPUs, memory, disk space). It creates a JSON file with resource information and strategic recommendations that inform computational approach decisions such as whether to use parallel processing (joblib, multiprocessing), out-of-core computing (Dask, Zarr), GPU acceleration (PyTorch, JAX), or memory-efficient strategies. Use this skill before running analyses, training models, processing large datasets, or any task where resource constraints matter.                                                                  |
| 187 | `scientific/cosmic-database`                 | 🔴 Review   | Access COSMIC cancer mutation database. Query somatic mutations, Cancer Gene Census, mutational signatures, gene fusions, for cancer research and precision oncology. Requires authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 188 | `scientific/gene-database`                   | 🔴 Review   | Query NCBI Gene via E-utilities/Datasets API. Search by symbol/ID, retrieve gene info (RefSeqs, GO, locations, phenotypes), batch lookups, for gene annotation and functional analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 189 | `scientific/biorxiv-database`                | 🔴 Review   | Efficient database search tool for bioRxiv preprint server. Use this skill when searching for life sciences preprints by keywords, authors, date ranges, or categories, retrieving paper metadata, downloading PDFs, or conducting literature reviews.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 190 | `scientific/esm`                             | 🔴 Review   | Comprehensive toolkit for protein language models including ESM3 (generative multimodal protein design across sequence, structure, and function) and ESM C (efficient protein embeddings and representations). Use this skill when working with protein sequences, structures, or function prediction; designing novel proteins; generating protein embeddings; performing inverse folding; or conducting protein engineering tasks. Supports both local model usage and cloud-based Forge API for scalable inference.                                                                                                                                                                    |
| 191 | `scientific/scientific-schematics`           | 🔴 Review   | Create publication-quality scientific diagrams using Nano Banana Pro AI with smart iterative refinement. Uses Gemini 3 Pro for quality review. Only regenerates if quality is below threshold for your document type. Specialized in neural network architectures, system diagrams, flowcharts, biological pathways, and complex scientific visualizations.                                                                                                                                                                                                                                                                                                                               |
| 192 | `scientific/geniml`                          | 🔴 Review   | This skill should be used when working with genomic interval data (BED files) for machine learning tasks. Use for training region embeddings (Region2Vec, BEDspace), single-cell ATAC-seq analysis (scEmbed), building consensus peaks (universes), or any ML-based analysis of genomic regions. Applies to BED file collections, scATAC-seq data, chromatin accessibility datasets, and region-based genomic feature learning.                                                                                                                                                                                                                                                           |
| 193 | `scientific/geopandas`                       | 🔴 Review   | Python library for working with geospatial vector data including shapefiles, GeoJSON, and GeoPackage files. Use when working with geographic data for spatial analysis, geometric operations, coordinate transformations, spatial joins, overlay operations, choropleth mapping, or any task involving reading/writing/analyzing vector geographic data. Supports PostGIS databases, interactive maps, and integration with matplotlib/folium/cartopy. Use for tasks like buffer analysis, spatial joins between datasets, dissolving boundaries, clipping data, calculating areas/distances, reprojecting coordinate systems, creating maps, or converting between spatial file formats. |
| 194 | `scientific/seaborn`                         | 🔴 Review   | Statistical visualization with pandas integration. Use for quick exploration of distributions, relationships, and categorical comparisons with attractive defaults. Best for box plots, violin plots, pair plots, heatmaps. Built on matplotlib. For interactive plots use plotly; for publication styling use scientific-visualization.                                                                                                                                                                                                                                                                                                                                                  |
| 195 | `scientific/protocolsio-integration`         | 🔴 Review   | Integration with protocols.io API for managing scientific protocols. This skill should be used when working with protocols.io to search, create, update, or publish protocols; manage protocol steps and materials; handle discussions and comments; organize workspaces; upload and manage files; or integrate protocols.io functionality into workflows. Applicable for protocol discovery, collaborative protocol development, experiment tracking, lab protocol management, and scientific documentation.                                                                                                                                                                             |
| 196 | `scientific/fluidsim`                        | 🔴 Review   | Framework for computational fluid dynamics simulations using Python. Use when running fluid dynamics simulations including Navier-Stokes equations (2D/3D), shallow water equations, stratified flows, or when analyzing turbulence, vortex dynamics, or geophysical flows. Provides pseudospectral methods with FFT, HPC support, and comprehensive output analysis.                                                                                                                                                                                                                                                                                                                     |
| 197 | `scientific/pymatgen`                        | 🔴 Review   | Materials science toolkit. Crystal structures (CIF, POSCAR), phase diagrams, band structure, DOS, Materials Project integration, format conversion, for computational materials science.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 198 | `scientific/molfeat`                         | 🔴 Review   | Molecular featurization for ML (100+ featurizers). ECFP, MACCS, descriptors, pretrained models (ChemBERTa), convert SMILES to features, for QSAR and molecular ML.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 199 | `scientific/geo-database`                    | 🔴 Review   | Access NCBI GEO for gene expression/genomics data. Search/download microarray and RNA-seq datasets (GSE, GSM, GPL), retrieve SOFT/Matrix files, for transcriptomics and expression analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 200 | `scientific/citation-management`             | 🔴 Review   | Comprehensive citation management for academic research. Search Google Scholar and PubMed for papers, extract accurate metadata, validate citations, and generate properly formatted BibTeX entries. This skill should be used when you need to find papers, verify citation information, convert DOIs to BibTeX, or ensure reference accuracy in scientific writing.                                                                                                                                                                                                                                                                                                                     |
| 201 | `scientific/scientific-critical-thinking`    | 🔴 Review   | Evaluate scientific claims and evidence quality. Use for assessing experimental design validity, identifying biases and confounders, applying evidence grading frameworks (GRADE, Cochrane Risk of Bias), or teaching critical analysis. Best for understanding evidence quality, identifying flaws. For formal peer review writing use peer-review.                                                                                                                                                                                                                                                                                                                                      |
| 202 | `scientific/pydicom`                         | 🔴 Review   | Python library for working with DICOM (Digital Imaging and Communications in Medicine) files. Use this skill when reading, writing, or modifying medical imaging data in DICOM format, extracting pixel data from medical images (CT, MRI, X-ray, ultrasound), anonymizing DICOM files, working with DICOM metadata and tags, converting DICOM images to other formats, handling compressed DICOM data, or processing medical imaging datasets. Applies to tasks involving medical image analysis, PACS systems, radiology workflows, and healthcare imaging applications.                                                                                                                |
| 203 | `scientific/markitdown`                      | 🔴 Review   | Convert files and office documents to Markdown. Supports PDF, DOCX, PPTX, XLSX, images (with OCR), audio (with transcription), HTML, CSV, JSON, XML, ZIP, YouTube URLs, EPubs and more.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 204 | `scientific/hmdb-database`                   | 🔴 Review   | Access Human Metabolome Database (220K+ metabolites). Search by name/ID/structure, retrieve chemical properties, biomarker data, NMR/MS spectra, pathways, for metabolomics and identification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 205 | `scientific/rowan`                           | 🔴 Review   | Cloud-based quantum chemistry platform with Python API. Preferred for computational chemistry workflows including pKa prediction, geometry optimization, conformer searching, molecular property calculations, protein-ligand docking (AutoDock Vina), and AI protein cofolding (Chai-1, Boltz-1/2). Use when tasks involve quantum chemistry calculations, molecular property prediction, DFT or semiempirical methods, neural network potentials (AIMNet2), protein-ligand binding predictions, or automated computational chemistry pipelines. Provides cloud compute resources with no local setup required.                                                                          |
| 206 | `scientific/clinvar-database`                | 🔴 Review   | Query NCBI ClinVar for variant clinical significance. Search by gene/position, interpret pathogenicity classifications, access via E-utilities API or FTP, annotate VCFs, for genomic medicine.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 207 | `scientific/drugbank-database`               | 🔴 Review   | Access and analyze comprehensive drug information from the DrugBank database including drug properties, interactions, targets, pathways, chemical structures, and pharmacology data. This skill should be used when working with pharmaceutical data, drug discovery research, pharmacology studies, drug-drug interaction analysis, target identification, chemical similarity searches, ADMET predictions, or any task requiring detailed drug and drug target information from DrugBank.                                                                                                                                                                                               |
| 208 | `scientific/opentrons-integration`           | 🔴 Review   | Official Opentrons Protocol API for OT-2 and Flex robots. Use when writing protocols specifically for Opentrons hardware with full access to Protocol API v2 features. Best for production Opentrons protocols, official API compatibility. For multi-vendor automation or broader equipment control use pylabrobot.                                                                                                                                                                                                                                                                                                                                                                      |
| 209 | `scientific/brenda-database`                 | 🔴 Review   | Access BRENDA enzyme database via SOAP API. Retrieve kinetic parameters (Km, kcat), reaction equations, organism data, and substrate-specific enzyme information for biochemical research and metabolic pathway analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 210 | `scientific/fda-database`                    | 🔴 Review   | Query openFDA API for drugs, devices, adverse events, recalls, regulatory submissions (510k, PMA), substance identification (UNII), for FDA regulatory data analysis and safety research.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 211 | `scientific/biopython`                       | 🔴 Review   | Comprehensive molecular biology toolkit. Use for sequence manipulation, file parsing (FASTA/GenBank/PDB), phylogenetics, and programmatic NCBI/PubMed access (Bio.Entrez). Best for batch processing, custom bioinformatics pipelines, BLAST automation. For quick lookups use gget; for multi-service integration use bioservices.                                                                                                                                                                                                                                                                                                                                                       |
| 212 | `scientific/gtars`                           | 🔴 Review   | High-performance toolkit for genomic interval analysis in Rust with Python bindings. Use when working with genomic regions, BED files, coverage tracks, overlap detection, tokenization for ML models, or fragment analysis in computational genomics and machine learning applications.                                                                                                                                                                                                                                                                                                                                                                                                  |
| 213 | `scientific/scvi-tools`                      | 🔴 Review   | Deep generative models for single-cell omics. Use when you need probabilistic batch correction (scVI), transfer learning, differential expression with uncertainty, or multi-modal integration (TOTALVI, MultiVI). Best for advanced modeling, batch effects, multimodal data. For standard analysis pipelines use scanpy.                                                                                                                                                                                                                                                                                                                                                                |
| 214 | `scientific/lamindb`                         | 🔴 Review   | This skill should be used when working with LaminDB, an open-source data framework for biology that makes data queryable, traceable, reproducible, and FAIR. Use when managing biological datasets (scRNA-seq, spatial, flow cytometry, etc.), tracking computational workflows, curating and validating data with biological ontologies, building data lakehouses, or ensuring data lineage and reproducibility in biological research. Covers data management, annotation, ontologies (genes, cell types, diseases, tissues), schema validation, integrations with workflow managers (Nextflow, Snakemake) and MLOps platforms (W&B, MLflow), and deployment strategies.                |
| 215 | `scientific/datamol`                         | 🔴 Review   | Pythonic wrapper around RDKit with simplified interface and sensible defaults. Preferred for standard drug discovery including SMILES parsing, standardization, descriptors, fingerprints, clustering, 3D conformers, parallel processing. Returns native rdkit.Chem.Mol objects. For advanced control or custom parameters, use rdkit directly.                                                                                                                                                                                                                                                                                                                                          |
| 216 | `scientific/research-grants`                 | 🔴 Review   | Write competitive research proposals for NSF, NIH, DOE, DARPA, and Taiwan NSTC. Agency-specific formatting, review criteria, budget preparation, broader impacts, significance statements, innovation narratives, and compliance with submission requirements.                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 217 | `scientific/ensembl-database`                | 🔴 Review   | Query Ensembl genome database REST API for 250+ species. Gene lookups, sequence retrieval, variant analysis, comparative genomics, orthologs, VEP predictions, for genomic research.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 218 | `scientific/plotly`                          | 🔴 Review   | Interactive visualization library. Use when you need hover info, zoom, pan, or web-embeddable charts. Best for dashboards, exploratory analysis, and presentations. For static publication figures use matplotlib or scientific-visualization.                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 219 | `scientific/statistical-analysis`            | 🔴 Review   | Guided statistical analysis with test selection and reporting. Use when you need help choosing appropriate tests for your data, assumption checking, power analysis, and APA-formatted results. Best for academic research reporting, test selection guidance. For implementing specific models programmatically use statsmodels.                                                                                                                                                                                                                                                                                                                                                         |
| 220 | `scientific/denario`                         | 🔴 Review   | Multiagent AI system for scientific research assistance that automates research workflows from data analysis to publication. This skill should be used when generating research ideas from datasets, developing research methodologies, executing computational experiments, performing literature searches, or generating publication-ready papers in LaTeX format. Supports end-to-end research pipelines with customizable agent orchestration.                                                                                                                                                                                                                                        |
| 221 | `scientific/scientific-writing`              | 🔴 Review   | Core skill for the deep research and writing tool. Write scientific manuscripts in full paragraphs (never bullet points). Use two-stage process with (1) section outlines with key points using research-lookup then (2) convert to flowing prose. IMRAD structure, citations (APA/AMA/Vancouver), figures/tables, reporting guidelines (CONSORT/STROBE/PRISMA), for research papers and journal submissions.                                                                                                                                                                                                                                                                             |
| 222 | `scientific/clinical-decision-support`       | 🔴 Review   | Generate professional clinical decision support (CDS) documents for pharmaceutical and clinical research settings, including patient cohort analyses (biomarker-stratified with outcomes) and treatment recommendation reports (evidence-based guidelines with decision algorithms). Supports GRADE evidence grading, statistical analysis (hazard ratios, survival curves, waterfall plots), biomarker integration, and regulatory compliance. Outputs publication-ready LaTeX/PDF format optimized for drug development, clinical research, and evidence synthesis.                                                                                                                     |
| 223 | `scientific/diffdock`                        | 🔴 Review   | Diffusion-based molecular docking. Predict protein-ligand binding poses from PDB/SMILES, confidence scores, virtual screening, for structure-based drug design. Not for affinity prediction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 224 | `scientific/clinpgx-database`                | 🔴 Review   | Access ClinPGx pharmacogenomics data (successor to PharmGKB). Query gene-drug interactions, CPIC guidelines, allele functions, for precision medicine and genotype-guided dosing decisions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 225 | `scientific/pydeseq2`                        | 🔴 Review   | Differential gene expression analysis (Python DESeq2). Identify DE genes from bulk RNA-seq counts, Wald tests, FDR correction, volcano/MA plots, for RNA-seq analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 226 | `scientific/gwas-database`                   | 🔴 Review   | Query NHGRI-EBI GWAS Catalog for SNP-trait associations. Search variants by rs ID, disease/trait, gene, retrieve p-values and summary statistics, for genetic epidemiology and polygenic risk scores.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 227 | `scientific/bioservices`                     | 🔴 Review   | Unified Python interface to 40+ bioinformatics services. Use when querying multiple databases (UniProt, KEGG, ChEMBL, Reactome) in a single workflow with consistent API. Best for cross-database analysis, ID mapping across services. For quick single-database lookups use gget; for sequence/file manipulation use biopython.                                                                                                                                                                                                                                                                                                                                                         |
| 228 | `scientific/scikit-bio`                      | 🔴 Review   | Biological data toolkit. Sequence analysis, alignments, phylogenetic trees, diversity metrics (alpha/beta, UniFrac), ordination (PCoA), PERMANOVA, FASTA/Newick I/O, for microbiome analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 229 | `scientific/gget`                            | 🔴 Review   | "Fast CLI/Python queries to 20+ bioinformatics databases. Use for quick lookups: gene info, BLAST searches, AlphaFold structures, enrichment analysis. Best for interactive exploration, simple queries. For batch processing or advanced BLAST use biopython; for multi-database Python workflows use bioservices."                                                                                                                                                                                                                                                                                                                                                                      |
| 230 | `scientific/literature-review`               | 🔴 Review   | Conduct comprehensive, systematic literature reviews using multiple academic databases (PubMed, arXiv, bioRxiv, Semantic Scholar, etc.). This skill should be used when conducting systematic literature reviews, meta-analyses, research synthesis, or comprehensive literature searches across biomedical, scientific, and technical domains. Creates professionally formatted markdown documents and PDFs with verified citations in multiple citation styles (APA, Nature, Vancouver, etc.).                                                                                                                                                                                          |
| 231 | `scientific/pyhealth`                        | 🔴 Review   | Comprehensive healthcare AI toolkit for developing, testing, and deploying machine learning models with clinical data. This skill should be used when working with electronic health records (EHR), clinical prediction tasks (mortality, readmission, drug recommendation), medical coding systems (ICD, NDC, ATC), physiological signals (EEG, ECG), healthcare datasets (MIMIC-III/IV, eICU, OMOP), or implementing deep learning models for healthcare applications (RETAIN, SafeDrug, Transformer, GNN).                                                                                                                                                                             |
| 232 | `scientific/transformers`                    | 🔴 Review   | This skill should be used when working with pre-trained transformer models for natural language processing, computer vision, audio, or multimodal tasks. Use for text generation, classification, question answering, translation, summarization, image classification, object detection, speech recognition, and fine-tuning models on custom datasets.                                                                                                                                                                                                                                                                                                                                  |
| 233 | `scientific/scholar-evaluation`              | 🔴 Review   | Systematically evaluate scholarly work using the ScholarEval framework, providing structured assessment across research quality dimensions including problem formulation, methodology, analysis, and writing with quantitative scoring and actionable feedback.                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 234 | `scientific/cirq`                            | 🔴 Review   | Google quantum computing framework. Use when targeting Google Quantum AI hardware, designing noise-aware circuits, or running quantum characterization experiments. Best for Google hardware, noise modeling, and low-level circuit design. For IBM hardware use qiskit; for quantum ML with autodiff use pennylane; for physics simulations use qutip.                                                                                                                                                                                                                                                                                                                                   |
| 235 | `scientific/uniprot-database`                | 🔴 Review   | Direct REST API access to UniProt. Protein searches, FASTA retrieval, ID mapping, Swiss-Prot/TrEMBL. For Python workflows with multiple databases, prefer bioservices (unified interface to 40+ services). Use this for direct HTTP/REST work or UniProt-specific control.                                                                                                                                                                                                                                                                                                                                                                                                                |
| 236 | `scientific/deepchem`                        | 🔴 Review   | Molecular ML with diverse featurizers and pre-built datasets. Use for property prediction (ADMET, toxicity) with traditional ML or GNNs when you want extensive featurization options and MoleculeNet benchmarks. Best for quick experiments with pre-trained models, diverse molecular representations. For graph-first PyTorch workflows use torchdrug; for benchmark datasets use pytdc.                                                                                                                                                                                                                                                                                               |
| 237 | `scientific/pathml`                          | 🔴 Review   | Full-featured computational pathology toolkit. Use for advanced WSI analysis including multiplexed immunofluorescence (CODEX, Vectra), nucleus segmentation, tissue graph construction, and ML model training on pathology data. Supports 160+ slide formats. For simple tile extraction from H&E slides, histolab may be simpler.                                                                                                                                                                                                                                                                                                                                                        |
| 238 | `scientific/latex-posters`                   | 🔴 Review   | Create professional research posters in LaTeX using beamerposter, tikzposter, or baposter. Support for conference presentations, academic posters, and scientific communication. Includes layout design, color schemes, multi-column formats, figure integration, and poster-specific best practices for visual communication.                                                                                                                                                                                                                                                                                                                                                            |
| 239 | `scientific/zarr-python`                     | 🔴 Review   | Chunked N-D arrays for cloud storage. Compressed arrays, parallel I/O, S3/GCS integration, NumPy/Dask/Xarray compatible, for large-scale scientific computing pipelines.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 240 | `scientific/matplotlib`                      | 🔴 Review   | Low-level plotting library for full customization. Use when you need fine-grained control over every plot element, creating novel plot types, or integrating with specific scientific workflows. Export to PNG/PDF/SVG for publication. For quick statistical plots use seaborn; for interactive plots use plotly; for publication-ready multi-panel figures with journal styling, use scientific-visualization.                                                                                                                                                                                                                                                                          |
| 241 | `scientific/adaptyv`                         | 🔴 Review   | Cloud laboratory platform for automated protein testing and validation. Use when designing proteins and needing experimental validation including binding assays, expression testing, thermostability measurements, enzyme activity assays, or protein sequence optimization. Also use for submitting experiments via API, tracking experiment status, downloading results, optimizing protein sequences for better expression using computational tools (NetSolP, SoluProt, SolubleMPNN, ESM), or managing protein design workflows with wet-lab validation.                                                                                                                             |
| 242 | `scientific/venue-templates`                 | 🔴 Review   | Access comprehensive LaTeX templates, formatting requirements, and submission guidelines for major scientific publication venues (Nature, Science, PLOS, IEEE, ACM), academic conferences (NeurIPS, ICML, CVPR, CHI), research posters, and grant proposals (NSF, NIH, DOE, DARPA). This skill should be used when preparing manuscripts for journal submission, conference papers, research posters, or grant proposals and need venue-specific formatting requirements and templates.                                                                                                                                                                                                   |
| 243 | `scientific/pytorch-lightning`               | 🟡 Elevated | Deep learning framework (PyTorch Lightning). Organize PyTorch code into LightningModules, configure Trainers for multi-GPU/TPU, implement data pipelines, callbacks, logging (W&B, TensorBoard), distributed training (DDP, FSDP, DeepSpeed), for scalable neural network training.                                                                                                                                                                                                                                                                                                                                                                                                       |
| 244 | `scientific/scientific-slides`               | 🔴 Review   | Build slide decks and presentations for research talks. Use this for making PowerPoint slides, conference presentations, seminar talks, research presentations, thesis defense slides, or any scientific talk. Provides slide structure, design templates, timing guidance, and visual validation. Works with PowerPoint and LaTeX Beamer.                                                                                                                                                                                                                                                                                                                                                |
| 245 | `scientific/scientific-visualization`        | 🔴 Review   | Meta-skill for publication-ready figures. Use when creating journal submission figures requiring multi-panel layouts, significance annotations, error bars, colorblind-safe palettes, and specific journal formatting (Nature, Science, Cell). Orchestrates matplotlib/seaborn/plotly with publication styles. For quick exploration use seaborn or plotly directly.                                                                                                                                                                                                                                                                                                                      |
| 246 | `scientific/neuropixels-analysis`            | 🔴 Review   | Neuropixels neural recording analysis. Load SpikeGLX/OpenEphys data, preprocess, motion correction, Kilosort4 spike sorting, quality metrics, Allen/IBL curation, AI-assisted visual analysis, for Neuropixels 1.0/2.0 extracellular electrophysiology. Use when working with neural recordings, spike sorting, extracellular electrophysiology, or when the user mentions Neuropixels, SpikeGLX, Open Ephys, Kilosort, quality metrics, or unit curation.                                                                                                                                                                                                                                |
| 247 | `scientific/hypogenic`                       | 🔴 Review   | Automated LLM-driven hypothesis generation and testing on tabular datasets. Use when you want to systematically explore hypotheses about patterns in empirical data (e.g., deception detection, content analysis). Combines literature insights with data-driven hypothesis testing. For manual hypothesis formulation use hypothesis-generation; for creative ideation use scientific-brainstorming.                                                                                                                                                                                                                                                                                     |
| 248 | `scientific/openalex-database`               | 🔴 Review   | Query and analyze scholarly literature using the OpenAlex database. This skill should be used when searching for academic papers, analyzing research trends, finding works by authors or institutions, tracking citations, discovering open access publications, or conducting bibliometric analysis across 240M+ scholarly works. Use for literature searches, research output analysis, citation analysis, and academic database queries.                                                                                                                                                                                                                                               |
| 249 | `scientific/generate-image`                  | 🔴 Review   | Generate or edit images using AI models (FLUX, Gemini). Use for general-purpose image generation including photos, illustrations, artwork, visual assets, concept art, and any image that is not a technical diagram or schematic. For flowcharts, circuits, pathways, and technical diagrams, use the scientific-schematics skill instead.                                                                                                                                                                                                                                                                                                                                               |
| 250 | `scientific/torchdrug`                       | 🔴 Review   | PyTorch-native graph neural networks for molecules and proteins. Use when building custom GNN architectures for drug discovery, protein modeling, or knowledge graph reasoning. Best for custom model development, protein property prediction, retrosynthesis. For pre-trained models and diverse featurizers use deepchem; for benchmark datasets use pytdc.                                                                                                                                                                                                                                                                                                                            |
| 251 | `scientific/flowio`                          | 🟡 Elevated | Parse FCS (Flow Cytometry Standard) files v2.0-3.1. Extract events as NumPy arrays, read metadata/channels, convert to CSV/DataFrame, for flow cytometry data preprocessing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 252 | `scientific/datacommons-client`              | 🔴 Review   | Work with Data Commons, a platform providing programmatic access to public statistical data from global sources. Use this skill when working with demographic data, economic indicators, health statistics, environmental data, or any public datasets available through Data Commons. Applicable for querying population statistics, GDP figures, unemployment rates, disease prevalence, geographic entity resolution, and exploring relationships between statistical entities.                                                                                                                                                                                                        |
| 253 | `scientific/pylabrobot`                      | 🔴 Review   | Vendor-agnostic lab automation framework. Use when controlling multiple equipment types (Hamilton, Tecan, Opentrons, plate readers, pumps) or needing unified programming across different vendors. Best for complex workflows, multi-vendor setups, simulation. For Opentrons-only protocols with official API, opentrons-integration may be simpler.                                                                                                                                                                                                                                                                                                                                    |
| 254 | `scientific/aeon`                            | 🔴 Review   | This skill should be used for time series machine learning tasks including classification, regression, clustering, forecasting, anomaly detection, segmentation, and similarity search. Use when working with temporal data, sequential patterns, or time-indexed observations requiring specialized algorithms beyond standard ML approaches. Particularly suited for univariate and multivariate time series analysis with scikit-learn compatible APIs.                                                                                                                                                                                                                                |
| 255 | `scientific/modal`                           | 🔴 Review   | Run Python code in the cloud with serverless containers, GPUs, and autoscaling. Use when deploying ML models, running batch processing jobs, scheduling compute-intensive tasks, or serving APIs that require GPU acceleration or dynamic scaling.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 256 | `scientific/statsmodels`                     | 🔴 Review   | Statistical models library for Python. Use when you need specific model classes (OLS, GLM, mixed models, ARIMA) with detailed diagnostics, residuals, and inference. Best for econometrics, time series, rigorous inference with coefficient tables. For guided statistical test selection with APA reporting use statistical-analysis.                                                                                                                                                                                                                                                                                                                                                   |
| 257 | `scientific/scanpy`                          | 🔴 Review   | Standard single-cell RNA-seq analysis pipeline. Use for QC, normalization, dimensionality reduction (PCA/UMAP/t-SNE), clustering, differential expression, and visualization. Best for exploratory scRNA-seq analysis with established workflows. For deep learning models use scvi-tools; for data format questions use anndata.                                                                                                                                                                                                                                                                                                                                                         |
| 258 | `scientific/clinicaltrials-database`         | 🔴 Review   | Query ClinicalTrials.gov via API v2. Search trials by condition, drug, location, status, or phase. Retrieve trial details by NCT ID, export data, for clinical research and patient matching.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 259 | `scientific/ena-database`                    | 🔴 Review   | Access European Nucleotide Archive via API/FTP. Retrieve DNA/RNA sequences, raw reads (FASTQ), genome assemblies by accession, for genomics and bioinformatics pipelines. Supports multiple formats.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 260 | `scientific/pennylane`                       | 🔴 Review   | Hardware-agnostic quantum ML framework with automatic differentiation. Use when training quantum circuits via gradients, building hybrid quantum-classical models, or needing device portability across IBM/Google/Rigetti/IonQ. Best for variational algorithms (VQE, QAOA), quantum neural networks, and integration with PyTorch/JAX/TensorFlow. For hardware-specific optimizations use qiskit (IBM) or cirq (Google); for open quantum systems use qutip.                                                                                                                                                                                                                            |
| 261 | `scientific/pufferlib`                       | 🔴 Review   | High-performance reinforcement learning framework optimized for speed and scale. Use when you need fast parallel training, vectorized environments, multi-agent systems, or integration with game environments (Atari, Procgen, NetHack). Achieves 2-10x speedups over standard implementations. For quick prototyping or standard algorithm implementations with extensive documentation, use stable-baselines3 instead.                                                                                                                                                                                                                                                                 |
| 262 | `scientific/dnanexus-integration`            | 🔴 Review   | DNAnexus cloud genomics platform. Build apps/applets, manage data (upload/download), dxpy Python SDK, run workflows, FASTQ/BAM/VCF, for genomics pipeline development and execution.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 263 | `scientific/pdb-database`                    | 🔴 Review   | Access RCSB PDB for 3D protein/nucleic acid structures. Search by text/sequence/structure, download coordinates (PDB/mmCIF), retrieve metadata, for structural biology and drug discovery.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 264 | `scientific/etetoolkit`                      | 🔴 Review   | Phylogenetic tree toolkit (ETE). Tree manipulation (Newick/NHX), evolutionary event detection, orthology/paralogy, NCBI taxonomy, visualization (PDF/SVG), for phylogenomics.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 265 | `scientific/cellxgene-census`                | 🔴 Review   | Query the CELLxGENE Census (61M+ cells) programmatically. Use when you need expression data across tissues, diseases, or cell types from the largest curated single-cell atlas. Best for population-scale queries, reference atlas comparisons. For analyzing your own data use scanpy or scvi-tools.                                                                                                                                                                                                                                                                                                                                                                                     |
| 266 | `scientific/latchbio-integration`            | 🔴 Review   | Latch platform for bioinformatics workflows. Build pipelines with Latch SDK, @workflow/@task decorators, deploy serverless workflows, LatchFile/LatchDir, Nextflow/Snakemake integration.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |

---

[← Back to Directory](../directory.md)
