Claude Skills
The open format is called Agent Skills and works in Claude Code, Codex, Cursor and other agents — most people know it as Claude Skills.
Every Agent Skill we could find on GitHub, deduplicated by content. 79 566 files from 1 758 authors, of which 61 913 are unique — the rest is the same skill repackaged into someone else's repository. For each one: what it weighs in tokens, whether it ships runnable scripts, and which MCP servers it needs.
Load plate boundary GeoJSON and create a GeoDataFrame with proper geometry parsing. Verify column names (PlateA, PlateB) match the dataset structure. Use this skill to prepare boundary data before filtering for Pacific plate relevance.
Load plate polygon GeoJSON and parse geometries correctly. Verify the column name used for plate identifiers (e.g., 'PlateName' or similar). Use this skill to prepare plate polygon data for containment checks.
Load earthquake data from GeoJSON format and validate that it contains required fields (id, time, magnitude, latitude, longitude, place). Use this skill when initializing the analysis to ensure data integrity before processing.
Write the final result dictionary to a JSON file at `/root/answer.json` with proper formatting and field validation. Use this skill as the final step to save the analysis result.
Reproject earthquake points and boundary geometries to EPSG:4087 (World Equidistant Cylindrical) before calculating distances. Use this skill to ensure accurate distance measurements in kilometers.
Before writing final answers, validate that all required evidence has been extracted, multi-hop traversal was executed, and answers are complete against expected values.
Extract evidence from all three tiers (explicit reviewers, substantive feedback contributors from Slack and transcripts, and other identifiable contributors). Follow artifact references and traverse relationships to collect complete answer sets.
Load enterprise data from /root/DATA, identify the correct artifact version for each product mentioned in questions, and reject cross-product distractors. Apply strict 2-signal product grounding (artifact metadata + question context).
Load and parse questions from /root/question.txt, extract question IDs and their artifact/product context. Validate that all questions are correctly mapped before proceeding to data retrieval.
Count tokens consumed during data retrieval operations, validate numeric format, and write results to /root/answer.json with proper structure.
Search multiple funds' holdings data for a specific security (by CUSIP) and aggregate the total share values held by each fund manager. Use this to rank fund managers by their investment in a particular security.
Sum the market values of all holdings to derive the Assets Under Management (AUM) for a fund as of a specific report date. Use this to answer questions about fund size in a given quarter.
Load holdings for the same fund in two different quarters, match positions by security identifier, and calculate the change in shares and market values. Use this to identify which securities received increased investment between reporting periods.
Inspect the actual holdings dataset to understand its schema, field names, and data patterns before applying filters. Use this to identify the correct field name that distinguishes equity securities from bonds, options, warrants, and other non-stock instruments.
Remove non-equity securities (bonds, options, warrants, preferred shares, funds) from holdings data, keeping only common stock positions. Use the correct security type field identified from the raw data structure inspection.
Search the COVERPAGE dataset using fuzzy matching to locate a specific fund by name and extract its accession_number for subsequent analysis. Use this when you need to identify a fund's filing by partial or approximate name matching.
Retrieve and load the complete holdings dataset for a specific fund using its accession_number. Use this to access position-level details needed for AUM, stock count, and comparative analysis.
Find the CUSIP identifier for a specific security (e.g., Palantir) by searching across all holdings data or a security master file. Use this when you need to locate a specific stock across multiple fund positions.
Confirm that the accession_number retrieved corresponds to the correct quarter and report date before using it for analysis. Use this to prevent analyzing data from the wrong quarter.
Generate proper git-compatible patch files that address the empty key validation and JavaScript filter disabling vulnerabilities, then apply them to the Druid 0.20.0 source repository.
Configure and enforce a security policy that completely disables JavaScript filter evaluation in Apache Druid, preventing arbitrary code execution through the javascript filter type even if structural validation is bypassed.
Validate and sanitize raw JSON input at the point where it enters Jackson's deserialization pipeline, before any ObjectMapper.readValue() call processes it, to prevent bypass attacks using empty keys.
Find the exact code locations where user-supplied JSON is deserialized into DimFilter and other security-sensitive objects in Apache Druid's indexing pipeline, to identify where raw input validation must occur before Jackson processes it.
Compute the average number of days from PR creation to merge for all merged PRs in December 2024, using correct timestamp parsing and filtering.
Compile gathered PR and issue metrics into a properly formatted JSON file at /app/report.json with the exact required structure and data types.
Determine which person opened the most pull requests in December 2024 by analyzing author data from the PR query results.
Fetch all issues created in December 2024 from cli/cli repository using correct date filtering, and identify bug-related issues based on label substring matching.
Fetch all pull requests created in December 2024 from cli/cli repository using the GitHub CLI, applying correct date range filtering to ensure accurate total count and contributor identification.
Use when starting a new project to verify Python version requirements declared in configuration files. This prevents version mismatches before environment setup.
Use when implementing the `simpo_loss` function in SimPOTrainer class. Extract loss computation logic from the paper and translate it to PyTorch code that accepts the expected tensor inputs.
Use after activating Python 3.10 environment to install project dependencies without version conflicts. This ensures all packages are compatible with the target Python version.
Use to execute the unit test within the Python 3.10 virtual environment after implementing the loss function. This validates the implementation against fixed input tensors.
Use when you need to switch from an incompatible Python version to Python 3.10 before project setup. This ensures the correct runtime environment for dependency installation and test execution.
Use this skill to create the regex patterns and replacement values needed to fill placeholders in a Word template. Organize patterns for easy iteration and ensure proper escaping.
Use this skill to safely find and replace placeholder text in Word document paragraphs at the run level. This handles cases where placeholder text is split across multiple runs, which is common in Word documents and breaks simple string replacement.
Use this skill to read employee/candidate data from a JSON file and validate that all required fields exist before attempting document generation. This prevents placeholder errors caused by missing data.
Use this skill to handle conditional content blocks marked with {{IF_CONDITION}}...{{END_IF_CONDITION}} in Word documents. Keep or remove the entire block based on a condition, and clean up the marker text. Apply this during paragraph processing, not as a separate pass, to avoid structural issues with modified paragraphs.
Use this skill to write a modified python-docx Document object back to a .docx file, handling file paths and permissions correctly.
Use this skill when you need to find and process text in Word documents beyond just `doc.paragraphs`. Include tables, headers, and footers to ensure no content is missed.
Use this skill to analyze extracted text content from documents and classify them into the correct subject folder based on keyword matching and content analysis.
Use this skill to extract text and structure from Word documents (.docx files) to determine their subject for classification into the correct folder.
Use this skill to extract the full text, title, abstract, and keywords from PDF files to determine their actual subject matter. Essential for content-based sorting when PDF filenames may be arXiv IDs or other non-descriptive identifiers.
Use this skill to extract text, slide titles, and content from PowerPoint presentations to accurately determine their subject matter for classification.
Use this skill at the start to scan the source directory, identify all files, create a processing plan, and establish the destination folder structure.
Use this skill to systematically track all files before and after sorting to ensure no files are lost, duplicated, or left out during the organization process.
Core principles for translating Python code to idiomatic Scala, including paradigm shifts from procedural/OOP to functional programming, type system differences, and structural refactoring strategies.
Functional programming patterns in Scala for data transformation, collection processing, and batch operations suitable for distributed systems.
Scala-specific naming conventions, code organization patterns, and style guidelines that differ from Python conventions.
Scala's type system features, testing patterns, and integration with test specifications for ensuring correctness of translated code.
How to structure abstract base classes, trait hierarchies, and inheritance patterns in Scala for the tokenizer domain.
Matches each meeting request against available calendar slots, respecting date and time constraints, and prioritizing flexible (blue) blocks for overwriting. Selects the earliest available slot that accommodates the meeting.
Parses email messages from JSON input file to extract meeting duration, date constraints, time-of-day constraints, and recipient contact information for each meeting request.
Extracts calendar structure, time slots, existing appointments, and timezone from a PDF calendar document. Maps pixel positions to actual times using axis labels, identifies appointment blocks with their colors, and determines which dates are covered by the calendar.
Use Node.js file system operations to recursively copy the entire `/root/data/indiv-stock/` directory (including all subdirectories and files) to `/root/output/data/indiv-stock/` to preserve the original directory structure for the web app
Create CSS styling for `.selected` (bubbles), `.highlighted` (table rows), and `.tooltip` classes to provide clear visual feedback for user interactions
Create a utility function to reliably detect ETF entries by checking for null/undefined marketCap values, enabling conditional tooltip display and styling
Create and manage a D3 tooltip element that displays on hover for non-ETF stocks with dynamic positioning based on mouse movement
Load CSV data and verify all stock entries contain the required `ticker` field with non-empty string values before using in selection matching logic
Implement click handlers on both bubble chart and data table that maintain synchronized highlighting/selection state across both visualizations
Set up and validate the GLM environment for Lake Mendota simulation. Use this skill to verify the configuration file exists, inspect current calibration parameters, and confirm all input data (meteorological forcing, field observations, initial profile) are accessible before running calibration.
Claude Skills — questions
Answers built from the skills we actually parsed.