Development Claude Skills
8 676 development skills from 759 authors. They write and change code. Half of them fit into 1 830 tokens or less — that is what one costs your context window when the agent loads it. 1 213 ship runnable scripts rather than instructions alone. 42 of them cannot work without an MCP server, most often rube. We also found 1 172 copies of these same skills sitting in other people's repositories — counted once here, not 1 172 times.
8 676 unique 759 authors 5 250 updated this month 1 369 from vendors
Identifying vulnerabilities in Node.js dependencies using the npm audit tool to filter for high and critical severities.
Processes JSON data from GitHub Search results to compute specific repository health metrics including average merge time, top contributors, and bug resolution counts.
Fetch data from GitHub's Search API using the GitHub CLI (gh) while correctly handling pagination and merging results. Use this when you need to retrieve more than 100 items or ensure full dataset coverage for a specific period.
Aligns the local environment with the repository's requirements by checking for dependency files, installing build-essential tools for complex packages like DeepSpeed, and logging environment metadata.
Define idiomatic Scala 2.13 type hierarchies and domain models, replacing Python's class structures and Enums with traits and case classes.
Initializes the directory structure and populates the environment with necessary data and libraries for the D3.js visualization. This skill should be executed before generating any code files to ensure the target paths exist and the D3 library is available locally.
Efficiently executing grid search over massive parameter spaces using Python multiprocessing.
Generating and saving git-compatible patch files for Apache Druid source code.
Used to transform raw GitHub CLI output into the required reporting structure, ensuring data integrity and correct typing.
Used to query, filter, and extract metadata from GitHub PRs and Issues using the `gh` command line tool with appropriate search qualifiers and pagination limits.
Synchronizes the Python environment with specific dependency versions defined in project files to ensure numerical reproducibility.
Translating Python dynamic structures into type-safe Scala ADTs and case classes.
Parses a text file containing key-value pairs (like question IDs and question text) into a Python dictionary.
Idiomatic translation of Python constructs to Scala 2.13, including classes, interfaces, enums, and naming conventions.
How to create, apply, and verify security patches for git repositories. Use this skill when creating patches from code changes, applying patches to source code, or validating that patches correctly address vulnerabilities.
Query GitHub API for pull requests and issues within a date range, retrieving all metadata needed for metrics collection. Use this skill whenever you need to fetch GitHub PR or issue data with date filtering, especially when gathering activity reports or computing statistics across a time period.
| How to handle type variance in Scala generics when translating from Python's flexible type system. Use this whenever translating Python generic types (TypeVar with covariant/contravariant bounds) to Scala. Covers covariance (+T), contravariance (-T), and invariance for proper type safety.
| How to convert Python mutable dataclasses and enums to immutable Scala case classes, sealed traits, and sealed objects. Use when translating Python @dataclass, Enum, and mutable collection patterns to idiomatic Scala. Covers immutable-by-default patterns, copy with modifications, and sealed hierarchies.
| How to convert Python Protocol classes (structural typing) to Scala traits and type classes. Use when translating Python's @runtime_checkable Protocol patterns to Scala's nominal typing with traits. Covers trait-based abstraction, implicit type classes, and structural type emulation.
> Generate technical exploded-view posters of hardware devices using Python Pillow. Use this skill when creating engineering diagrams, exploded-view illustrations, hardware layer breakdowns, or technical documentation posters programmatically.
> Translating Python builder patterns, fluent interfaces, and factory functions to Scala. Use when converting Python classes with method chaining, __init__ with mutable lists/dicts, or builder/factory patterns to idiomatic Scala with immutable state and companion objects.
> Translating Python enums, dataclasses, and union types to Scala sealed traits, case classes, and ADTs. Use when converting Python Enum classes to Scala enumerations, Python dataclasses to Scala case classes, or Python Union/Optional types to Scala Option/Either/sealed hierarchies.
> Translating Python generics, variance annotations, protocols, and type variables to Scala type parameters, variance annotations, and traits. Use when converting Python Generic[T], TypeVar with covariant/contravariant, Protocol classes, or higher-kinded type simulations to Scala.
> How to generate a technical exploded-view hardware poster as a PNG using Python (matplotlib + Pillow). Use this skill whenever the user asks for an exploded-view diagram, hardware layer diagram, technical product poster, or engineering teardown "PCB diagram", "technical poster", "engineering poster", "teardown illustration".
> How to gather GitHub repository statistics (PRs, issues, contributors) using the GitHub REST API via curl and Python. Use this skill whenever the user asks for a community pulse, activity summary, monthly report, or repository metrics for any GitHub repo — even if they don't explicitly mention the API.
Guide for translating Python fluent builder patterns and mutable accumulator objects to idiomatic immutable Scala builders with companion objects. Use this skill when converting Python classes with method chaining (returning self), mutable state accumulation, or factory/build() methods to Scala.
Guide for translating Python generic containers (covariant/contravariant), functor/monad simulations, and JSON handling to idiomatic Scala. Use this skill when converting Python Generic[T_co], Generic[T_contra], TokenFunctor, TokenMonad, or json.dumps/json.loads patterns to Scala variance annotations, proper functional types, and Circe JSON.
Guide for translating Python Enum, Protocol, and abstract class hierarchies to Scala sealed trait hierarchies. Use this skill whenever converting Python Enum classes, runtime-checkable Protocol types, abstract base classes (ABC), or Union type aliases to idiomatic Scala sealed traits, case objects, and type classes.
How to run the General Lake Model (GLM3) for lake temperature simulation, calibrate parameters in glm3.nml, read NetCDF output with Python, and compute RMSE metrics against field observations. Use this skill whenever the user mentions GLM, lake temperature simulation, glm3.nml, or wants to calibrate lake model parameters.
How to write INDEX&MATCH, VLOOKUP&MATCH, XLOOKUP, and similar two-condition lookup formulas in Excel using openpyxl. Use this skill whenever the user needs to populate data cells using lookup functions that match on two criteria (e.g., series code AND year), especially when pulling cross-sheet data with dynamic row/column matching.
Expert guidance on using the GitHub CLI (gh) to extract pull request and issue data for specific timeframes and repositories. Use this skill whenever you need to gather metrics for community reports, activity analysis, or repository health checks.
Guidelines for translating Python dataclasses, enums, and collections to Scala.
Guidelines for translating Python functional patterns and simulations to idiomatic Scala.
Guidelines for translating Python TypeVars and Protocols to Scala Generics and Traits.
Guidelines for mapping Python standard libraries (json, datetime) to Scala equivalents (Circe, java.time).
How to rebuild Apache Druid after applying patches. Use this whenever the codebase has been modified and needs a partial or full rebuild.
How to gather PR and issue data from a GitHub repository using the gh CLI for monthly reports. Use this skill whenever you need to fetch monthly metrics from a repository.
How to process GitHub API JSON output into a structured report.json for monthly analytics. Use this whenever you have raw JSON data from the gh CLI.
How to use circe for JSON processing in Scala. Use this skill whenever translating Python json operations to Scala or working with circe libraries.
Translating Python simulated Functors and Monads to Scala Higher-Kinded Types. Use this skill whenever implementing functional programming concepts like Functor, Monad, Applicative in Scala.
Translating Python TypeVar variance to Scala. Use this skill whenever you see T_co or T_contra in Python and need to write equivalent Scala traits or classes.
The gh CLI is GitHub's official command line tool for interacting with GitHub repositories, issues, pull requests, and more. When needs to interact with GitHub repositories, issues, pull requests, and more, use this skill.
Align Python version and repo-declared dependencies (requirements.txt / environment.yml) before installing packages for NLP research code reproduction.
Guide for translating Python code to functional Scala style. Use when converting Python code involving numeric formatting, higher-order functions, decorators, closures, generators, or when aiming for idiomatic functional Scala with pattern matching, Option handling, and monadic operations.
This skill should be used when the user asks to "build", "design", "scaffold", "architect", or "plan" any system, feature, service, app, agent, pipeline, connector, or tool — especially when the request is short, vague, or underspecified. It should also be used when the user asks to "review this architecture", "what am I missing", "ask me the right questions", "poke holes in this", or requests a design review before implementation. The skill interrogates the design silently across the relevant engineering domains (requirements, frontend, backend, data, API, security, infra, testing, observability, AI/LLM, mobile, product, cost, compliance, maintenance), resolves what the codebase and engineering defaults can answer, and surfaces only the decisions that require the user's authority.
>- Maintain openInvest's docs (docs/wiki chapters + docs/wiki/adr) under Google's Open Knowledge Format (OKF). Two jobs. (1) Teach agents to maintain docs the OKF way — every doc carries a small YAML frontmatter block as the single source of truth (type, title, tags, intent, schema_source, documents); schema details link to the authoritative code instead of being copied into prose; no more hand-maintained thousand-line markdown. (2) Look docs up fast — grep the literal term FIRST; only when grep is ambiguous (hits scattered across files / synonym mismatch / zero hits) run find_docs.py to rank the owning doc by frontmatter intent, or resolve a doc's schema_source to the real code. Trigger phrases — "which doc covers X", "find the schema for PortfolioResponse", "where is GET /api/holdings documented", "docs for verdict.risk_profile", "add OKF frontmatter to this doc", "lint the wiki", "scaffold a new ADR/chapter". --repo <path> ...).
Back up / restore openInvest's local state — memory/ (holdings, strategy, user profile, committee records, dream logs) + db/ (trade ledger, job run history, market-data cache) + .env (SMTP/API credentials) + user_profile.json. All of this data is .gitignore'd with no historical versions in git, so a single accidental overwrite (e.g. slipping and running some one-off migration/init script) means real data loss — no git revert available. **Proactive trigger scenarios** — "backup invest data / 备份一下 openInvest 的数据", "my holdings/strategy look wiped / 我的持仓/策略好像被清空了", "invest data is lost / invest 数据丢了", "restore invest backup / 恢复一下 invest 的备份", before any reinstall/migration of the openInvest deployment on this machine, or right before running an unfamiliar migration/init script (back up first, then act).
>- **WORKFLOW SKILL** - First-run flow for adding Aspire to a repo. Picks `aspire new` (greenfield) or `aspire init` (existing repo), drops the AppHost skeleton, then hands off to `aspireify` for resource wiring. add Aspire to existing repo, scaffold Aspire app, bootstrap Aspire, no AppHost detected, install aspireify, generated .aspire/modules. (use aspire-orchestration), deploy/publish (use aspire-deployment), logs/traces (use aspire-monitoring), repo that already has an AppHost.