1230 skills published by cxcscmu across 1 repository. Together they weigh 1 426 712 tokens — that is what loading all of them at once would cost you in context.
1230 skills 1 426 712 tokens total
How to analyze 13F filings. Use this skill to process COVERPAGE.tsv, INFOTABLE.tsv, and metadata for hedge fund holdings and AUM.
Perform various data analysis on SEC 13-F and obtain some insights of fund activities such as number of holdings, AUM, and change of holdings between two quarters.
Perform various data analysis on SEC 13-F and obtain some insights of fund activities such as number of holdings, AUM, and change of holdings between two quarters.
Perform data analysis on SEC 13-F filing datasets (TSV format) to obtain insights about fund activities such as number of holdings, AUM, and change of holdings between two quarters. Use this skill whenever analyzing hedge fund portfolios, comparing quarterly holdings, or working with SEC EDGAR 13F data files.
Compare holdings between two quarters or find top holders of a specific stock.
Analyze SEC 13-F filings data including AUM, holdings count, and cross-quarter comparisons using TSV files.
Extract AUM, holdings count, and detailed holding information for a specific fund.
A skill for parsing and analyzing SEC Form 13F TSV files, including COVERPAGE, INFOTABLE, and SUMMARYPAGE, using pandas.
Analyze SEC 13F fund holdings data given an accession number. Use this skill when you have an accession_number and need to extract fund details including AUM, number of holdings, and detailed position data. Works with Q2 and Q3 2025 filings.
Search for hedge funds in SEC 13F filings by fuzzy name matching. Use this skill whenever you need to find a fund's accession number by name (e.g., "Renaissance Technologies", "Berkshire Hathaway"). Returns accession_number to use with fund analysis.
Search for fund accession numbers and stock CUSIPs using fuzzy matching.
Using map projections to calculate real-world distances in meters or kilometers accurately.
Mine Slack data for embedded URLs, mentioned products, competitive intelligence, and cross-referencing with external data sources.
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.
Guidelines for analyzing 13F filings, finding fund accession numbers, calculating AUM, and counting exact stock holdings by utilizing existing scripts and correctly excluding options.
Retrieve a fund's AUM, stock holding counts, or compare investment changes between two quarters.
Parse the calendar PDF to identify existing appointments, flexible blue slots, and the 15-minute grid coordinate mapping.
Identify and rank the top fund managers holding a specific stock CUSIP in a given quarter.
Use this to structure the final output into the required JSON schema, calculating precise token usage based on the retrieved context.
Anthropic's official brand color palette, typography, and design tokens for use in branded materials.
Anthropic's official brand color palette, design tokens, and typography standards for consistent brand application.
Use this skill when you need to apply Anthropic's official brand color palette to any design artifact, poster, or visual. Contains the correct HEX values for all brand color tokens as of 2024.
Defines the official, sanctioned Anthropic brand palette and HEX mapping for all technical documentation and hardware visualization assets.
Guidelines for applying Anthropic's brand identity, including color palettes, typography, and visual principles. Use this skill whenever creating branded assets, posters, or UI designs for Anthropic.
Guidelines for applying Anthropic's visual identity and brand tokens in technical and marketing artifacts.
How to apply Anthropic's official brand colors, typography, and design guidelines. Use this skill whenever the user mentions Anthropic styling, corporate colors, brand accents, or visual formatting for Anthropic.
Reference guide for Anthropic's official brand colors, typography, and design standards. Use this skill whenever creating branded materials, posters, or visual assets that need to follow Anthropic's corporate identity guidelines. Includes color palette, typography standards, minimalist design principles, and brand application rules.
Provides the official Anthropic brand color palette and typography tokens. Use this skill whenever you need canonical HEX values for Anthropic brand colors or the correct heading font name for any Anthropic design artifact.
> Authoritative reference for Anthropic's official brand color palette, typography, and design tokens. Use this skill whenever creating any Anthropic-branded artifact, poster, UI, or document that must apply official HEX values for background, casing, "corporate dark", "identity light", "primary accent", "secondary accent", "tertiary accent", "brand tokens", "muted mid gray", "Anthropic typography".
Anthropic official brand color palette, typography standards, and design tokens for consistent brand application.
Use this skill when selecting and applying fonts for Anthropic brand materials. Specifies the official heading and body typefaces with correct fallback chains.
Specifies the sanctioned typefaces for Anthropic internal engineering handbooks and technical posters.
Step-by-step instructions for creating and applying patches to fix the JavaScript RCE vulnerability in Apache Druid 0.20.0. Covers inspecting actual source code patterns, creating correct sed replacements or patch files, and verifying the fix. Use this when you need to patch and build Druid.
Understanding the CVE in Apache Druid 0.20.0 where authenticated attackers can execute arbitrary code via JavaScript payloads. The vulnerability exploits @JacksonInject with empty key "" to override JavaScriptConfig and enable JavaScript execution even when disabled. Use this skill to understand the attack vector and plan the fix.
Security patching for Apache Druid - covers JavaScript execution vulnerabilities, sampler endpoint protection, and filter validation patterns.
Security practices and vulnerability patching for Apache Druid, focusing on JavaScript sandbox configuration.
Applying patches to the Druid source code and performing a targeted Maven build.
Multi-hop search over enterprise artifacts to find key reviewers, approvers, feedback contributors, authors, product reports, competitor insights, and demo URLs. Prevents cross-product leakage and prevents treating meeting participants as reviewers.
Look up arxiv paper metadata (title, abstract, subject) from arxiv IDs to classify papers by topic without reading full PDFs.
Discovers PDF, DOCX, and PPTX files in a directory (handling hidden characters and extensions robustly), extracts their text, determines their subject, and moves them into organized folders.
Organize large collections of files into categorized folders. Use this skill when you need to move or copy 100+ files into multiple destination folders based on classification data. Handles PDF, DOCX, PPTX and other file types while preserving original filenames and content.
Converts all extracted keyframe images in a directory from RGB to grayscale and overwrites the original files.
Efficiently organizes large numbers of files into directories.
Guidelines for Anthropic brand colors, typography, and aesthetic. Use this skill whenever branding, color application, or corporate design standards are relevant to a project.
Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
Track and manage travel budget across accommodations, meals, and activities
Identify bug reports by checking if any issue label contains the substring "bug" (case-insensitive matching). Use this skill when categorizing GitHub issues as bugs vs. features, filtering defects, or generating quality/reliability metrics.
Use when building a D3.js v6 bubble chart with force simulation, sector clustering, collision detection, tooltips, and interactive highlighting. Handles ETFs (no marketCap/sector) as a separate cluster.
Use when building an HTML data table that syncs highlighting with a D3 bubble chart on click interactions in both directions.
Create a definitive lookup table mapping each character in your poem to its Mandarin pinyin, tone number (1–4), and 平仄 classification (平=level/rising tones 1–2; 仄=falling/entering tones 3–4). Use only authoritative sources like Xinhua Dictionary. This table serves as your verification anchor before composition and prevents tone misclassification errors.
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.
invoke this skill when you need to perform database search for travel planning. This skill provides some useful pre-packaged tools to look up accommodations, attractions, cities, driving distance, flights, and restaurants from the bundled dataset.
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.
Compute the average number of days from PR creation to merge for all merged PRs in December 2024, using correct timestamp parsing and filtering.
Combine all Pacific plate boundary geometries using `.unary_union` and calculate the distance from each earthquake to this combined boundary geometry. Returns the minimum distance in kilometers for each earthquake.
Processes JSON data from GitHub Search results to compute specific repository health metrics including average merge time, top contributors, and bug resolution counts.
Compute the distance from each Pacific plate earthquake to the unified plate boundary.
Extract appointments from calendar.pdf. Use whenever you need to determine availability from the calendar.
Parse visual calendar PDFs to extract existing appointments with their time ranges, colors, and availability status. Use this skill whenever processing calendar images/PDFs to determine busy/free slots, even if the user just says "check my calendar" or "find available time".
Techniques for parsing visual calendar PDFs to extract appointment blocks, free slots, and time boundaries.
Logic for calculating meeting slots based on constraints and availability.
Parse a visual calendar PDF to extract existing appointments and find earliest available meeting slots. Handles blue (low-priority/flexible) blocks as overwritable free time. Use when given a calendar image/PDF and meeting requests that need to be scheduled without conflicts.
Find available time slots in a calendar and schedule meetings while respecting constraints
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.
Performs efficient parameter optimization using a heuristic search or scipy.optimize to satisfy RMSE constraints within fixed parameter ranges.
Understand the structure and fields of the California Small Claims Court Form SC-100
Use this skill when you need to fill out the California Small Claims Court form SC-100. It maps the form's PDF field names to their meanings and expected values.
How to fill out the California Small Claims Court SC-100 form, including field mapping and required vs. optional fields.
Use this skill to map specific natural language case details to the legal requirements of the SC-100 form.
How to fill out California Small Claims Court forms (SC-100 and related). Use this skill whenever the user needs to complete a California small claims court filing, fill in plaintiff/defendant information, describe a claim, or prepare court documents for small claims cases.
Guidance for filling California SC-100 Small Claims forms. Use this skill when filling out, validating, or processing California judicial council forms, specifically the SC-100.
California Small Claims Court SC-100 form field mapping and filling guide. Use this skill when filling out California SC-100 Plaintiff's Claim forms, understanding small claims court procedures, or mapping case details to SC-100 form fields.
California SC-100 Small Claims Court form field mapping and filling guide.
Use this skill when you need to find, install, or configure a Python 3.10 environment on the system. Checks for existing python3.10 binary, installs if missing, and sets up pip for that version.
Use when starting a new project to verify Python version requirements declared in configuration files. This prevents version mismatches before environment setup.
How to compose a seven-character regulated verse (七言律诗) in Classical Chinese, including tonal patterns, rhyme schemes, and structural requirements.
Explains the rules, forms, and modern rhyming conventions for composing a seven-character regulated verse (Qi Lu).
How to compose a seven-character regulated verse (七言律诗) in Classical Chinese poetry. Use this skill whenever the user asks to write classical Chinese poetry, a regulated verse, a 律诗, or any structured poem with tonal rules, rhyme schemes, and parallelism requirements. Covers structure, tonal patterns, rhyming (based on modern Mandarin), antithesis couplets, and thematic guidance.
Modern Mandarin rhyme groups for classical Chinese poetry composition, mapping finals to rhyme categories.
Guidance on using classical Chinese poetic imagery for themes like war and peace. Use this skill when writing traditional Chinese poetry to ensure appropriate vocabulary and evoke classical aesthetics.
Compose classical Chinese poetry on peace themes using authentic imagery, perspective shifts, and the voice of ordinary people experiencing war's aftermath.
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.
Categorizes a document into one of five subjects (LLM, trapped_ion_and_qc, black_hole, DNA, music_history) based on an expanded technical keyword dictionary. It prioritizes the beginning of the text (titles and abstracts) where subject density is highest.
How to write multi-line text files using command line interfaces.
Professional methodology for transforming raw repository activity into structured community pulse reports. Use this skill when you need to calculate metrics like merge times, contributor rankings, and bug resolution rates for meeting-ready summaries.
Compares holding changes between two quarters for a specific fund to determine investment increases.
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.
How to compile PR and issue statistics into a report.json file for a GitHub repository community pulse report, using jq to build the final JSON structure.
Fill in your poem position-by-position, starting with the 4 rhyme characters (lines 2, 4, 6, 8). For each remaining position, select a character, verify its pinyin and tone in your reference table, confirm it matches the required 平/仄 classification, then move to the next position. Never move to a new line until all 7 positions of the current line pass verification.
Calculates RMSE between simulated and observed data using exact datetime matching and integer depth binning based on simulation start date 2009-01-01.
Parse scheduling constraints from a email text.
Classify documents by subject using keyword matching and text analysis
Processes all extracted keyframes by converting them to grayscale, then counts coins, enemies, and turtles in each frame using template matching. Generates a CSV file with frame-by-frame object counts. Use this as the main analysis pipeline after keyframe extraction.
Convert all extracted keyframe PNG images from RGB to grayscale inplace, overwriting the original files. Also convert template images (coin.png, enemy.png, turtle.png) to grayscale. Use this before running object counting.
Use this skill to convert extracted keyframe PNG images to grayscale in-place using Python3 and PIL/Pillow. Only convert keyframe images, NOT template images (coin.png, enemy.png, turtle.png).
Use when you need to create output directory structures and copy files into them for web app deployment.
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
Count coins, enemies, and turtles in each keyframe using the provided count_objects.py script with threshold=0.9 and dedup_min_dist=3. Parse stdout for integer counts. Write results to /root/counting_results.csv.
Use this skill to count coins, enemies, and turtles in grayscale keyframe images using OpenCV template matching with a provided count_objects.py script. Includes robust output parsing and fallback to direct template matching if the script is unavailable.
Counts occurrences of specific objects (coins, enemies, turtles) in a frame using a template matching script with optimized parameters.
Count the number of distinct stocks (equity positions only) held by Renaissance Technologies. Filters to SH (share) type only and excludes options/derivatives by checking PUTCALL column. Use this specifically for Q2 answer about Renaissance stock count.
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.
Searches all funds within a specific quarter to rank holdings for a target security by CUSIP.
Loading and parsing CSV files with D3.js, data transformation, and handling missing values
Aggregate object counts into a structured CSV file.
Output vulnerability reports as a formatted CSV file.
Creating structured CSV reports for security findings.
Formatting security audit findings into a standardized CSV format for reporting and compliance.
Implementation of a custom distance metric for DBSCAN clustering using scipy and sklearn.
Custom distance metric implementation for use with clustering algorithms like DBSCAN.
Define custom distance/similarity metrics for clustering and ML algorithms. Use when working with DBSCAN, sklearn, or scipy distance functions with application-specific metrics.
Define custom distance/similarity metrics for DBSCAN clustering with sklearn, using weighted Euclidean distances.
Logic to parse nested security database objects into a scalar CVSS score for the final CSV report.
Extract CVSS scores from Trivy JSON output.
How to generate security audit reports in CSV format. Use this skill whenever you need to produce a `/root/security_audit.csv` report.
Extract CVSS (Common Vulnerability Scoring System) scores from vulnerability data sources with proper fallback handling. This skill covers understanding CVSS v3, handling multiple score sources (NVD, GHSA, RedHat), implementing source priority logic, and dealing with missing scores in security reporting.
Extract and handle CVSS scores from multiple vulnerability data sources (NVD, GHSA, RedHat) with proper fallback priority.
Extract CVSS scores from vulnerability data sources with proper fallback handling across NVD, GHSA, and RedHat sources.
> How to build a D3.js v6 force-directed bubble chart with sector clustering, size encoding, color legends, tooltips, and interactive selection. Use this skill whenever the user wants a bubble chart, force simulation, cluster layout, or interactive SVG circles with D3.
Synchronize interactions between D3 visualizations and HTML tables, enabling click-to-highlight and hover effects across both elements. Use this skill when you need chart and table elements to stay in sync - clicking a bubble highlights its table row, clicking a row highlights the bubble, and/or hovering shows related data across both. Essential for exploratory dashboards where users need to see data from multiple perspectives simultaneously.
Add a categorical color legend to a D3 chart using colored rectangles or circles with text labels, supporting both SVG-inline and HTML overlay styles.
How to implement cross-highlighting between D3.js visualizations and HTML Data Tables. Use this skill whenever the user wants to connect a chart (like a bubble chart or scatter plot) with an HTML table, so clicking or hovering one updates the other.
Load and parse CSV data with D3.js v6 using d3.csv() and d3.autoType for local file serving.
Efficiently binding data to DOM elements and handling user interactions like hover and click in D3.js.
Loading CSV data, formatting currency/large numbers, and implementing tooltips in D3.
> How to build an interactive HTML data table driven by D3.js v6 with sortable columns, row highlighting, cross-component selection, and formatted values. Use this skill when building tabular displays alongside D3 charts, especially when the table needs to stay in sync with chart interactions.
Build interactive HTML data tables with D3.js v6, including row highlighting and click-based selection synced with charts.
Guide for creating clustered bubble charts using D3.js force simulations (v6+), including collision and categorization.
Create force-simulation bubble charts with D3.js v6, including sector clustering, collision avoidance, tooltips, and legends.
Build a force-simulation bubble chart in D3.js v6 where bubbles are sized by a numeric value, colored by category, and clustered by category using forceX/forceY. Covers deterministic layout, collision, and tick-based settling.
How to create a force-directed bubble chart in D3.js (v6+). Use this skill whenever the user asks to build a bubble chart, cluster bubbles by category, or use d3.forceSimulation to position SVG circles without overlap.
Creating bubble clusters in D3.js using force simulations.
Techniques for creating clustered bubble charts using D3 force simulations (v6).
D3.js force simulation for creating interactive bubble charts with clustering, collision detection, and physics-based positioning
Essential D3.js v6 concepts including selections, scales, SVG basics, and data binding for building interactive visualizations
D3.js techniques for tooltips, hover effects, click handlers, and cross-filtering between visualizations
> Build interactive data tables with D3.js that are linked to other D3 visualizations. Use this skill when building HTML tables with D3 that need click-to-highlight interaction, interactive table, linked table and chart, click to highlight.
Build a sortable, highlightable HTML data table linked to a D3 chart so clicking a chart element highlights the matching table row and vice versa.
Building dynamic tables with D3 and implementing bidirectional interactions with SVG elements.
HTML/CSS/JS patterns for creating tooltips, conditional interactions based on data attributes, and cross-highlighting elements across different views (like a chart and a table).
Build deterministic, verifiable data visualizations with D3.js (v6). Generate standalone HTML/SVG (and optional PNG) from local data files without external network dependencies. Use when tasks require charts, plots, axes/scales, legends, tooltips, or data-driven SVG output.
Guide for linking D3.js SVG visualizations with DOM elements like HTML tables for bidirectional interactivity (hover, click, highlight).
Use this skill for D3.js (v6) force-directed bubble charts and linked data tables. Always use this when tasked with financial data visualization using D3.js.
Creating data-driven HTML tables using D3.js.
Using Python and Pandas to analyze large CSV datasets and filter based on specific criteria like budget, location, and amenities.
This skill covers computing RMSE metrics from observational and simulated water temperature data.
Use this skill to understand the database file structure and how to search for Ohio cities, restaurants, accommodations, attractions, and distances in the provided dataset files for trip planning.
Filter accommodations, restaurants, and attractions by travel requirements
How to filter tabular datasets. Use this skill whenever you need to process or filter CSV files, tabular data, or databases to find records that match specific criteria such as location, price, category, or flags (like pet-friendly).
Ensures the generated output strictly adheres to the required JSON schema.
Load and parse CSV/TXT files from travel database for itinerary planning
Advanced data retrieval in Excel using INDEX and MATCH.
Matching observation data to simulation output with exact datetime and depth binning
Greedy matching of centroid points to expert annotations based on standard Euclidean distance.
Provides methods to search, parse, and filter local CSV files in /app/data/.
Filter CSV data (restaurants, accommodations, attractions) based on criteria like city, cuisine, budget, and pet-friendliness.
Used to transform raw GitHub CLI output into the required reporting structure, ensuring data integrity and correct typing.
How to query CSV datasets in /app/data to extract information like accommodations, attractions, and restaurants. Use this skill whenever you need to look up data from files in the /app/data directory.
Provides strategies for traversing and filtering hierarchical JSON datasets stored in flat files.
Instructions for querying the provided datasets to ensure constraints regarding pet-friendly lodging, specific cuisines, and valid locations are met.
Use INDEX combined with MATCH to retrieve data from a source table based on two criteria (row and column headers).
Format dates and times according to specific requirements for meeting confirmations
Efficiently computing DBSCAN with a custom weighted (anisotropic) distance metric using coordinate scaling, avoiding the overhead of slow custom distance functions.
Define custom distance metrics for DBSCAN clustering. Use this skill whenever a task requires clustering points with unequal weighting or application-specific distances.
Implement DBSCAN clustering with a custom weighted Euclidean distance metric controlled by shape_weight parameter. Use this skill to cluster citizen science point annotations on Mars cloud images.
> How to run DBSCAN clustering with a custom anisotropic distance metric using sklearn and scipy. Use this skill whenever the user needs to cluster spatial points with a weighted or shape-adjusted distance, such as attenuating x vs y distances differently, or when DBSCAN needs a non-Euclidean metric defined as a callable. Covers cluster centroid computation and noise-point handling.
Run DBSCAN clustering with a custom distance metric using sklearn, including how to define weighted Euclidean metrics and extract cluster centroids.
Implements DBSCAN with a weighted Euclidean distance metric.
Implementing custom distance metrics for DBSCAN in scikit-learn for specialized coordinate-based clustering.
How to run DBSCAN with a custom anisotropic distance metric using sklearn, including defining callable metrics and computing cluster centroids from labeled output.
Implement DBSCAN clustering with custom distance metrics using scikit-learn's pairwise_distances.
Implementing a weighted Euclidean distance metric for DBSCAN to account for anisotropic spatial features.
Ensure vulnerability records are deduplicated and ordered according to ground-truth requirements.
Create CSS styling for `.selected` (bubbles), `.highlighted` (table rows), and `.tooltip` classes to provide clear visual feedback for user interactions
How to perform security audits on package-lock.json. Use this skill whenever you need to identify HIGH or CRITICAL vulnerabilities in project dependencies.
Analyze /root/package-lock.json to identify HIGH and CRITICAL vulnerabilities using automated security audit tools and database lookups.
> How to generate a design_parameters.json file containing the applied HEX color values and heading font name used in a branded poster or artifact. Use this skill whenever a task requires outputting a machine-readable record of design tokens "applied hex values", "color parameters json", "brand token json output".
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.
Select restaurants across multiple cuisine types (American, Mediterranean, Chinese, Italian) that meet quality standards and budget. Use this when meal planning requires variety across different culinary traditions.
Classify documents by subject matter. Use this skill when you need to determine which category (LLM, Trapped Ion & Quantum Computing, Black Hole, DNA, Music History) a PDF, DOCX, or PPTX file belongs to based on its content. Analyzes titles, abstracts, keywords, and text content to accurately categorize documents.
Logic for categorizing documents into subjects based on keyword matching.
How to classify and organize documents (PDFs, DOCX, PPTX) into categories based on their content. Use this skill whenever the user mentions organizing, sorting, or classifying documents into subjects or folders, even if they don't explicitly ask for it.
Robustly extracts text from PDF, DOCX, and PPTX files while maintaining structural integrity for multi-column layouts and nested elements.
Extract author, reviewer, and feedback information from structured documents and their associated discussions.
End-to-end pipeline for extracting, classifying, and organizing documents by subject
Organizes mixed document files (PDF, PPTX, DOCX) into subject-based folders by analyzing content. Use this skill when sorting, categorizing, or organizing documents into topic folders.
Extracts text from PDF, DOCX, and PPTX files using Python.
Word document manipulation with python-docx - handling split placeholders, headers/footers, nested tables
Handle conditional sections in Word templates with IF/END_IF markers, removing or keeping content based on data values.
Handle {{IF_CONDITION}}...{{END_IF_CONDITION}} conditional blocks in Word templates — keep content and strip markers when true, remove entire block when false.
Manually processes non-standard conditional markers like `{{IF_VARIABLE}}` and `{{END_IF_VARIABLE}}` in a Word document. It identifies blocks of text to either retain (removing markers) or delete (removing the block) based on data.
Handles reading, populating, and saving .docx files using the python-docx library. Use this skill for any tasks involving template filling or modifying Word documents.
Manipulate Word documents using python-docx, including text replacement and handling conditional sections.
Robustly replace {{PLACEHOLDER}} tokens in Word documents, handling split runs across paragraphs, tables, headers, and footers.
Extract text from DOCX and PPTX files for content analysis
Extract text from DOCX and PPTX files using python-docx and python-pptx for content analysis.
Replaces placeholders in a Word document across all sections, including headers, footers, body paragraphs, and deeply nested tables. It uses paragraph-level replacement to ensure placeholders split across multiple runs are correctly identified.
> Fill Word document (.docx) templates that use placeholder syntax like {{PLACEHOLDER}}. Handles split placeholders (where Word splits a placeholder across multiple XML runs), conditional sections ({{IF_X}}...{{END_IF_X}}), and preserves formatting. Use this skill whenever the user asks to fill a Word template, generate a document from a template, or replace placeholders in a .docx file.
How to open a .docx Word document template with python-docx, replace placeholder tags like {{PLACEHOLDER}} in all document locations (body, headers, footers, tables including nested tables), handle conditional sections, and save the result.
Robustly fill Word (.docx) templates with JSON data. Handles split placeholders, nested tables, headers/footers, and conditional logic like IF/END_IF blocks. Use this skill whenever you need to generate professional documents from templates.
Strategies for programmatically modifying .docx files, handling placeholders, and performing conditional text removal.
Use when you need to obtain the D3.js v6 minified library file and save it locally for a web app.
Securing Jackson deserialization in Druid to prevent user-supplied JSON keys from overriding system-injected security configurations.
Securing Apache Druid's JavaScriptConfig deserialization. Use this skill whenever patching or securing Jackson deserialization in Druid, especially regarding the empty key ("") bypass.
How to patch the Apache Druid 0.20.0 JavaScript sandbox bypass vulnerability. Use this skill when fixing CVE in Druid where authenticated attackers can execute arbitrary code through malicious JavaScript payloads via the sampler endpoint. The vulnerability allows empty key "" in filter specifications to bypass JavaScript security settings.
Apache Druid JavaScript RCE vulnerability (CVE-2021-25646) fix via @JacksonInject hardening and constructor validation.
How to patch Apache Druid JavaScript RCE vulnerabilities (CVE-2021-25646 and similar). Use this skill whenever patching Druid JavaScript filter/aggregator security bypass vulnerabilities, when the @JacksonInject config can be overridden via JSON, or when handling arbitrary code execution via JavaScript in Druid sampler/query endpoints.
Specific guidance for securing JavaScript execution in Apache Druid. Use this when working with JavaScriptDimFilter, JavaScriptExtractionFn, JavaScriptAggregatorFactory, and other JS-enabled components.
Securing Apache Druid's JavaScript execution engine against code injection and security bypass attacks.
Systematic identification of all Apache Druid components utilizing JavaScript to ensure comprehensive patching of CVE-2021-25646.
Patching Apache Druid JavaScript injection vulnerability (CVE-2021-25646). Use this skill when fixing Druid's JavaScript execution bypass where empty JSON keys override @JacksonInject JavaScriptConfig to enable JavaScript execution despite being disabled server-wide.
How to build Apache Druid with Maven, including how to skip OOM-prone modules, skip code quality checks for patched files, and build only specific modules. Use this skill when building Druid from source, when rebuilding after applying security patches, or when Maven build fails due to memory or code quality check issues.
How to rebuild Apache Druid after applying patches. Use this whenever the codebase has been modified and needs a partial or full rebuild.
Creating, applying, and verifying patches for Apache Druid using Maven with specific flags to bypass non-essential checks.
How to fix the Apache Druid JavaScript sampler vulnerability. Use this skill when patching Druid code to block arbitrary JavaScript execution.
Techniques for identifying and patching vulnerabilities in Apache Druid, specifically focusing on Jackson deserialization and JavaScript security. Use this skill when dealing with CVEs related to RCE or security bypasses in Druid.
> How to parse USGS GeoJSON earthquake data, filter by location relative to tectonic plates, and find the earthquake furthest from a plate boundary. Use this skill whenever the user asks to find earthquakes within a plate, compute distances from plate boundaries, or analyze USGS earthquake catalog data with GeoPandas.
> Calculate geodesic distances between earthquake points and plate boundaries using GeoPandas projections. Use this skill when computing distances in kilometers between geographic points and linestring/polygon boundaries, especially for finding the furthest earthquake, geodesic distance, plate boundary distance.
Converting earthquake timestamps from USGS GeoJSON format (epoch milliseconds) to ISO 8601 format for output.
Use this skill when you need to parse meeting schedule request emails from a JSON file, extract meeting duration, date/time constraints, sender information, and message IDs. Handles various natural language patterns for expressing meeting preferences.
Extract meeting request details from JSON input. Use whenever you process meeting requests.
Generate formatted meeting reply emails and save them as .txt files, then log results to results.json. Use when you need to respond to meeting scheduling requests with proposed time slots.
Extracts meeting requirements from /root/test_input.json, handling variable constraints and field parsing.
Parse meeting request emails to extract duration and time constraints, then find the earliest available time slot on a calendar.
Workflow for parsing meeting request emails, matching constraints to calendar availability, and generating reply files.
Strategies for reading and indexing diverse enterprise data formats located in a flat directory or specific path.
Core skill for retrieving information from enterprise data files (JSON, JSONL, CSV, Parquet, Markdown, etc.) located at /root/DATA, answering questions from /root/question.txt, and writing structured answers to /root/answer.json. Handles multi-hop reasoning, cross-referencing, and entity resolution across enterprise documents.
Techniques for retrieving structured information from enterprise Slack/document JSON data files.
How to extract and format enterprise product data for specific queries. Use this skill whenever the user asks to retrieve employee IDs, report authors, competitor URLs, or insights from JSON enterprise product or metadata files.
Retrieve and aggregate information across multiple enterprise data sources
Use this to search, filter, and navigate enterprise artifacts (/root/DATA) to answer specific questions, ensuring cross-product isolation and multi-hop link traversal.
Search and query enterprise JSON data to find specific information like employee IDs, document references, URLs, and insights. Use this skill when you need to locate answers to business questions such as finding authors of reports, team members with specific insights, or shared URLs. Handles multi-step queries, filtering, and deduplication of results.
Procedures for setting up the environment for research projects involving Python, PyTorch, and NLP models. Use whenever environment requirements (environment.yml) are present.
Procedures for setting up the python environment, installing dependencies, and verifying installations.
Creates the directory structure, copies data, and writes the specific JS/CSS/HTML files required for the web application.
Set up Python environment for PyTorch-based NLP projects with transformers and alignment training. Use this skill when initializing project environments, managing dependencies from environment.yml files, installing required packages, and ensuring CUDA/device compatibility. Essential for reproducible machine learning research requiring specific package versions.
Synchronizes the Python environment with specific dependency versions defined in project files to ensure numerical reproducibility.
Before writing final answers, validate that all required evidence has been extracted, multi-hop traversal was executed, and answers are complete against expected values.
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.
How to perform two-dimensional data lookups in Excel using functions like INDEX & MATCH or VLOOKUP & MATCH based on both row and column criteria.
How to write advanced Excel formulas (INDEX/MATCH, XLOOKUP, VLOOKUP, SUMPRODUCT, Percentiles, and other statistical functions). Use this skill whenever you need to populate Excel cells with advanced lookup or statistical formulas, or when calculating weighted averages in Excel.
Techniques for statistical analysis in Excel including weighted means, percentiles, and rounding.
How to perform data lookups in Excel using INDEX and MATCH. Use this skill when needing to extract data from a source table based on two conditions (e.g., Row header and Column header).
Use standard Excel functions to calculate basic statistical measures across a range of values.
Calculate financial metrics in Excel including percentages of GDP, percentage changes, and weighted averages. Use this skill when working with economic data, calculating net exports as percentage of GDP, or deriving financial ratios from raw data.
> How to use INDEX&MATCH for two-dimensional lookups in Excel via openpyxl. Use this skill whenever building Excel formulas that look up values by matching both a row criterion and a column criterion from a data table — e.g., matching a series code (row) and a year (column). Trigger when the user mentions VLOOKUP&MATCH, HLOOKUP&MATCH, XLOOKUP&MATCH, INDEX&MATCH, or two-condition lookups.
Using INDEX&MATCH (single and dual condition) for dynamic lookups across rows and columns in Excel, including cross-sheet references.
Using INDEX/MATCH formulas in Excel for two-condition lookups across sheets.
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.
How to write lookup formulas (INDEX/MATCH, VLOOKUP, SUMPRODUCT-based lookups) that work in both Excel and Gnumeric/LibreOffice for multi-condition lookups. Use this when filling cells with formulas that reference data based on multiple criteria.
Master Excel lookup functions (VLOOKUP, HLOOKUP, INDEX/MATCH, XLOOKUP) for single and multiple criteria.
Covers advanced Excel lookup functions including VLOOKUP, INDEX/MATCH, and XLOOKUP for multi-dimensional data retrieval.
Use when you need to retrieve data from a table using two simultaneous conditions (e.g., row label + column header). Covers INDEX&MATCH, XLOOKUP&MATCH, VLOOKUP&MATCH, and HLOOKUP&MATCH patterns in Excel.
Use when calculating net exports as a percentage of GDP in Excel, including computing summary statistics (min, max, median, mean, percentiles) and a GDP-weighted mean using SUMPRODUCT. Covers formula structure, rounding conventions, and display formatting.
Editing Excel files with openpyxl to insert formulas while preserving all existing formatting, styles, colors, and structure.
Convert decimal percentages to whole-number representations and round to a specific decimal place.
Covers descriptive statistics (mean, median, percentiles) and weighted averages using Excel formulas.
How to calculate statistical summaries (min, max, median, mean, percentiles) and weighted averages using SUMPRODUCT, with specific rules for rounding and avoiding double-scaling of percentages.
Use Excel statistical functions for descriptive analysis including percentiles, weighted calculations, and data summaries.
Excel statistical functions (MIN, MAX, MEDIAN, AVERAGE, PERCENTILE, SUMPRODUCT) with ROUND.
Master two-condition lookups in Excel using INDEX&MATCH, XLOOKUP&MATCH, and HLOOKUP&MATCH. Use this skill whenever working with Excel lookups that require matching on two or more criteria (e.g., finding values based on both a row and column condition, or series code and year).
Perform a two-dimensional lookup in Excel to retrieve data based on both a row criteria (e.g., series code) and a column criteria (e.g., year).
Calculate a weighted mean using the SUMPRODUCT and SUM functions.
Calculating GDP-weighted means and other weighted statistics in Excel using SUMPRODUCT, including net exports as percent of GDP.
How to calculate weighted means, net export percentages, and statistical summaries (min, max, median, mean, percentiles) in Excel using SUMPRODUCT, ROUND, PERCENTILE, and other functions. Use this skill whenever the user needs GDP-weighted averages, trade statistics as percent of GDP, or descriptive statistics across a cross-section of countries or entities.
> How to calculate weighted means and descriptive statistics (min, max, median, percentiles, simple mean) in Excel formulas via openpyxl. Use this skill whenever the user asks for SUMPRODUCT-based weighted averages, GDP-weighted means, percentile calculations, or descriptive statistics in Excel.
Use when writing formulas in one Excel sheet that reference data in another sheet. Covers syntax, absolute vs relative references, and best practices for multi-sheet lookup formulas.
Use the xlsx skill tool to create, read, modify and analyze Excel spreadsheets with formulas and formatting.
Orchestrate the full analysis workflow: load data, identify Pacific plate, filter earthquakes and boundaries, project to EPSG:4087, calculate distances, find the furthest earthquake, and save results. Use this as the main execution skill.
How to generate 2D isometric or exploded-view technical posters programmatically. Use this skill whenever the user asks for a technical exploded-view, internal hardware layers, or an isometric hardware diagram.
Techniques for drawing isometric or orthographic exploded-view hardware diagrams programmatically using Pillow, with annotation leader lines and layer separation.
Format and save the identified earthquake data as a JSON file.
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.
Extract CVSS score from vulnerability data using the correct priority order (NVD → GHSA → RedHat) and handle nested JSON structure properly. Use case-insensitive field access and correct JSON path navigation.
Use this skill to extract text and structure from Word documents (.docx files) to determine their subject for classification into the correct folder.
Converts a video file into a series of keyframe images using FFmpeg with specific frame selection filters.
Extract meeting duration, constraints, and metadata from the input JSON file containing email requests.
Extracts text from .docx and .pptx files using `pandoc`. This tool is preferred for its robustness in handling various document schemas and converting them into plain text for analysis.
Extracts text and mathematical descriptions from a PDF file to identify specific algorithm parameters and loss functions. This is used to ensure the implementation matches the theoretical definition in the paper.
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 first to discover the actual field names in a PDF form. Extracts and prints all form field names from a PDF file to ensure accurate field mapping before filling the form.
Extracts text from PDF files using the `pdftotext` command-line utility with the `-layout` flag to preserve multi-column formatting, which is essential for accurately parsing scientific papers.
Use this skill to extract text, slide titles, and content from PowerPoint presentations to accurately determine their subject matter for classification.
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.
Extract key frames from an MP4 video file and save them as PNG images in a target directory. Use this skill when you need to convert a video into individual frame images for further analysis.
Converts an MP4 video file into individual keyframe PNG images. Use this to decompose a video into analyzable still frames. Extracts one keyframe per scene and stores them in the root directory with sequential naming.
Extract key frames (I-frames) from video files using FFmpeg CLI. Use this skill whenever you need to pull out keyframes, thumbnails, or important frames from MP4, MKV, AVI, or other video formats for analysis, previews, or processing.
Use ffmpeg to extract key frames (I-frames) from a video file into a directory.
Extract key frames (I-frames) from video files using FFmpeg command line tool. Use this skill when the user needs to pull out keyframes, thumbnails, or important frames from MP4, MKV, AVI, or other video formats for analysis, previews, or processing.
Extract key frames (I-frames) from video files using FFmpeg to identify scene changes and important moments.
Extract I-frame keyframes from video files using FFmpeg command line, saving them as numbered PNG images.
Extract key frames (I-frames) from video files using FFmpeg for analysis and processing.
Robust extraction of text from various file formats (PDF, DOCX, etc).
Classify academic papers and documents into subject categories using keyword-based text analysis.
Use this skill to classify PDF, PPTX, or DOCX files into subject categories: LLM, trapped_ion_and_qc, black_hole, DNA, or music_history. Analyze filenames and available content to determine the correct category.
Techniques for parsing TSV/JSON files for financial reporting data (13F).
Handles the final writing of the poem into the specified file path, enforcing strict formatting constraints.
This skill covers organizing files into subdirectories by subject matter.
Organize files into target directories based on classification results
Intelligently organizes your files and folders across your computer by understanding context, finding duplicates, suggesting better structures, and automating cleanup tasks. Reduces cognitive load and keeps your digital workspace tidy without manual effort.
Organize files into subject folders using keyword-based classification of titles and abstracts, with fallback to full text extraction.
Safely moves files into target directories while preventing collisions, handling path logic, and maintaining state.
Use this skill to fill the California Small Claims Court form (SC-100) with plaintiff and defendant information, case details, and amounts. Requires actual field names from the PDF — run Extract PDF Form Field Names skill first.
Fills a PDF form with provided data. It maps field keys to their respective pages and applies values. It handles multi-line text areas by assigning specific strings to the identified sequential keys. For checkboxes, it uses the precise export values found during inspection. All dates must be formatted as 'xxxx-xx-xx'.
Use this skill to fill in the California SC-100 Small Claims Court PDF form with case data and save the filled PDF. Handles text fields, checkboxes, and radio buttons using pypdf. Run the inspection skill first to confirm field names, then use this skill to write the filled PDF to /root/sc100-filled.pdf.
Use the `.within()` geometric method to identify earthquakes that are contained inside the Pacific plate polygon. Use this skill to ensure only earthquakes actually inside the Pacific plate are analyzed.
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.
Filter the boundary dataset to include only boundaries relevant to the Pacific plate (where PlateA or PlateB equals the Pacific plate identifier). Use this skill to exclude irrelevant boundaries before distance calculations.
Filter vulnerability records to include only HIGH and CRITICAL severity levels with case-sensitive exact matching.
Logical patterns for comparing 13F holdings across quarters to determine net change.
Find the earthquake within the Pacific plate (Code == "PA") that is farthest from the Pacific plate boundary lines in PB2002_boundaries.json. Uses an equal-area projection for accurate distance measurement. Filters boundaries where PlateA or PlateB equals "PA".
Identify the earthquake with the maximum distance to the Pacific plate boundary from the earthquakes within the Pacific plate. Use this skill to locate the target earthquake for final output.
Use this skill first to locate the trivy binary and its pre-downloaded vulnerability database cache on the system before running any security audit.
Test ML functions with fixed input tensors for reproducibility.
Write CSV output with correct field quoting and escaping for special characters, using standard CSV formatting.
Splits a long string of text (like a claim description or reason) into multiple parts that fit into sequential PDF field keys. Use this when the SC-100 form provides multiple lines (e.g., 'Reason_Line1', 'Reason_Line2') for a single explanation.
Generating a JSON output file with specific requirements for list-based answers and numeric token counts.
Reading and modifying Fortran namelist configuration files for scientific models
Compare hedge fund holdings between two quarters to identify changes in investment positions. Use this skill when analyzing Q-over-Q changes in fund portfolios, finding top increased/decreased positions, or tracking specific fund activity across reporting periods. Triggers on questions about "change from Q2 to Q3", "increased investment", "top buys/sells", or any cross-quarter 13F comparison.
Fuzzy search SEC 13-F COVERPAGE.tsv to find fund names and accession numbers by approximate name matching.
Fuzzy matching techniques for finding hedge funds by name when exact names are unknown
This skill includes search capability in 13F, such as fuzzy search a fund information using possibly inaccurate name, or fuzzy search a stock cusip info using its name.
This skill includes search capability in 13F, such as fuzzy search a fund information using possibly inaccurate name, or fuzzy search a stock cusip info using its name.
Fuzzy search fund names in SEC 13F COVERPAGE data or stock names in INFOTABLE data. Use this skill whenever searching for a fund or stock by name when the exact spelling or format is uncertain, or when performing case-insensitive partial matching on SEC filing data.
Fuzzy string matching for fund names and stock CUSIPs using thefuzz library.
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.
A skill for finding best string matches in datasets using fuzzy matching libraries like fuzzywuzzy or rapidfuzz.
How to calculate net exports as % of GDP, descriptive statistics, and weighted mean for GCC countries in the gdp.xlsx workbook. Use this for the specific task of filling in the Task sheet with lookup formulas, percentage calculations, and SUMPRODUCT weighted mean.
Create technical diagrams and posters adhering to Anthropic's official brand guidelines. Use this skill to produce exploded-view hardware visualizations with specific brand color tokens, typography, and minimalist styling.
Compile gathered PR and issue metrics into a properly formatted JSON file at /app/report.json with the exact required structure and data types.
Use this skill to generate the final CSV file at /root/counting_results.csv with columns frame_id, coins, enemies, turtles. Frame IDs must be in the format /root/keyframes_%03d.png.
Aggregates counting data for all frames and objects into a final CSV file formatted as required.
Creates the core D3.js logic in visualization.js. This includes data loading, custom market cap formatting (supporting "T" for Trillions), force simulation for sector clustering, bubble generation, and bidirectional table highlighting.
Generate meeting confirmation text files based on a specific template and save the results in a JSON log.
Creates a minimalist technical exploded-view poster of the Nova edge device for Anthropic's internal engineering handbook. Displays at least 5 hardware layers (Casing, Thermal Unit, PCB, Battery, Interface) with official Anthropic brand colors, typography, and design standards. Outputs a PNG poster and a JSON file with applied brand color hex values and heading font name.
Creates the HTML and CSS files for the stock visualization app. The HTML provides the structure for the side-by-side layout (bubble chart and table), while the CSS handles styling, scrolling, and highlighting logic.
Loading and processing GeoJSON earthquake and plate boundary data with GeoPandas for spatial analysis.
Master coordinate systems and projections in GeoPandas for accurate spatial calculations. Handle WGS84 to projected coordinate system conversions, select appropriate projections for regions, and perform distance/area calculations correctly. Use this skill when working with latitude/longitude data that needs to be converted to metric distances, or when performing spatial calculations that require specific coordinate systems.
Calculate distances between geospatial points and boundaries using GeoPandas with proper metric projections (EPSG:4087).
How to calculate distance between points and other geometries (like lines or polygons) in metric units using GeoPandas.
> How to load, filter, and work with tectonic plate boundary and polygon data using GeoPandas. Use this skill whenever the user mentions plate boundaries, tectonic plates, PB2002 data, or needs to identify which tectonic plate a point belongs to, or extract boundaries for a specific plate like Pacific (PA), African (AF), North American (NA), etc.
How to determine which points fall inside a specific polygon using GeoPandas.
Use GeoPandas with coordinate projections to perform accurate spatial calculations and transformations.
Using GeoPandas coordinate projections for accurate distance calculations on geospatial data.
> Handles CRS transformations and distance calculations in kilometers. Use this for converting between geographic coordinates (WGS84) and equal-area projections (like Lambert Azimuthal Equal Area centered on the Pacific region) for accurate distance measurements.
How to perform spatial filtering (point-in-polygon), combine line boundaries, and accurately calculate metric distances between points and boundaries using GeoPandas.
Use GeoPandas to filter points within a specific polygon, such as finding earthquakes within a specific tectonic plate.
How to perform geospatial analysis using GeoPandas. Use this skill whenever the user mentions maps, coordinates, geospatial distance, plate boundaries, earthquakes, or spatial data, even if they don't explicitly ask for it.
Analyze geospatial data using geopandas with proper coordinate projections. Use when calculating distances between geographic features, performing spatial filtering, or working with plate boundaries and earthquake data.
Techniques for loading and initial processing of GeoJSON and coordinate-based datasets using GeoPandas.
Procedures for performing precise distance calculations between points and geometries using GeoPandas. Use this skill when calculating distances in kilometers, reprojecting GeoDataFrames, or finding the nearest features in a geospatial dataset.
Analyze earthquakes relative to tectonic plate boundaries using GeoPandas. Load earthquake and plate boundary data, identify earthquakes within specific plates, calculate distances to boundaries, and analyze spatial relationships. Use this skill when working with plate tectonics, earthquake location analysis, distance calculations to plate boundaries, or coordinate projection systems in geopandas.
> Handles loading and processing of earthquake and plate boundary data. Use this for reading, filtering, and joining geospatial datasets related to tectonics (plates, boundaries, earthquake points).
Transform GeoPandas objects to metric projections (like World Equidistant Cylindrical) to calculate distances in meters or kilometers rather than degrees.
> Analyze tectonic plate geometries using GeoPandas with proper coordinate projections. Use this skill whenever working with PB2002 plate boundary/plate polygon data, filtering points by plate membership, or extracting plate-specific boundaries.
Provides foundational techniques for loading, projecting, and manipulating geospatial datasets using GeoPandas.
Guidance on selecting appropriate CRS projections for geospatial distance calculations, especially EPSG:4087 for global analyses.
Load the INFOTABLE (holdings) parquet for a given quarter and filter by accession_number to get a specific fund's holdings. Handles column name variations. Use this after obtaining an accession_number from the coverpage.
> Query GitHub repository activity (PRs, issues) for a date range using the gh CLI. Use this skill whenever you need to fetch pull request or issue data from a GitHub repository, compute statistics like counts, merge times, or identify top contributors. Triggers on tasks involving GitHub activity reports, community pulse summaries, or repository metrics gathering.
Skills for querying GitHub API data using the `gh` CLI, specifically for extracting PR and issue metrics.
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.
Computing pull request statistics (merge time, top contributors) from gh CLI JSON output using jq.
Using the gh CLI to search and list GitHub issues and pull requests with date filters and label queries.
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.
Retrieve pull request and issue data from GitHub repositories using the gh CLI with specific filters and JSON output for downstream processing.
> total counts, bug report identification by label substring matching, and resolved bug counts. Use this skill whenever the user asks about issue metrics, bug counts, triage stats, or community health reports for a GitHub repo.
> How to fetch and analyze pull request data from a GitHub repository for a contributors. Use this skill whenever the user wants PR metrics, pull request summaries, contributor leaderboards, or community pulse reports.
How to accurately search for issues (excluding pull requests) in a GitHub repository using the gh CLI, since GitHub's search API treats PRs as a type of issue.
How to accurately search for pull requests in a specific GitHub repository within a date range using the gh CLI, and correctly distinguish merged vs closed-without-merge PRs.
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.
How to use `gh api` with pagination to retrieve all results from GitHub REST API endpoints, including PRs and issues.
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.
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.
Query GitHub repositories for PRs and issues using gh CLI with date filtering and structured output.
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.
Analyze GitHub issues for a date range, counting totals, bug reports (by label substring), and closed bug reports.
How to calculate GitHub community pulse metrics using the `gh` CLI. Use this skill whenever the user asks for pull request metrics, issue metrics, community pulse, average merge times, top contributors, or bug reports over a specific timeframe.
Aggregate GitHub PR and issue data into structured metrics, including contributor analysis, merge statistics, and bug categorization. Use this skill when compiling activity reports, computing open-source velocity metrics, or generating community pulse summaries.
Process GitHub API data to calculate PR/issue metrics including merge time averages, author rankings, and bug categorization.
Compute PR statistics (total, merged, closed, avg merge time, top contributor) from GitHub API data using Python or jq.
> Build structured JSON reports from GitHub repository activity data. Use this skill whenever you need to compile PR and issue statistics into a formatted JSON file for meeting summaries, community pulse reports, or stakeholder updates. Triggers on tasks that require outputting a report.json or similar artifact from GitHub metrics.
> 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.
Fetch repository metrics, issues, and pull requests over a specific date range using the GitHub Search API.
Use `gh search issues` to fetch issues from a specific repo within a date range. Returns structured JSON. More reliable than `gh issue list --search` for date-range filtering.
Use `gh search prs` to fetch pull requests from a specific repo within a date range. Returns structured JSON for downstream processing. More reliable than `gh pr list --search` for date-range filtering.
Creating, managing, and applying unified diff patches with Git for source code modifications.
A good starting point for GLM calibration tasks. Use to inspect glm3.nml, confirm how GLM runs, and identify the relevant files before moving on to calibration and output evaluation.
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.
Calibrating GLM parameters (Kw, coef_mix_hyp, wind_factor, lw_factor, ch) to minimize RMSE against field observations.
Calibration strategy for GLM lake temperature simulations, including parameter sensitivity and typical ranges.
Calibration guidance for GLM tasks. Often most effective after glm-basics has clarified the setup; glm-output is the companion skill for exact final metric computation.
Calibrate GLM by adjusting key parameters to minimize RMSE. Use this skill when you need to iteratively tune model parameters to meet performance thresholds.
Managing and modifying GLM configuration files (glm3.nml) for calibration. Use this skill whenever you need to safely update GLM parameters, preserve non-calibration settings, validate configuration syntax, or manage multiple parameter sets. Essential for iterative calibration workflows where parameters must change reliably without corrupting the config.
Manage and calibrate General Lake Model (GLM) configuration files (glm3.nml) within specified parameter constraints and physical ranges.
Evaluate GLM simulation results using field observations and RMSE metrics. Use this skill when you need to merge simulation results with field observations and calculate RMSE values for different conditions (overall, annual_deep, summer_deep).
A skill to process GLM NetCDF output and calculate specific RMSE metrics by merging with field observations.
How to run the General Lake Model (GLM) for lake water temperature simulation. Use this skill whenever you need to execute GLM simulations, understand GLM configuration files (*.nml), interpret GLM output (NetCDF), or troubleshoot GLM execution. Essential for lake modeling and water temperature prediction tasks.
> Calibrate the General Lake Model (GLM) for lake temperature simulation. Use this skill whenever calibrating GLM parameters, running GLM simulations, or tuning Kw, coef_mix_hyp, wind_factor, lw_factor, or ch to match observed water temperature profiles. Covers Lake Mendota and similar dimictic lakes.
Use this skill to understand the GLM (General Lake Model) configuration for Lake Mendota, including how to read and modify the glm3.nml file, what parameters are allowed to change, and how the model is structured. Apply this before running or calibrating GLM.
Running the General Lake Model (GLM3) for lake temperature simulation, including configuration file structure and execution.
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 calculate and save GLM performance metrics (RMSE) to metrics.json. Use this whenever the user asks for RMSE checks or final model evaluation.
Calculate specific RMSE metrics by merging simulation and observation data using exact datetime and rounded-depth matching.
Extracting and analyzing GLM NetCDF output to compute RMSE against field observations using exact datetime+depth matching.
A skill to edit GLM's namelist file (glm3.nml) by safely updating parameter values within specific blocks.
How to merge GLM simulation output with field observations and compute RMSE metrics for Lake Mendota calibration. Use this when computing overall RMSE, annual deep RMSE, and summer deep RMSE from matched observation-simulation pairs.
Output-processing guidance for GLM tasks. Especially useful after glm-basics and glm-calibration when you need verifier-matching metrics from output.nc and a final /root/metrics.json.
How to extract water temperature profiles from GLM NetCDF output files (output.nc). Use this skill when you need to read GLM simulation results, extract depth and temperature arrays, and construct a dataframe of simulated temperatures at specific depths and times.
Extract and transform water temperature data from GLM NetCDF files, handling dynamic layering, masked arrays, and temporal alignment.
Use this skill to correctly parse GLM NetCDF output (output.nc) into a DataFrame of (datetime, depth, temperature) triples. Handles the 4D variable shape (ntime, nlayer, 1, 1), correct depth conversion using fixed lake_depth from glm3.nml, and datetime reconstruction using manual timedelta from a fixed reference date.
Safely modify specific calibration parameters in the GLM configuration file. Use this skill when you need to update Kw, coef_mix_hyp, wind_factor, lw_factor, or ch while preserving all other settings and respecting published calibration ranges.
A skill to execute the GLM binary and manage its simulation output.
Manage GLM (General Lake Model) configuration and execution. Use this skill when modifying 'glm3.nml' or running the GLM binary to ensure simulation parameters are correctly set and the model runs successfully.
Running the General Lake Model (GLM) and understanding its NML configuration file format.
Running the General Lake Model (GLM) with configuration files and parameter calibration
This skill covers running the General Lake Model (GLM) and modifying its configuration file (glm3.nml).
How to run GLM, modify calibration parameters, and manage simulation outputs. Use this whenever the user wants to run, calibrate, or troubleshoot GLM simulations.
Convert RGB images to grayscale using OpenCV (cv2) in Python. Use this skill when the user needs to convert color images to grayscale for image processing, template matching, or analysis.
Implement greedy bipartite matching for pairing cluster centroids with expert annotations.
How to perform greedy matching between predicted cluster centroids and ground-truth expert points using closest-pairs-first strategy with a maximum distance threshold.
How to perform greedy nearest-neighbor matching between two sets of 2D points (cluster centroids vs expert annotations) with a maximum distance threshold, returning matched pairs for F1/delta computation.
Greedy matching algorithm to pair predicted cluster centroids with ground truth points for F1 and distance metrics.
Evaluating clustering performance using greedy matching of predicted centroids against ground truth points.
Match clustered centroids to expert annotations using greedy nearest-neighbor matching with distance constraints. Compute F1 scores and delta metrics for clustering quality assessment.
Matching predicted cluster centroids to ground truth points using a greedy distance-based approach to calculate F1 score and precision/recall.
Running a multi-parameter grid search efficiently using parallel processing to find optimal hyperparameters.
Logic for planning itineraries that rely on ground transportation (driving) rather than flights, ensuring travel feasibility and daily activity engagement.
How to use offline vulnerability scanning tools like grype, trivy, or osv-scanner to detect vulnerabilities in dependency lock files without network access.
Properly handle null, missing, and empty values in vulnerability records with appropriate fallback values.
Compare fund holdings between two quarters (Q2 vs Q3) to identify increased/decreased positions by dollar value or share count.
Using Hugging Face TRL library for building custom trainers for Preference Optimization methods like DPO, SimPO, etc.
Efficiently executing grid search over massive parameter spaces using Python multiprocessing.
Create a utility function to reliably detect ETF entries by checking for null/undefined marketCap values, enabling conditional tooltip display and styling
Examine the plates dataset to find the exact identifier used for the Pacific plate (e.g., "PA", "Pacific", etc.). Use this skill early in the analysis to ensure consistent filtering across boundaries and plates.
Determine which person opened the most pull requests in December 2024 by analyzing author data from the PR query results.
Command-line tools for modifying and manipulating images, such as resizing, blurring, or changing colorspace. Use this skill whenever the user mentions modifying images, converting to grayscale, or changing image properties.
Comprehensive command-line tools for modifying and manipulating images, such as resize, blur, crop, flip, and many more.
Guidelines for applying strict brand color palettes and minimalist technical design standards to generated imagery.
Technical image generation using Python's Pillow library. Use this when you need to programmatically create diagrams, posters, or technical drawings.
Convert images to grayscale in-place.
Use this skill to convert RGB images to grayscale. It provides methods using common libraries like OpenCV or PIL.
Use ImageMagick to convert an image to grayscale inplace.
Convert RGB color images to grayscale and save them in-place, overriding the original files. Use this skill whenever the user asks to convert images to gray-scale, desaturate photos, or prepare images for grayscale processing pipelines using OpenCV or Pillow.
Techniques for image preprocessing and template matching to count objects in images.
Convert images to grayscale in-place using OpenCV.
Use this skill for image conversion, such as grayscale conversion, to prepare images for analysis.
Use this skill to implement the simpo_loss function in SimPOTrainer based on the SimPO paper. The loss combines a length-normalized reward with a margin gamma and uses BCE loss without a reference model.
Implements the SimPO (Simple Preference Optimization) loss function with length normalization and reward margin as specified in the research paper.
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.
Create and manage a D3 tooltip element that displays on hover for non-ETF stocks with dynamic positioning based on mouse movement
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.
How to inspect the structure of an Excel workbook before writing formulas, including checking sheet names, cell values, data types, and layout. Use this whenever you need to understand the actual content of an Excel file before modifying it.
Use this skill to inspect all form fields in a PDF file, printing their names, types, and current values/export values. Useful for understanding the structure of a PDF form before filling it.
Extracts detailed information about form fields in a PDF, including field keys, types, page indices, current values, and allowed export values for checkboxes and radio buttons. Use this to identify how multi-line text is split across different keys (e.g., 'Reason_1', 'Reason_2') and to find the exact string required to check a box (e.g., 'Yes', '1', or 'On').
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 this skill to install all required packages for the SimPO project using Python 3.10 specifically. Installs torch, transformers, trl, and other dependencies into the python3.10 environment.
Planning multi-city travel itineraries with budget constraints, route optimization, and cuisine diversity.
Build multi-day travel itineraries in JSON format from database lookups. Use this skill when constructing day-by-day travel plans with transportation, meals, attractions, and accommodations.
Build multi-day travel itineraries with routing, scheduling, and constraint satisfaction. Use this skill whenever creating a structured travel plan that must span multiple days, visit specific cities, include meals and accommodations, and respect travel time and budget constraints. Essential for generating day-by-day itineraries in JSON or structured formats.
Guidelines for selecting database-compliant restaurants, accommodations, and attractions based on specific user constraints like budget, pets, and cuisine.
Create a JSON structure for a 7-day travel plan.
Use this skill to convert a completed day-by-day travel plan into the required JSON output format and write it to /app/output/itinerary.json. Enforces field rules, naming conventions, and completeness checks.
Use this skill to construct the final itinerary and strictly format the output as a JSON file, enforcing specific key requirements and keywords.
Handles the structural requirements and formatting of the 7-day travel itinerary JSON.
How to structure and write a valid travel itinerary JSON file matching the required schema for /app/output/itinerary.json.
How to plan travel itineraries. Use this skill whenever the user mentions a travel itinerary, a trip, planning a vacation, or generating a schedule from travel constraints, even if they don't explicitly ask for an itinerary planner.
Use this skill to build a multi-day travel itinerary from structured requirements (origin, cities, dates, budget, constraints). It queries available database files and produces a day-by-day plan with transportation, meals, attractions, and accommodations.
How to construct a 7-day, pet-friendly travel itinerary for three Ohio cities starting from Minneapolis without using flights. Use this skill for planning, organizing the itinerary data, and formatting the final JSON output.
Use this skill to validate a completed itinerary JSON against all task requirements before finalizing output. Run this checklist after formatting and before writing the file.
A final verification step to ensure the JSON output meets all structural and constraint requirements before delivery.
Securing Jackson JSON deserialization by validating input before processing and preventing unknown properties.
Security and Jackson deserialization issues in Apache Druid, focusing on property bypasses.
Security considerations for Jackson @JacksonInject - preventing JSON input from overriding injected values, covering CVE patterns and defense strategies.
Fixing Jackson @JacksonInject bypass vulnerabilities where attackers use empty JSON keys to override injected values. Use this skill whenever reviewing or patching Java code that uses @JacksonInject for security-sensitive configuration injection, especially in Apache projects.
Preventing Jackson @JacksonInject override attacks where JSON input can replace server-side injected values.
Security considerations for Jackson @JacksonInject annotation in Java applications. How to prevent JSON input from overriding server-injected values. Use this skill whenever reviewing code that uses @JacksonInject, when an attacker could supply JSON to override configuration objects, or when fixing deserialization vulnerabilities related to injectable values.
Security considerations for Jackson JSON deserialization, specifically regarding `@JacksonInject` and unintended property overrides.
Security considerations for Jackson JSON deserialization in Java applications. This skill covers common attack patterns such as the Empty Key ("") attack vector, polymorphic type handling, nested injection, and duplicate keys, along with their root causes and recommended mitigation strategies. It provides essential background knowledge and is highly useful for addressing related security vulnerabilities. It is always recommended to invoke this skill before working on relevant security fixes.
Best practices for securing JavaScript execution in Java applications using ScriptEngines like Rhino or Nashorn.
Techniques for applying security fixes to Java projects using git, diffs, and Maven.
Workflow for creating and applying patches to Java projects - diff format, patch application, and Maven rebuilds for security fixes.
Perform parallel grid search using joblib. Use this skill whenever a task requires optimizing multiple hyperparameters simultaneously across CPU cores.
Process JSON data from GitHub CLI using jq to calculate metrics like average merge times, counts, and top contributors.
Using jq to parse, filter, and aggregate JSON data from CLI tools for generating reports.
Format retrieval answers as a dictionary in /root/answer.json.
Standardized structure for branding metadata in engineering documentation.
Python patterns for analyzing large JSON datasets to find specific information, track tokens, and write answers in the required format.
Patterns for analyzing and outputting structured JSON answers from enterprise data queries.
Extract, parse, and query JSON data from large enterprise files efficiently
Load and parse large enterprise JSON data files efficiently. Use this skill when you need to read JSON files from /root/DATA or similar enterprise data directories, especially large files that exceed memory limits. Handles partial reading, searching specific content within JSON structures, and navigating nested JSON hierarchies without loading entire files into memory.
How to read and extract specific values from employee_data.json to map them to template placeholders.
Provides techniques for parsing and extracting data from JSON files in Python.
Use this skill to read and parse structured email data from a JSON file, extracting fields like message ID, sender email, subject, body, and meeting constraints (duration, preferred times/dates).
Skill to extract information from the structured JSON data, including Slack messages and document metadata.
Read input JSON files with email requests and write results.json with reply filenames and recipients.
Ensures the final output strictly adheres to the requested JSON structure and field requirements.
Formats and saves answers to a JSON file where each entry requires a specific nested dictionary structure containing list-type values and positive numeric token counts.
Format enterprise data retrieval results as JSON with token tracking. Use this skill when you need to output query results to JSON files in the format {"q1": {"answer": [...], "tokens": N}, ...}. Handles answer list formatting, token counting, and file output validation.
Parsing JSON input files for structured data extraction.
Provides utility functions for reading, manipulating, and writing JSON data structures efficiently in Python.
Efficiently read and parse JSON files for use in automation tasks.
Skills for processing JSON data in the CLI, primarily using `jq`.
Answer questions from JSON enterprise data and write results to answer.json. Use this skill when the user asks multiple questions about enterprise data and needs answers stored in a JSON file with token counts. Handles the output format requirements for answer.json.
Generate and write structured JSON reports with proper formatting and validation.
Format query results to JSON with proper structure and token tracking
Specialized instructions for reading, modifying, and filling PDF legal forms (e.g., California judicial council forms). Use this for any task involving PDF forms.
Use when you need to enumerate files in a directory, optionally filtering by extension. Returns sorted list of file paths.
Extracts and tracks the consumed token usage from an LLM API response to monitor API cost and utilization.
Load and search the COVERPAGE parquet file for a specific fund manager using fuzzy matching on the FILINGMANAGER_NAME field. Returns the best matching row including accession_number, AUM, and other fund details. Use this when you need to find a fund's accession number by name.
Load GeoJSON files with GeoPandas and inspect their structure — columns, CRS, geometry types, and sample rows. Use this before any spatial analysis to understand field names and data layout.
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 GeoJSON and plate boundary datasets, and ensure consistent projection for distance analysis.
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.
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.
Load CSV data and verify all stock entries contain the required `ticker` field with non-empty string values before using in selection matching logic
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 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.
Neutralizing malicious logic by modifying class deserialization behaviors.
Rules for rhyming in poetry based on modern Mandarin (Pinyin).
Guide to modern Mandarin pronunciation-based rhyming for classical Chinese regulated verse. Use this skill when determining rhyme schemes, ensuring proper rhyming sounds in couplets, and verifying phonetic compatibility in classical poetry composition.
Master modern Mandarin pinyin finals and tone systems to create accurate rhymes for classical poetry following contemporary pronunciation standards.
Rules for determining the Ping (平) or Ze (仄) status of a character based on modern Mandarin Pinyin tones.
Correctly identify and extract Trivy vulnerability JSON field names and map them to the required CSV output columns in exact order.
Explicitly write out the required tonal pattern for all 8 lines of your chosen regulated verse form (specify which of the 4 canonical forms: 仄起平收 or 平起平收, etc.). Display the target pattern as a visual grid showing positions 1–7 for each line, then use this as your line-by-line verification checklist during composition.
Organizing annotation data by image identifiers to prepare for image-by-image clustering analysis.
Load citizen science and expert annotation datasets, match them by image using file_rad column, handle missing data, and prepare data for clustering evaluation.
Compute F1 score and delta (average distance) metrics for Mars cloud cluster evaluation. Use this skill when evaluating DBSCAN clustering results against expert annotations, including handling edge cases like images with no clusters, no expert points, or no matches.
How to optimize DBSCAN hyperparameters for Mars cloud clustering. Use this skill whenever performing grid search, DBSCAN clustering, or evaluating F1 and delta for Mars datasets.
Implement greedy nearest-neighbor matching between cluster centroids and expert annotations. Use this skill when you need to match predicted cluster centers to ground-truth expert points for Mars cloud evaluation, always using standard Euclidean distance with a maximum distance threshold of 100 pixels.
Implement weighted custom distance metric for DBSCAN clustering. Use this skill when working with DBSCAN on Mars cloud data where distances need to be weighted differently across x and y axes using a shape_weight parameter (w). The custom metric is d(a,b) = sqrt((w*Δx)² + ((2-w)*Δy)²), controlling whether x-distances or y-distances are attenuated.
Identify Pareto-optimal solutions from Mars cloud clustering results. Use this skill when you need to find the frontier of solutions that balance multiple conflicting objectives (e.g., maximizing F1 while minimizing delta), eliminating dominated solutions and finding all trade-off points.
Optimized Maven build commands for Apache Druid to save time and resources. Use this when you need to rebuild Druid after applying patches.
Guide on how to rebuild Druid using Maven while skipping unnecessary checks. Use this skill when asked to compile or build Druid.
Building Apache Druid with Maven, managing memory constraints, and skipping verification checks.
How to build Apache Druid efficiently with Maven while skipping unnecessary checks and OOM-prone modules. Use this skill when building patched Druid versions, when rebuilding after security fixes, or when the web-console module causes out-of-memory errors.
Parse duration and time constraints from email text.
Extracts meeting durations and constraints from a meeting request JSON file (e.g., test_input.json). Use this whenever you need to process incoming meeting invitations to understand their specific requirements.
Parse meeting request emails from JSON format and extract duration and time constraints
Parse meeting request emails from test_input.json to extract meeting details. This skill helps extract recipient email, message ID, meeting duration, and any date/time constraints from JSON email records. Use this whenever you need to process meeting requests from a JSON file.
Generate properly formatted meeting confirmation emails and save results. This skill handles creating reply text files with exact formatting (date format with day name and full date, time format with leading zeros), generating results.json with metadata, and ensuring compliance with the response template. Use this whenever you need to format meeting confirmations or generate scheduled meeting documentation.
Generates reply text files and the final result log with specific formatting for date, time, and JSON. Use this skill whenever you need to provide a professional meeting proposal in a fixed format.
Schedule meetings by matching email requests against calendar availability. Use this skill when processing meeting request emails, finding optimal meeting times, or generating meeting reply templates. Triggers on phrases like "schedule a meeting", "find a time", "propose meeting slots".
Use this skill whenever you need to schedule meetings, parse calendar PDFs, resolve overlapping time windows across timezones, and format schedule responses.
Logic for finding the earliest possible meeting slot based on calendar availability and email request constraints. Use this skill whenever you need to propose a meeting time from a set of constraints and an existing schedule.
Find the earliest available meeting time slots that satisfy constraints. This skill implements the scheduling algorithm to match meeting requests with available calendar slots, handling blue (flexible) block overwriting, time constraints, and date preferences. Use this whenever you need to schedule a meeting or find available time slots.
Calculating RMSE metrics and parameter calibration for lake model validation
Verifies model components like loss functions using unit tests and saves the results as NumPy archives.
Guidelines for mapping modern Mandarin pronunciation (Pinyin) to traditional Ping (Level) and Ze (Oblique) poetic tones, and identifying modern rhyme families.
Plan a multi-day road trip across multiple cities without flights, considering driving distances, travel time between destinations, and logical routing to minimize backtracking. Use this when building itineraries that require ground transportation between cities.
Use INDEX-MATCH with two conditions (series code and year) to retrieve values from a source data table. Apply this when you need to pull specific data points based on multiple criteria from an unstructured data range.
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.
Work with MultiPolygon and MultiLineString geometries from real plate boundary datasets.
Correlate and merge data from multiple sources (documents, Slack, meetings, URLs) to answer enterprise questions.
Reading and analyzing GLM NetCDF output with Python netCDF4 and pandas for RMSE evaluation.
> Extract simulated temperature from GLM NetCDF output and match against field observations for RMSE evaluation. Use this skill when computing RMSE metrics from GLM output.nc files matched against CSV observation data with datetime and depth columns. Covers exact datetime + rounded-depth merging.
Reading, processing, and analyzing NetCDF output from lake simulation models
Calculate net exports as a percentage of GDP for multiple countries, then compute descriptive statistics (min, max, median, mean, percentiles) on the percentage values. Use this when analyzing trade performance across multiple entities.
Manages NLP environments, handling library dependencies like PyTorch, Transformers, and custom local packages.
Set up and run NLP preference optimization experiments (DPO, SimPO, CPO). Use this skill when configuring trainer environments, installing dependencies (torch, trl, transformers, peft), or running preference optimization unit tests. Triggers on: DPO, SimPO, preference optimization, trl trainer, RLHF, alignment training.
Set up Python environment for NLP and preference optimization projects.
Align Python version and repo-declared dependencies (requirements.txt / environment.yml) before installing packages for NLP research code reproduction.
Identifying vulnerabilities in Node.js dependencies using the npm audit tool to filter for high and critical severities.
How to perform security audits on Node.js package-lock.json files using npm audit and other offline tools to identify vulnerabilities in third-party dependencies.
Scan npm package-lock.json files for vulnerabilities using Trivy in offline mode. Extracts HIGH and CRITICAL severity vulnerabilities with detailed metadata (CVE, CVSS, fix versions). Use this skill whenever you need to audit npm dependencies for security issues, especially when an offline vulnerability database is available.
Count occurrences of an object in the image using computer vision algorithm.
Count occurrences of an object in an image using computer vision algorithms. Use this skill whenever the user asks to count objects, find matches, or identify items in a scene using a template image.
Use this skill for counting specific objects (coins, enemies, turtles) in images using template matching.
Use this skill to count occurrences of a template image within a larger target image using template matching techniques.
Count objects in an image using the command-line interface of the object detection script.
Detect and count occurrences of template images within a larger target image.
Logic for mapping employee JSON data to offer letter template placeholders. Includes handling of conditional fields like relocation packages. Use this skill when preparing data for offer letter generation.
> Fill Word offer letter templates with employee data, replacing {{PLACEHOLDER}} tokens and handling {{IF_CONDITION}}...{{END_IF_CONDITION}} conditional blocks. Use this skill whenever the user asks to generate, fill, or produce an offer letter from a .docx template and a JSON data file, or whenever you need to merge HR data into a Word document template with placeholders and optional sections (e.g. relocation package, signing bonus).
Generate filled offer letters from a JSON employee data file and a Word template. Use this skill whenever you need to create offer letters by matching data fields to document placeholders, handling conditional relocation packages, and saving the final document.
Extracts text from DOCX and PPTX documents for content analysis.
Identify major attractions, points of interest, and notable sites across three Ohio cities that appeal to general travelers. Use this when building activities for a multi-city itinerary.
Use this skill when planning a 7-day road trip itinerary from Minneapolis to three cities in Ohio, covering budget, pet-friendly accommodations, cuisine preferences, and no-flight constraints. Produces a JSON itinerary file.
Extracts AUM and total holdings count for a specific fund using its accession number and the quarter folder path.
Convert images from RGB/BGR to grayscale using OpenCV and save in-place.
Count occurrences of an object in an image using OpenCV template matching (cv2.matchTemplate). Use this skill whenever the user needs to detect and count how many times a small reference image (template) appears in a larger image, such as counting coins, enemies, or other game sprites. Works on both grayscale and color images.
Use OpenCV for image processing, grayscale conversion, and template matching to detect objects in images.
Count occurrences of a template object in an image using OpenCV template matching with non-maximum suppression.
Editing existing Excel files with openpyxl while preserving formatting and adding formulas.
Select appropriate projected CRS based on geographic region for accurate distance calculations.
Resolves scheduling conflicts between email requests and calendar availability, prioritizing meeting requests over blue (flexible) blocks.
Use this skill to classify and move 100+ PDF/PPTX/DOCX files into 5 subject folders (LLM, trapped_ion_and_qc, black_hole, DNA, music_history) based on content analysis. Handles keyword scoring with filename tiebreaking and music_history as catch-all default.
Format and write Pareto frontier results to CSV file with proper rounding and column ordering.
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.
Finding the earthquake furthest from the Pacific plate boundary within the Pacific plate itself, using GeoPandas with EPSG:4087 projection for distance calculations and EPSG:4326 for spatial containment checks.
How to parse package-lock.json to extract all dependency names and versions for vulnerability lookups, covering both lockfile v1, v2, and v3 formats.
Parse and extract package information from npm package-lock.json files to identify dependencies and their installed versions.
> How to parallelize hyperparameter grid search using joblib. Use this skill whenever the user needs to evaluate many hyperparameter combinations (e.g., DBSCAN epsilon, min_samples, shape_weight) efficiently across CPU cores. Covers joblib.Parallel, parameter grid generation with itertools, and collecting results into a DataFrame.
Parallelize hyperparameter grid searches using joblib for CPU-bound tasks like DBSCAN clustering evaluation loops.
Parallelize hyperparameter grid search using joblib for efficient multi-core execution.
How to parallelize a grid search over hyperparameter combinations in Python using joblib or multiprocessing for CPU-bound tasks like DBSCAN clustering.
Parallel processing with joblib for grid search and batch computations across multiple CPU cores.
Parallel processing with joblib to speed up computationally intensive parameter grid searches.
Parallel processing with joblib for grid search and batch computations. Use when speeding up computationally intensive tasks across multiple CPU cores.
Identify Pareto-optimal points from a set of multi-objective solutions.
Identify Pareto-optimal solutions from multi-objective optimization results.
How to compute the Pareto frontier from a set of (F1, delta) optimization results where F1 is maximized and delta is minimized. Includes filtering, dominance checking, and CSV output formatting.
How to identify Pareto-optimal solutions from a set of multi-objective optimization results, specifically maximizing one metric while minimizing another.
Identifying the set of non-dominated solutions in a multi-objective optimization problem.
Compute the Pareto frontier for multi-objective optimization. Use this skill whenever a task requires finding optimal trade-offs between conflicting metrics (e.g., maximize F1, minimize distance).
Identifying Pareto-optimal points in a multi-objective optimization space.
Execute grid search over DBSCAN hyperparameters, evaluate each combination across all images, filter by F1 threshold, and identify Pareto-optimal solutions balancing F1 score and delta metric.
Multi-objective optimization with Pareto frontiers. Use when optimizing multiple conflicting objectives simultaneously, finding trade-off solutions, or computing Pareto-optimal points.
Compute Pareto-optimal frontiers from multi-objective optimization results, including dominance checking and frontier extraction.
Multi-objective optimization with Pareto frontiers for finding trade-off solutions between conflicting objectives.
Parses a text file containing key-value pairs (like question IDs and question text) into a Python dictionary.
Generating and saving git-compatible patch files for Apache Druid source code.
A comprehensive PDF toolkit for advanced data extraction and document analysis. Beyond text and table extraction, this tool is optimized for visual layout reasoning: it can map graphical elements to coordinates (such as determining appointment times based on their position on a calendar timeline) and identify color-coded features (e.g., distinguishing high-priority blocks from flexible blue-colored entries). Use this skill when the task requires interpreting schedule layouts, calculating durations from visual spans, or resolving scheduling conflicts based on the spatial and color properties of a PDF document.
Extracting text and metadata from PDF documents.
Extract appointments and time blocks from a calendar PDF. This skill helps parse calendar.pdf to identify appointment blocks, their positions on the timeline, duration, and color coding (including blue blocks that represent flexible/overwritable slots). Use this whenever you need to extract calendar data from a PDF document.
Extract text and identifying colored regions (e.g., rectangles) from a PDF using pdfplumber.
Extracts appointments, start/end times, and priority colors from a PDF calendar. Use this skill whenever you need to understand existing schedules from a visual PDF calendar document.
Parses /root/calendar.pdf to extract appointment timings, color-coded blocks, and time-axis mappings using pdfplumber.
Use PyMuPDF (fitz) to extract visual calendar blocks from a PDF, including color detection and pixel-to-time conversion.
Extract calendar events, blocks, and time slots from PDF calendar files using pdfplumber
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 this skill to extract visual calendar data from a PDF file using PyMuPDF (fitz), including reading text for time labels and appointments, detecting colored rectangular blocks, and measuring their vertical positions to determine start/end times based on a 15-minute-per-row grid.
Classifies PDF academic papers by subject area using text extraction from first pages. Use this skill whenever you need to categorize, sort, or organize PDF papers by topic, research field, or subject matter.
Extracts vector graphics, colors, and text from PDF files using PyMuPDF to analyze calendars or visual schedules.
Extracts text from PDF documents for content analysis.
Organizes PDF, PPTX, and DOCX academic files into subject folders by extracting and analyzing their title/abstract text. Use this skill whenever the user needs to sort or categorize a batch of research papers or documents into topic-based folders (e.g., LLM, quantum computing, biology, physics, music). Handles arXiv papers and other academic documents automatically.
Provides guidelines for filling out PDF forms using programming tools.
Fill PDF form fields programmatically using Python and pypdf. Use this skill whenever the user needs to fill out a PDF form, set text fields, or check checkboxes in a PDF document.
Fill PDF forms programmatically using pypdf library. Use this skill whenever you need to fill in PDF forms with field data, extract field names from PDFs, or generate filled PDF documents. Essential for automating form completion tasks.
Fill PDF form fields programmatically using Python libraries like pypdf or pdfrw
Use this skill to identify, extract, and populate specific fields within a PDF form using the pdftk or pikepdf toolsets.
Methods for programmatically filling PDF forms (AcroForms) and saving the results using pypdf.
Fill PDF form fields using pypdf library in Python, including text fields and checkboxes.
Techniques for inspecting PDF form fields and their properties using Python libraries like pypdf.
Use this skill to extract text from PDF files to determine their subject matter.
Extract text from PDF files using Python libraries (PyPDF2, pdfplumber) for content analysis and classification.
Extract text content from PDF files for analysis and classification
How to extract text from PDF files for content-based classification. Use this when you need to read PDF content to determine what subject/topic a paper belongs to. Covers both text-based and scanned PDFs.
Identify and select pet-friendly lodging options that welcome dogs and meet budget constraints. Use this when travelers have pets and need verified pet-friendly hotel/lodging information.
Filtering accommodations for pet-friendly stays by analyzing house_rules field in accommodation data.
Convert images to grayscale in-place using Pillow (PIL), overwriting original RGB files.
Create technical poster and diagram images using Pillow (PIL), including shapes, text, lines, and layered composition.
Creating technical diagrams and exploded-view illustrations using Python Pillow with geometric primitives and text annotations.
Implements Manus-style file-based planning for complex tasks. Creates task_plan.md, findings.md, and progress.md. Use when starting complex multi-step tasks, research projects, or any task requiring >5 tool calls.
Work with tectonic plate boundary datasets (PB2002 format) to identify plate regions, extract specific plate boundaries, and perform spatial filtering. Load plate boundary and plate polygon data, identify specific plates like the Pacific plate, and extract relevant boundaries. Use this skill when parsing plate tectonics datasets, identifying plate regions from boundary lines, or filtering spatial data by plate membership.
Analyzing earthquake data relative to tectonic plate boundaries using PB2002 dataset and GeoPandas.
Techniques for processing tectonic plate data, specifically using the PB2002 dataset. Use this skill when filtering points within plates, identifying plate boundaries, or working with global tectonic geometries in GeoPandas.
Analyze plate tectonics data using GeoPandas, identify points within plates, and calculate distances to boundaries.
Specific knowledge of the PB2002 (Bird, 2002) dataset structure for identifying the Pacific plate.
Work with PB2002 plate boundary and polygon data to identify plate membership and boundary distances for earthquakes.
Guidelines and structures for composing classical Chinese poetry, specifically seven-character regulated verse (Qi-Yan Lu-Shi).
Composes an eight-line seven-character regulated verse (Qiyan Lüshi) focusing on historical or emotional themes, ensuring exact line counts and structural integrity.
Guidelines for composing classical Chinese seven-character regulated verse (Qi-Yan-Lu-Shi), focusing on structure, rhythm, and emotional expression.
Analyzing fund portfolios including AUM extraction, holdings counts, and portfolio composition
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.
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).
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.
Inspecting and filling interactive PDF forms (AcroForms) using the pypdf library. Crucial for automating the population of government or legal PDF documents.
Generate structured CSV files from Python data using the csv module for tabular data export.
Parse datetime strings and compute time durations/averages for datasets (like PR merge times) in Python.
Manipulate Word documents (.docx) using Python, including placeholder replacement and conditional section handling.
Manipulate Word .docx files with python-docx, including handling split placeholders across runs and conditional sections.
Programmatically read, modify, and create Word documents (.docx) with python-docx library
Techniques for replacing text placeholders, safely deleting paragraphs, and handling custom multi-paragraph conditionals (like IF/END_IF markers) in Microsoft Word documents using python-docx.
Detailed guidance on recursively processing nested tables in python-docx documents. Use this when a Word template contains tables inside table cells and you need to reach all paragraphs.
A skill for replacing placeholders and handling conditional blocks in python-docx.
How to process Word documents (.docx) with python-docx. Use this skill whenever the user mentions Word templates, docx templating, replacing placeholders, or processing Word files, even if they don't explicitly ask for it.
Using openpyxl to read, write, and modify Excel files while preserving formatting and using formulas.
Matching observations with simulated data using exact datetime and rounded depth merges in pandas.
Use this skill when you need to programmatically fill PDF form fields using Python. Covers inspecting field names and writing values to fillable PDFs.
Create clean technical posters and diagrams using the Python Pillow library, including shape drawing, typography placement, and annotation.
Create technical graphics, diagrams, and posters using Python Pillow library with precise color control and typography.
Guide on using the Python pypdf library to read, write, and fill PDF forms programmatically.
Implementing immutable fluent builder pattern in Scala as a translation of Python classes with method chaining, emphasizing immutability and type safety.
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.
> 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.
Using the circe library for JSON encoding, decoding, and manipulation in Scala as a replacement for Python's json module, covering the Json ADT, parsing, and path traversal.
Guide for mapping Python collection types and operations to Scala equivalents.
Guidelines for translating Python dataclasses, enums, and collections to Scala.
> 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.
Guidelines for mapping Python standard libraries (json, datetime) to Scala equivalents (Circe, java.time).
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.
Guide for translating Python functional patterns (map, flatMap, Option, monads) to idiomatic Scala.
Mapping Python's functional tools to idiomatic Scala equivalents, including lambdas and collection methods.
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.
Guidelines for translating Python functional patterns and simulations to idiomatic Scala.
Guidelines for translating Python TypeVars and Protocols to Scala Generics and Traits.
> 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.
Guide for writing idiomatic Scala including naming conventions, error handling, and pattern matching.
Mapping standard and common libraries from Python to Scala, including datetime, decimal, and JSON.
Translating Python classes, inheritance, and generic variance to Scala equivalents.
Guide for translating Python classes, inheritance, ABC, generics and builder patterns to idiomatic Scala.
Translating Python Enum classes to Scala sealed abstract classes or sealed traits with companion objects, preserving value fields and exhaustive pattern matching.
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.
Basic syntax and type mapping from Python to Scala, including primitive types and common control structures.
Reference for translating Python syntax constructs (enums, dataclasses, type vars, protocols) to Scala equivalents.
Techniques to find specific data points in nested Python dictionaries using recursion.
Idiomatic translation of Python constructs to Scala 2.13, including classes, interfaces, enums, and naming conventions.
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.
Use when translating Python OOP/functional code to idiomatic Scala 2.13, covering class hierarchies, enumerations, error handling, and naming conventions
Reading and processing NetCDF outputs from models like GLM using Python and xarray.
How to implement custom loss functions in PyTorch. Use this skill whenever the user asks to implement a loss function, write a custom criterion, or mentions PyTorch tensor operations for backpropagation.
Implement loss functions in PyTorch with proper tensor operations.
Set up Python environments for NLP/ML projects using PyTorch, transformers, and TRL. Use this skill when installing dependencies for preference optimization, RLHF, or transformer-based training pipelines.
PyTorch patterns for implementing preference optimization losses (DPO, SimPO, etc.) for LLM training.
Guide for implementing preference optimization methods (DPO, SimPO, IPO) in PyTorch. Use when implementing loss functions for RLHF-style training.
Run PyTorch unit tests, save results to NumPy files, and log environment information for reproducibility. Use this skill when executing test suites for neural network functions, validating loss computations, saving tensor outputs for verification, and creating reproducibility logs with Python/package versions.
Use this skill to look up the four canonical tonal patterns for seven-character regulated verse (七律 Qilv). Provides exact 平/仄 sequences for all 8 lines under each of the four standard forms, plus the rule for checking positions 2, 4, 6.
How to compose a seven-character regulated verse (Qiyan Lushi). Use this skill whenever the user asks to write a seven-character regulated verse or traditional Chinese poetry, even if they don't explicitly mention the rules.
Rules for composing Chinese seven-character regulated verse (Qi Yan Lv Shi).
Rules and structure for composing Chinese seven-character regulated verse (七言律诗). Use this skill whenever composing, analyzing, or explaining 七言律诗, 律诗, or classical Chinese regulated verse — even if the user just says "write a Chinese poem" in a formal style.
Structural, syntactical, and tonal rules for composing a seven-character regulated verse (七言律诗).
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.
How to parse key-value pairs from a text file where keys and question values are stored together.
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.
Use this to ingest the task file and orchestrate the multi-step retrieval and formatting workflow.
Use when you need to read and parse CSV files from the filesystem in Python. Handles encoding, missing values, and returns structured data.
Use this skill to understand the exact Python source code in /root/Tokenizer.py before translating to Scala. This covers every class, method, regex pattern, enum value, default value, and metadata key that must be faithfully reproduced.
Use this skill to read and understand /root/TokenizerSpec.scala to determine the exact expected API signatures, imports, class names, method names, and enum values that the Scala implementation must match.
Compose Chinese five-character and seven-character regulated verse under a strict modern Mandarin rule set. Use this Skill when the user asks for five-character or seven-character regulated verse, wants a poem written in a disciplined regulated-verse form, or wants an existing regulated poem revised to fit strict line-count, character-count, 平仄, rhyme, title quality, thematic coherence, and poetic depth requirements. This Skill uses modern Mandarin tones for 平仄, Mandarin finals for rhyme, allows polyphonic characters if any non-neutral reading fits, ignores neutral tone unless no non-neutral reading exists, and emphasizes a fitting title, unified theme, meaningful progression, balanced middle couplets, and a resonant conclusion.
Comprehensive guide to seven-character regulated verse (七言律诗) format, structure, and tone patterns. Use this skill whenever composing classical Chinese regulated verse, especially when strict adherence to tonal patterns, line structure, and formal requirements is critical.
Applies the specific tonal patterns and rhyme requirements for a seven-character regulated verse to ensure classic prosody.
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 reproduce Deep Learning papers. Use this skill whenever the user asks to implement an algorithm, loss function, architecture, or technique based on an academic paper (PDF, Arxiv, etc).
Guidance on ensuring a consistent rhyme scheme in modern Mandarin for classical Chinese poetry, focusing on rhyming vowels.
Algorithmic planning of itineraries avoiding specific transport modes and allocating time based on budget constraints.
Use a distance matrix CSV to find travel time and distance between cities for self-driving trips.
Plan multi-city road trip routes using distance matrices and constraints
Determines the driving route from Minneapolis to Ohio, segments the 7-day travel period into manageable travel and stay durations, and ensures no flights are used.
How to load and filter CSV travel data in Python
How to serialize the final travel itinerary to a JSON file.
Improved 13F dataset analysis functions (includes better handling of TSVs).
Comprehensive guide for analyzing SEC 13-F quarterly filings data (TSV format) including fund lookup, AUM, holdings comparison, and stock investor analysis.
Analyze fund AUM, holdings count, and cross-quarter investment changes from SEC 13F filings.
How to correctly and robustly search for a fund manager's accession number in SEC 13F COVERPAGE.tsv.
How to calculate a fund's actual AUM and total unique stock count for modern SEC 13F data.
How to accurately identify stocks that "received increased investment" by checking both share count and dollar value change.
How to find top fund managers heavily invested in a particular stock across all data quality issues.
Advanced filtering for pet-friendly and cuisine-specific travel data.
Efficient and robust Pareto frontier calculation for multi-objective optimization.
Advanced PIL/Pillow techniques for depth effects, sophisticated shapes, and professional visual design
Selecting optimal projections for distance calculations in the Pacific.
Advanced document classification using weighted keyword scores and expanded subject vocabularies.
A skill for advanced technical illustration with Pillow, including complex hardware shapes, cooling fins, and annotation shelf-lines.
Advanced OpenCV template matching with dynamic threshold tuning, robust NMS filtering, and multi-scale detection for object counting in images.
Anthropic official brand colors, typography tokens, and design guidelines extracted from anthropic.com CSS.
Official Anthropic brand colors, typography, and styling instructions for technical posters and presentations.
A skill for managing and applying Anthropic's specific brand identity, including color tokens, typography fallbacks, and technical illustration standards.
Precise Anthropic brand color tokens and typography guidelines for design artifacts, with matplotlib-specific notes.
Handling the antimeridian (180/-180 longitude) in geospatial analysis with GeoPandas and Shapely.
Techniques for handling geometries that cross the 180/-180 degree longitude line.
Strategic color application following Anthropic brand standards for professional technical materials
Validate travel budget calculations including accommodation nights, meal costs, and constraint compliance.
Validate travel budgets using accommodation and restaurant data.
Comprehensive field mapping for California SC-100 Small Claims Court form with field IDs and filling guidance.
Refined techniques for composing classical Chinese regulated verse on war-and-peace themes, with verified imagery, couplet examples, and common pitfalls.
Comprehensive guidelines for composing a strict seven-character regulated verse (qiyan lvshi) based on modern Mandarin pronunciation, including advanced tonal rules.
Using Circe for JSON tokenization and dot-path navigation in Scala, with the exact APIs needed to replace Python's json module and dict traversal.
Detailed rules for seven-character regulated verse (七言律诗), including the "Sticky" (黏) and "Opposing" (对) rules.
Compute and aggregate F1 score and delta from clustering evaluation across images
Finding competitor product discussions, insights, and demo URLs across all ContentForce-related Slack channels
End-to-end solution for building multi-city travel itineraries with pet-friendly accommodations and diverse cuisine constraints.
Advanced techniques for composing seven-character regulated verse with thematic coherence
Improved keyword-based classification with confidence scoring, compound term detection, and refinement patterns
Find which funds hold a specific stock and rank them by holding value
Robust JSON-to-CSV parser for Trivy vulnerability reports.
Advanced CSV security report generation with validation, normalization, and comprehensive error handling
An advanced guide on generating a fully-featured CSV vulnerability report, featuring explicit filtering, missing data fallbacks, and strict header schemas.
Reliable CSV generation for security audits with automated field mapping.
Generate structured CSV security audit reports from Trivy JSON vulnerability data with deduplication, proper quoting, and field mapping.
Robust CSV loading and type coercion patterns for D3.js applications with multiple data sources
Generate and validate CSV files with data integrity checks, verification, and comprehensive error handling for reliable data export.
How to compute precomputed distance matrices for custom distance metrics in Scikit-Learn DBSCAN.
Implement weighted Euclidean distance metric for DBSCAN with shape parameter
Advanced robust CVSS extraction logic that correctly falls back across priority sources and handles missing values.
Extract CVSS v3 scores from Trivy vulnerability data with source priority fallback (NVD > GHSA > RedHat) and handle missing data gracefully.
Extract CVSS v3 scores from Trivy vulnerability JSON with source priority (NVD > GHSA > RedHat) and fallback to N/A.
Strategic CVSS score extraction with multi-source lookup, fallback handling, and NVD/GHSA integration
Creating D3.js v6 bubble charts with market cap sizing (scaleSqrt), sector coloring, inside ticker labels, and ETF uniform sizing — with correct tooltip suppression for ETFs.
Implementing force-directed bubble charts with category clustering and tooltips.
Production-ready D3.js bubble chart clustering with optimized force simulation and labeling
Optimized loading and pre-processing of CSV data for D3.js.
D3.js v6 force-directed bubble chart with sector clustering, collision avoidance, size mapping, and cross-component interaction.
Guide to building a polished D3.js (v6) force-directed bubble chart and a synchronized data table, including integrating secondary data for sparklines.
D3.js v6 force simulation for clustered bubbles by category using forceX/forceY anchors, forceCollide for no overlap, with truly deterministic initial positions.
Advanced clustering techniques in D3.js force simulations for compact and aesthetically pleasing layouts.
Improving interaction between D3 charts and HTML tables with selection events.
D3.js data table with exact column headers, formatted market cap, and bidirectional highlight with bubble chart.
Building a scrollable D3.js HTML table linked to a bubble chart with bidirectional click-highlight, correct scrollIntoView for overflow containers, and sector color badges.
Enhancing user experience with polished tooltips, table interactions, and smooth transitions.
Two-way synchronized selection between D3 visualization and HTML table with tooltips and scroll management
Aggregate and validate GitHub API data for metrics calculation with comprehensive error handling.
Using jq to compute statistics from GitHub API JSON responses including counts, averages, grouping, and label filtering.
Improved data querying skill for finding pet-friendly accommodations and specific restaurant cuisines in a given city.
Advanced filtering and validation of travel datasets with strict cuisine matching, budget constraints, and data quality checks.
Techniques for preparing and formatting data from JSON/API sources for inclusion in documents.
Efficient DBSCAN clustering with a custom parameterized distance metric using precomputed distance matrices for speed, plus centroid computation.
Implementation of DBSCAN with custom weighted Euclidean metric, optimized for parallel execution.
DBSCAN with custom weighted Euclidean distance metric for spatial clustering of annotations.
Refined skill for enforcing Anthropic corporate brand identity with precise HEX token usage.
Extract text from PDF, PPTX, and DOCX files for content classification, with error handling and fallback strategies.
Handle {{IF_X}}...{{END_IF_X}} conditional blocks in Word .docx templates — keep or remove content, with correct ordering relative to placeholder replacement.
Advanced techniques for Word document automation, including handling split runs, headers/footers, and complex conditionals.
A robust skill for template processing in DOCX files, handling placeholders and complex conditional blocks spanning multiple paragraphs.
Optimized Maven build command for Apache Druid to verify security patches.
Complete fix for Apache Druid CVE-2021-25646 JavaScript RCE via @JacksonInject override in all 7 affected components.
Complete guide to patching Apache Druid CVE-2021-25646 - JavaScript RCE via Jackson @JacksonInject bypass with empty JSON key
Securing Apache Druid JavaScript filters against unknown property injection attacks
Improved skill for creating and applying robust patches to the Druid source code, including verification steps.
A checklist for ensuring thorough patching of Apache Druid security vulnerabilities.
Parse USGS GeoJSON earthquake data into GeoPandas GeoDataFrame and output structured JSON results for geospatial analysis.
Comprehensive guide for retrieving structured information from enterprise JSON data files containing Slack messages, documents, meetings, and metadata.
Complete guide to retrieving structured answers from enterprise product JSON data files containing Slack, documents, meetings, and PRs
Advanced techniques for analyzing complex enterprise product JSON files containing messages, documents, and transcripts.
Advanced two-condition lookups in Excel using INDEX and MATCH with sheet-specific references in openpyxl.
Use INDEX&MATCH with two conditions (series code + year) to populate data tables in Excel from a source sheet, with proper anchoring for copyable formulas.
INDEX&MATCH for two-condition lookups in Excel, with correct absolute/mixed references for fill-down/fill-right
How to perform a two-dimensional lookup in Excel using either INDEX/MATCH or VLOOKUP/MATCH.
Calculating and formatting percentages in Excel with proper rounding and display
Calculating and rounding summary statistics like percentiles in Excel.
Excel statistical functions for datasets including MIN, MAX, MEDIAN, AVERAGE, QUARTILE, and SUMPRODUCT
Using Excel's statistical functions with rounding and percentage scaling in openpyxl.
Calculate GDP-weighted mean of net exports as % of GDP using SUMPRODUCT in Excel, including all supporting statistics (min, max, median, percentiles).
Verifying Excel formula results and handling errors using recalc.py and openpyxl.
Understanding scaling and execution of weighted means using SUMPRODUCT.
GDP-weighted mean and descriptive statistics for net exports as % of GDP in Excel
Weighted mean calculations in Excel using SUMPRODUCT and SUM in openpyxl.
Production-ready technique for technical exploded-view hardware diagrams in matplotlib, with layer details, annotations, and title blocks.
Improved layout strategy for technical exploded-view diagrams with better spacing and visual balance.
Extract key frames (I-frames) from a video file into a sequence of images using FFmpeg.
Advanced FFmpeg techniques for keyframe extraction with quality control.
Extract I-frame keyframes from video files using FFmpeg, with output verification and naming conventions.
Extract I-frame keyframes from video files using FFmpeg CLI, saving as zero-padded PNG sequences starting at 001.
Robust FFmpeg video frame extraction with error handling, alternative methods, and comprehensive frame selection strategies.
Improved keyword-based document classification with false-positive prevention, manual review of zero-score files, and post-classification verification.
Efficient recursive exploration and content searching across large datasets.
Safely moves files and validates the integrity of the organization process.
Robust file organization with verification, cleanup, and comprehensive logging
Robustly extracts text from PDF, DOCX, and PPTX files in Python using PyPDF2, python-docx, and python-pptx, suitable for document classification workflows.
Analyze individual fund holdings, AUM, and portfolio composition from 13-F data
Advanced fund analysis with share change verification to distinguish between price movement and deliberate investment.
Professional fund search with accession number verification and report type checking.
Fuzzy search for hedge funds or stocks by name in SEC 13F filings; handles cases where rank 1 is skipped due to amendment filtering.
Advanced handling of GeoJSON files in GeoPandas, emphasizing correct geometry formats and time processing to ISO 8601 standard.
Accurate geospatial distance calculations using GeoPandas with appropriate map projections for global-scale analysis.
Load and work with PB2002 tectonic plate boundary data using GeoPandas for spatial filtering and distance calculations, with antimeridian awareness.
Advanced guide on GeoPandas projections for accurate metric distance calculations without distortion using point-centric Azimuthal Equidistant CRS.
Improved guide for performing spatial joins with GeoPandas, specifically handling antimeridian crossing polygons like the Pacific Plate.
Geospatial data analysis with geopandas for distance calculations, filtering, and modern API usage.
Mastering GitHub API interactions using curl, including search, pagination, and rate limit handling.
How to identify bug report issues and count resolved bugs in a date range from GitHub Search API results.
How to compute PR statistics (merged, closed, avg_merge_days, top_contributor) from GitHub Search API items using Python.
Using the GitHub REST Search API to query PRs and issues with date filtering, pagination, and field extraction.
How to query the GitHub Search API for PRs and issues with date filtering, handling pagination and unauthenticated access via Python urllib.
Advanced skills for fetching, filtering, and aggregating GitHub data using `gh` CLI and `jq`.
Provides a robust python module for querying GitHub's search API using urllib with automatic pagination.
Query GitHub REST API with pagination and date filtering for repository data (PRs, issues).
How to run and calibrate GLM3 for lake temperature simulation - includes correct parameter effects, grid search strategy, and verified working parameter ranges.
This skill covers the process of calibrating GLM by iterating through parameters within allowed bounds and verifying metrics against observations.
Instructions for modifying GLM parameters using regex and systematically optimizing them within physical limits.
Two-phase grid search calibration for GLM parameters with parameter sensitivity analysis and regex-based nml editing.
Advanced GLM configuration and calibration strategies for vertical temperature profiles.
Diagnosing temperature profile mismatches and simulation errors in GLM outputs
Robust GLM evaluation methods for deep and summer water temperatures.
Complete guide to setting up, running, and configuring the General Lake Model (GLM) for 1D lake temperature simulation.
How to read GLM3 NetCDF output (shape/dimension details verified) and extract simulated temperature profiles matched to field observations.
Exact RMSE metric computation for GLM lake temperature evaluation - verified matching procedure with correct threshold values.
Greedy matching of predicted centroids to expert points by closest pairs first, with max distance threshold, computing F1 and delta.
Greedy one-to-one matching of cluster centroids to expert points with maximum distance constraint
Complete workflow for finding top stock increases/decreases between Q2 and Q3 for a specific fund.
Enhanced skill for programmatic design, incorporating system-level dependency management for image generation libraries.
Convert PNG images to grayscale inplace using ImageMagick; covers both keyframes and template images for consistent matching.
Convert a batch of images to grayscale in-place using ImageMagick's mogrify command.
Performs image format conversion and color space modification using ImageMagick tools.
Efficient inplace image processing using ImageMagick's mogrify.
Robust image processing with format conversion, in-place modification, and comprehensive verification of image properties.
Improved itinerary builder focusing on constraint adherence, logically connecting cities, and robust JSON schema generation.
Explore and query travel dataset files (CSV/TXT) to find cities, restaurants, accommodations, attractions, and driving distances — with precise filtering patterns and data field notes.
Plan 7-day itineraries with logical city transitions and transport.
Optimized itinerary building with cuisine distribution, cost tracking, and multi-city routing for pet-friendly travel.
Build a multi-city road-trip travel itinerary from dataset files with complete budget tracking, pet-friendly constraints, cuisine coverage, and correct JSON output format.
Plan multi-city driving itineraries with proper day allocation, cuisine variety, and format compliance.
Detailed explanation of the Jackson empty key ("") vulnerability and how it bypasses @JacksonInject security.
Security guide for Jackson @JacksonInject vulnerabilities - how attackers override injectable values via JSON and how to prevent it
Preventing Jackson @JacksonInject bypass via empty JSON keys by using OptBoolean.FALSE to reject user-supplied input for injected parameters.
Security considerations for Jackson JSON deserialization in Java, focusing on @JacksonInject bypass vulnerabilities via empty property names ("").
Creating and applying security patches for Jackson deserialization vulnerabilities in Java
Deep parsing and structural querying of nested JSON documents, resolving implicit relations across multi-modal corporate datasets like Slack messages and PRs.
Skill for parsing JSON files.
Provides advanced techniques for reading, parsing, and structured writing of JSON data, including complex filtering and aggregation.
Validate, format, and write JSON output with schema enforcement and error handling.
Classify academic papers into subject categories using weighted keyword matching with regex word boundaries and case-insensitive search.
Classifies unstructured text into specific categories based on keyword presence, falling back to a default category when no matches are found.
Advanced vocabulary and poetic devices for expressing suffering, war, and the hope for peace from an ordinary person's perspective.
Comprehensive rhyme groups for modern Mandarin (新韵), ensuring consistent rhyming throughout the poem.
Detailed guide to modern Mandarin rhyming and tone classification for classical Chinese poetry, including common pitfalls.
Production-ready market cap formatting with consistent decimals, edge case handling, and pre-computation
Efficient greedy matching of cluster centroids to expert points with distance constraint.
Greedy point matching and calculation of F1 score and average distance (delta).
Complete guide to generating polished technical poster PNGs with matplotlib, including typography, pseudo-3D layers, and annotations.
Advanced techniques for rendering 2D isometric exploded views of hardware using Matplotlib.
Improved skill for building Apache Druid with Maven, focusing on skipping non-essential tasks efficiently.
Building Apache Druid with Maven while maintaining security patch integrity and skipping unnecessary checks
Schedule multiple meeting requests into a calendar with earliest-first logic, then generate formatted reply .txt files and a results.json summary.
Schedule meetings into calendar free slots considering time constraints, timezone conversion, and blue-block overrides.
Provides guidelines on modern Mandarin pronunciation and rhyming for classical forms.
Implementing two-condition lookups in Excel using INDEX/MATCH with proper sheet references
Unified multi-format extraction for PDF, DOCX, and PPTX with consistent output and quality metrics
This skill covers using the netCDF4 library for reading simulation outputs in Lake Mendota GLM modelling.
Advanced matching of time-varying GLM simulation depths with observation data
Extracting GLM NetCDF output and computing exact RMSE metrics via datetime+depth merge against field observations.
Instructions for safely parsing GLM NetCDF output with netCDF4 and correctly executing an exact datetime + rounded-depth merge.
Complete setup guide for reproducing NLP paper results with HuggingFace TRL/transformers on Python 3.12 - use when setting up environments for preference optimization experiments.
Complete NML-based GLM calibration workflow with validation and verification
Enhanced npm vulnerability scanning with Trivy supporting multiple severity levels and complete metadata extraction
Count template objects in keyframes using count_objects.py; parse integer from output string and generate a CSV with results per frame.
Count the number of object occurrences in an image using OpenCV template matching in Python.
Robust object counting using template matching with parameter tuning.
Counts object occurrences in an image using OpenCV template matching with non-maximum suppression.
Convert images to grayscale in-place using OpenCV, including both keyframes and template images.
Using openpyxl to edit Excel workbooks with cross-sheet formulas while preserving all formatting
Safely insert Excel formulas into specific cells using openpyxl without altering formatting, colors, or structure of existing workbooks.
Efficient DBSCAN implementation by caching distance matrices for repeated hyperparameter evaluations.
A refined output generation skill that precisely templates text files and correctly constructs the requested JSON log.
Find top fund managers holding a specific stock (by CUSIP) using a fixed version of the holding_analysis workflow.
Parallel DBSCAN hyperparameter grid search with joblib for Mars cloud clustering.
Efficient parallel hyperparameter grid search using joblib with 847 combinations
Structured approach to grid search with nested loops and parallelization.
Advanced usage of joblib for parallel execution of grid search tasks, including result flattening.
Systematic parameter search strategies for GLM calibration with multiple metrics
Computing the Pareto frontier for multi-objective optimization (maximize F1, minimize delta) with correct dominance handling and output formatting.
Find Pareto-optimal solutions balancing multiple conflicting objectives with rigorous verification
Identifying the Pareto frontier for a set of results, efficient implementation.
Identifying Pareto-optimal solutions for multi-objective optimization (maximize F1, minimize delta).
Finding the Pareto frontier for multi-objective optimization using dominance conditions.
Precisely parse a PDF day-view calendar to extract event times, durations, and colors by reading visual block positions and the 15-minute grid.
Extract calendar events from PDF by mapping colored rectangles to a 15-min grid using PyMuPDF.
Robust PDF text extraction with fallback strategies and error handling for academic papers and documents
Skill for extracting text and layout.
Techniques for mapping case descriptions to PDF form fields.
A comprehensive skill for mapping, understanding, and filling complex interactive PDF forms using PyMuPDF (fitz).
Improved skill for filling XFA/non-standard PDFs using FreeText annotations when field mapping is unavailable.
Complete workflow for filling fillable PDF forms using Claude Code PDF skill scripts with pypdf.
Advanced techniques for filling PDF forms with fillable fields.
An improved skill to programmatically parse PDF calendars, mapping drawing coordinates to precise time intervals using PyMuPDF.
Advanced PDF parsing for calendar extraction, including sidebar filtering and color-based classification.
Fill PDF forms using the PDF skill's form-filling scripts and workflow
Extract text from PDF files using PyPDF2 with pdfplumber fallback; optimized for title/abstract extraction for classification.
Extract calendar event times by analyzing visual block positions relative to hour markers
Guide for composing a classical Chinese poem on the theme of peace, covering thematic structure and literary devices.
Pillow techniques for technical posters including 3D layers, annotations, and balanced layouts.
Robust pattern-based template processing with conditionals, data validation, and comprehensive placeholder replacement.
Finding earthquakes within tectonic plates and computing distances to plate boundaries using PB2002 data.
Advanced guidance for writing regulated verse, covering parallelism, rhythm, and emotional depth.
Extract text from PPTX and DOCX files using python-pptx and python-docx, including tables and all shapes.
Professional technical diagram layout with grid systems, visual hierarchy, and spatial organization
Procedures for aligning a project-specific environment to its `environment.yml` and project-root structure.
Advanced Word document manipulation using raw XML regex replacements to perfectly preserve formatting across split text runs.
Working with Word documents (DOCX) using python-docx library with proper text replacement strategies.
Replace {{PLACEHOLDER}} tokens in Word .docx templates using python-docx, correctly handling split runs, nested tables, headers/footers, and verification.
Robust python-docx template filling that handles split runs, conditional sections, nested tables, headers, and footers.
Translating Python @dataclass and Enum to Scala case class and Enumeration/Sealed Traits safely
Translating Python generics (TypeVar covariant/contravariant) to Scala generics (+T, -T) with examples
Parsing and handling JSON safely in Scala using io.circe
Translating Python Union types and @overload to Scala method overloads, type classes, and pattern matching
Environment setup and testing patterns for SimPO preference optimization with PyTorch.
A refined skill to implement SimPO (Simple Preference Optimization) loss in PyTorch, precisely matching the official paper implementation without a reference model.
Robust PyTorch tensor operations for implementing loss functions, including handling device placement and numerical stability.
Complete rules, structure, and verification checklist for seven-character regulated verse (七言律诗), with corrected rhyme groups and parallel couplet standards.
Compare holdings across quarters to identify increased/decreased investments
How to assemble and write a structured JSON report for GitHub community pulse statistics with validation.
Parse meeting requests with timezone handling and constraint detection
Robust Python logic for community pulse metrics with substring label matching and precise PR status handling.
Procedures for resolving environment conflicts, broken packages, and restricted system-wide access in Python.
Robustly extracts text from various document formats with multiple fallback options.
SC-100 California Small Claims form field ID mappings and data entry guidelines
How to fill California SC-100 Small Claims Court PDF form using fillable field IDs; includes complete field mapping, checkbox behavior, and field fill strategy.
Implementing an immutable fluent builder in Scala with companion object apply, varargs metadata, and a build() method returning a function — translating Python's mutable builder class.
Using circe for JSON tokenization in Scala, including printing, cursor navigation, and path-based access.
Idiomatic data modeling with case classes, sealed traits, and exhaustive matching.
Robust temporal tokenization with Java 8 Time API and DateTimeFormatter.
Refined FP patterns for Functors and Monads in Scala, including applicative.
Idiomatic Scala patterns for translating Python code including enums, case classes, and naming conventions.
Implementing the builder pattern in Scala using immutable case classes or private constructors with copy.
Idiomatic JSON handling using Circe.
Improved JSON path navigation using Circe cursors in Scala.
Enhanced numeric tokenization with BigDecimal and precision in Scala.
Handling absence and nullability in Scala using Option, with patterns for translating Python None handling.
Translating Python Enum and frozen dataclass to idiomatic Scala sealed ADTs and case classes, with precise metadata typing and withMetadata pattern.
Idiomatic Scala testing patterns with ScalaTest.
Robust text tokenization with regex and position tracking in Scala.
Translating Python Protocol, ABC, and isinstance dispatch to Scala traits, overloaded methods, and functor/monad abstractions.
Implementing type classes for extensible, ad-hoc polymorphism.
Translating Python TypeVar covariant/contravariant generics to Scala variance annotations, with concrete patterns for containers, sinks, and handlers.
Expressing variance annotations in Scala generics when translating from Python TypeVar covariant/contravariant types.
Skill for scheduling meetings.
An improved scheduling algorithm to find the earliest compatible free slots under time constraints.
Advanced scheduling with priority-based sorting (EDF) and flexible slot overwriting.
Load and parse SEC 13-F TSV files with proper data type handling and validation
Comprehensive rules, tonal patterns, and verification checklist for composing a seven-character regulated verse (七言律诗).
Detailed SimPO implementation logic covering reward formulation and margin-based loss computation.
Complete implementation of the SimPO (NeurIPS 2024) loss function with all variants and edge cases - use when reproducing SimPO or implementing reference-free preference optimization.
Complete SimPO loss implementation with exact formula derivation from the paper.
Precision implementation of SimPO (Simple Preference Optimization) loss with length-normalized rewards and configurable margin.
Complete SimPO loss implementation with length-normalized rewards and target margin
Testing SimPO loss function with fixed tensors and output verification
Proper initialization of SimPOTrainer with model loading and args setup
Advanced patterns for analyzing Slack conversations to extract reviewers, competitor insights, and shared resources from enterprise product channels.
Robust stock analysis and holder identification, bypassing file path issues in default scripts.
Robust data cleaning and formatting for financial datasets in D3.js.
Tune OpenCV template matching parameters (threshold and dedup distance) for accurate object counting in pixel-art games.
Format dates and times with strict adherence to required formats
Convert between US time zones for scheduling, defaulting unspecified zones to calendar timezone.
Convert US time zones to the calendar's local timezone, correctly handling Daylight Saving Time for dates in March through November.
Detailed tonal pattern requirements for seven-character regulated verse in modern Mandarin
Extract and validate travel data from CSV/TXT databases ensuring city-specific matching and constraint compliance.
Run Trivy in offline mode to identify high and critical vulnerabilities in package-lock.json with specific flag usage.
A complete guide to executing Trivy in offline mode via Python `subprocess` to scan dependency files for vulnerabilities.
Optimized Trivy offline scanning for lock files, including all dependency types.
Use Trivy vulnerability scanner in offline mode to discover security vulnerabilities in dependency files, covering setup, execution, and JSON output parsing.
Use Trivy vulnerability scanner in offline mode to scan dependency lock files and produce JSON vulnerability reports without internet access.
Precise identification of user roles and their contributions to product discussions and competitor analysis.
Comprehensive checklist to verify a completed seven-character regulated verse meets all requirements
Extracts all key frames from a video file into a specified output directory using FFmpeg.
Generate structured CSV security audit reports from Trivy JSON output with severity filtering, deduplication, and proper field mapping.
Robust extraction of vulnerability metadata with CVSS v3 priority and v2 fallback.
Improved Excel data analysis and formula manipulation using openpyxl.
Executes the GLM simulation and retrieves lake-specific depth data to ensure accurate mapping between model output and field observations.
Use this skill to execute the SimPO unit test with Python 3.10, save the loss results to /root/loss.npz, and log Python version and package info to /root/python_info.txt using the correct Python 3.10 executable.
Use this skill to run Trivy in offline mode against /root/package-lock.json and produce the security audit CSV at /root/security_audit.csv. Use only after locating the trivy cache directory.
Executes the provided unit test to verify the SimPO loss implementation and saves the output to a specific NPZ file for evaluation.
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 this skill to write a modified python-docx Document object back to a .docx file, handling file paths and permissions correctly.
Use this skill to extract and organize case data from a natural language case description for filling the SC-100 form. Maps case facts to form fields.
How to map and fill the California Small Claims Court form SC-100 (Plaintiff's Claim and ORDER to Go to Small Claims Court). Use this skill whenever the user mentions filling an SC-100 form or filing a small claims case in California.
Map case information to California Small Claims Court Form SC-100 fields. Use this skill whenever you need to fill the SC-100 form, understand its structure, extract field names, or map plaintiff/defendant information to the correct form sections.
Define idiomatic Scala 2.13 type hierarchies and domain models, replacing Python's class structures and Enums with traits and case classes.
Translating Python Enums and Protocols to Scala sealed traits and algebraic data types
Aligning the implementation with provided Test Specifications.
How to use circe for JSON processing in Scala. Use this skill whenever translating Python json operations to Scala or working with circe libraries.
Guide for using Circe in Scala 2.13 for parsing and generating JSON, specifically when translating Python JSON handling.
Working with Circe JSON library in Scala for type-safe JSON processing
Scala collections, iterators, and functional programming patterns for Python developers
Modeling domain entities and transformations using case classes, companion objects, and type-safe hierarchies.
Translating Python dynamic structures into type-safe Scala ADTs and case classes.
Implement a fluent Builder pattern in Scala to provide a clean API for object configuration and instantiation.
Implementing tokenization logic using functional patterns and standard library collections.
Guide for creating functional fluent builders in Scala.
Handling absence of values and errors in Scala using Option, Try, and Either instead of nulls and exceptions.
Idiomatic functional programming in Scala using sealed traits, pattern matching, and Option/Either for robust error handling.
Implement idiomatic Scala logic for parsing temporal/numeric data and handling batch processing using functional transformations and error types.
Functional programming patterns in Scala for data transformation, collection processing, and batch operations suitable for distributed systems.
Translating Python generic types, variance, and type bounds to Scala 2.13
| 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.
Guide for translating Python TypeVars and generics to Scala covariant and contravariant types.
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.
Building immutable configurations with fluent method chaining in Scala
Implementing the Builder pattern idiomatically in Scala using case classes and the copy method for immutability.
| 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.
Working with Java's LocalDate and LocalDateTime in Scala for temporal tokenization
Guide for translating Python @overload and dynamic typing (Any, Union) to Scala method overloading and type matching.
Scala-specific naming conventions, code organization patterns, and style guidelines that differ from Python conventions.
Translating Python's None/Optional to Scala's Option, Either, and Try types
Type-safe dispatch using Scala pattern matching for polymorphic operations
Using regular expressions for text tokenization and parsing in Scala using the scala.util.matching.Regex API.
String manipulation, formatting, and regex patterns in Scala
Scala's type system features, testing patterns, and integration with test specifications for ensuring correctness of translated code.
Use when implementing tokenizer abstractions in Scala 2.13 — covers Token/TokenType ADTs, tokenizer traits, builder pattern, and batch processing conventions
Use this skill when writing /root/Tokenizer.scala. It provides the concrete implementation strategy, Scala idioms, and compilation workflow for translating the Python Tokenizer to Scala 2.13.
| temporal types (LocalDate/LocalDateTime), and functional tokenization pipelines. Use when implementing tokenizer classes, handling JSON structures, or building fluent APIs.
How to structure abstract base classes, trait hierarchies, and inheritance patterns in Scala for the tokenizer domain.
| 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.
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.
Use this skill at the start to scan the source directory, identify all files, create a processing plan, and establish the destination folder structure.
Uses regular expressions to parse dates, time ranges, and durations from natural language text like meeting requests.
Find the earliest available meeting slots for multiple requests, treating blue blocks as available and updating the schedule state after each assignment.
Algorithm to find earliest available meeting slots given constraints and existing appointments.
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.
Fuzzy search the COVERPAGE data to find the specific accession_number for a hedge fund in a given quarter.
Find the CUSIP (Committee on Uniform Securities Identification Procedures) identifier for a specific company or stock.
Parse and analyze SEC 13-F filing TSV datasets to extract AUM, holdings count, and fund details by accession number.
Analyze SEC 13F filings data from TSV files. Use this skill whenever the user asks about hedge fund holdings, AUM (Assets Under Management), stock positions, fund managers, or any analysis of 13F filings data. Triggers on questions about fund portfolios, investment positions, quarterly comparisons, or SEC filing data stored in COVERPAGE.tsv, INFOTABLE.tsv, SUMMARYPAGE.tsv files.
How to compare fund holdings between Q2 and Q3 to find top stocks with increased investment by dollar value
Understanding SEC 13-F filing data structure, TSV format, and key tables for hedge fund analysis
Understanding the structure of SEC 13F filing datasets stored in /root/2025-q2 and /root/2025-q3 folders, including available scripts and data files
How to analyze a fund's AUM and stock count using accession_number, with proper filtering of options and deduplication. Covers Q1 (AUM) and Q2 (stock count).
How to fuzzy search for a fund in COVERPAGE.tsv to find its accession_number, using either built-in scripts or manual search
Generate structured CSV security audit reports from vulnerability data with proper formatting and schema validation. Use this skill whenever you need to export vulnerability records to CSV format with consistent field ordering, proper escaping, and RFC 4180 compliance.
Generate structured CSV security audit reports from vulnerability data with proper filtering, formatting, and field mapping.
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.
Construct the final CSV output file ensuring strict column compliance with the security audit requirements.
Maps documents to specific categories using a combination of keyword-based semantic matching and categorical hierarchy.
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.
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.
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.
Composing a Chinese Seven-Character Regulated Verse (七言律诗) following strict traditional structural, tonal, and rhyming rules using modern Mandarin.
Use this skill when composing a seven-character regulated verse (七言律诗) to ensure correct structural requirements including rhyme scheme, parallelism (对仗), thematic progression, and formatting rules.
Use this skill when composing a seven-character regulated verse (七言律诗) to ensure strict compliance with tonal patterns (平仄). This skill defines the four canonical tonal forms, provides a character-by-character verification method, and enforces a pattern-first composition workflow.
Master the structure, tonal patterns, and rhyming requirements of classical seven-character regulated verse (七言律诗) in Chinese poetry.
Rules and structure of Chinese seven-character regulated verse (七言律诗), including tonal patterns, parallelism, and rhyme schemes.
Guidance on composing seven-character regulated verse (七言律诗). Use this skill whenever a task requires writing traditional Chinese poetry in the seven-character regulated style, ensuring adherence to structural, parallelism, and rhyming rules (using modern Mandarin pronunciation).
How to set up the correct Python environment for the SimPO project, specifically using Python 3.10 and resolving version conflicts. Use this when setting up the environment to run SimPO code and unit tests.
Guidelines for implementing the SimPO loss function as per the SimPO paper.
Implement the SimPO (Simple Preference Optimization) loss function for LLM alignment. Use this skill whenever implementing SimPO training objectives, reference-free reward optimization, or Bradley-Terry preference loss with target reward margin. Triggers on: SimPO, preference optimization loss, average log probability reward, gamma margin.
Implements the SimPO (Simple Preference Optimization) loss function from the paper "SimPO: Simple Preference Optimization with a Reference-Free Reward". Use this when implementing or understanding SimPO training objectives.
SimPO (Simple Preference Optimization) loss computation for LLM alignment without a reference model.
Implement SimPO loss with length-normalized rewards and target margin.
How to implement the SimPO (Simple Preference Optimization) loss function based on the SimPO paper. Use this when implementing the simpo_loss method in SimPOTrainer.
Implements the Simple Preference Optimization (SimPO) loss function in PyTorch, focusing on length-normalized log probabilities and target reward margins.
Guidelines for implementing the SimPO (Simple Preference Optimization) loss function for NLP model training. Use this skill when modifying trainers or implementing preference-based loss functions in transformer projects.
Implements the SimPO loss function using stable log-probability operations in the specified trainer file.
How to correctly run the SimPO unit test to generate the loss.npz output file with reproducible results. Use when executing the unit test after implementing the loss function.
Create modular skill documents (SKILL.md files) for Claude Code. Use this skill whenever a task requires generating reusable knowledge documents, capturing domain expertise, or building skills that encode workflows, APIs, or specialized techniques. Invoke this whenever you need to write a SKILL.md from scratch, even if the user doesn't explicitly ask for a "skill".
> Analyze Slack message threads to identify participants, extract insights, and find shared resources. Use this skill when tracing who contributed to discussions about documents, competitor products, or shared URLs/demos in enterprise Slack data.
Validate spatial analysis results to ensure correctness of point-in-polygon and distance calculations.
Calculate the shortest distance between points (earthquakes) and a complex line geometry (plate boundaries).
Methods for filtering GeoDataFrames based on spatial relationships like containment and intersection.
Provides techniques for performing spatial operations like joins, contains, and distance calculations to identify relations between geographic features.
Perform descriptive statistical analysis while ensuring results are displayed as percentages rounded to one decimal place.
Load, parse, and transform stock market data from CSV files for D3 visualization. Use this skill when working with financial CSV data, handling missing values (ETFs often lack market cap/country data), formatting market capitalization as human-readable strings (1.64T), and preparing data for both visualization and table display. Essential for stock dashboards, portfolio analytics, and financial data pipelines.
Defines the layout, chart aesthetics, and table styling in style.css.
Maps extracted text to one of the 5 defined subjects.
Complete workflow for analyzing Super Mario game video frames and generating statistics. Use this skill when you need to extract video frames, process them for analysis, count game objects using template matching, and generate CSV reports of game element statistics.
Implement click handlers on both bubble chart and data table that maintain synchronized highlighting/selection state across both visualizations
Guidelines for creating technical exploded-view diagrams. Use this skill whenever drawing hardware, internal components, or technical exploded views.
> 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".
Use this skill when creating a technical exploded-view diagram poster of a hardware device. Covers layout, layer spacing, annotation style, and rendering approach using Python Pillow.
Provides the workflow for creating minimalist, low-saturation technical illustrations using the Nova device as a template.
Techniques and Python script patterns for generating technical exploded-view illustrations, including component layering, annotation leader lines, and isometric projection basics. Use this skill when generating hardware diagrams or exploded views.
Design principles and techniques for creating technical exploded-view diagrams and engineering documentation posters.
Guide for generating technical exploded-view posters using Python (PIL/Pillow). Use this skill when creating engineering diagrams, hardware breakdowns, or product teardowns that require precise layer visualization, annotation leader lines, and technical accuracy. Includes methods for drawing components, layering, annotation, and exporting high-quality images.
> 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.
Count specific objects in images using template matching with reference object images. Use this skill when you need to detect and count game elements, sprites, or recurring visual patterns in screenshots or game frames using a template image as reference.
Count occurrences of objects in images using OpenCV template matching. Use this skill when the user needs to detect and count specific objects (coins, enemies, items) in game screenshots or similar images using a reference template image.
Process templates with placeholder substitution and conditional sections
Classifies text into predefined categories using keyword matching heuristics.
Calculate average time-to-merge from PR creation to merge timestamps, handling edge cases like unmerged and closed PRs. Use this skill whenever computing PR velocity metrics, measuring merge turnaround, or analyzing PR lifecycle duration.
Convert meeting availability times between different timezones (e.g. PST to EST). Use when a meeting request specifies availability in a timezone different from the calendar's timezone.
Count tokens consumed during data retrieval operations, validate numeric format, and write results to /root/answer.json with proper structure.
Skill to estimate the number of consumed tokens for the task.
Methods for calculating or retrieving the number of tokens consumed during an LLM inference task.
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.
Distribute a total travel budget across accommodations, meals, transportation, and attractions while tracking spending against real data. Use this when ensuring costs stay within specified limits.
Optimize travel costs including accommodations, meals, transportation, and attractions while respecting budget constraints. Use this skill whenever building a trip with specific budget limits that require cost calculation, price comparison, or financial constraint satisfaction. Essential for maximizing trip value within fixed budgets.
Parse and search travel-related databases including cities, accommodations, restaurants, attractions, and distances. Use this skill whenever building a travel itinerary that requires querying real-world data from CSV files or text databases. This skill helps extract relevant POIs, lodging, dining, and routing information from structured datasets.
Look up travel data from the local CSV/TXT database for cities, restaurants, accommodations, attractions, and distances. Use this skill whenever planning a trip, building an itinerary, or querying travel-related datasets in /app/data/.
Query and filter travel CSV datasets (restaurants, accommodations, attractions, distances) using Python. Use this skill whenever you need to extract specific records from the travel database files, check pet policies, filter by cuisine, look up driving times, or validate that a city exists in the dataset.
Querying travel planning datasets (cities, restaurants, accommodations, attractions, distances) for itinerary generation.
Use this skill to query the local databases for distances, cities, accommodations, restaurants, and attractions to gather real-world data for an itinerary.
How to query and filter travel itinerary datasets (restaurants, accommodations, attractions, distances) to build constraint-satisfying travel plans.
Build a structured multi-day travel itinerary JSON from real CSV datasets. Use this skill whenever the user asks to create a travel plan, trip itinerary, or vacation schedule from a local database of cities, restaurants, accommodations, and attractions.
Invoke this skill when performing travel planning. It defines a structured workflow for generating itineraries. Following this workflow is essential to ensure the final plan satisfies user requirements.
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.
Performing offline security audits on package-lock.json files using Trivy.
Use Trivy for offline vulnerability scanning of dependency files like package-lock.json.
Use Trivy vulnerability scanner in offline mode to discover security vulnerabilities in dependency files.
Use Trivy vulnerability scanner in offline mode to discover security vulnerabilities in dependency files. This skill covers setting up offline scanning, executing Trivy against package lock files, and generating JSON vulnerability reports without requiring internet access.
Use Trivy vulnerability scanner in offline mode to discover security vulnerabilities in dependency files without internet access.
Use Trivy vulnerability scanner in offline mode to detect CVEs in npm dependencies and generate structured JSON reports.
Setup and installation of TRL (Transformer Reinforcement Learning) library with compatible torch/transformers versions. Use when setting up preference optimization training environments.
Creates an orchestration script to run the immutable unit test and capture the output loss values.
Safely updates specific calibration parameters in the glm3.nml file using f90nml, maintaining correct namelist group mapping and file integrity.
Load, parse, and process USGS earthquake data in GeoJSON or JSON formats.
Parse and work with USGS earthquake GeoJSON data, extracting IDs, magnitudes, coordinates, times, and place descriptions.
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.
Check that all 4 rhyme characters (lines 2, 4, 6, 8) belong to the same modern Mandarin rhyme family by comparing their finals and tone patterns. Use Xinhua Dictionary or online Mandarin phonetic tool to confirm final identity (e.g., -ing, -ang, -ong) and ensure all 4 characters have identical tone classification (all 平, or all 仄) in the rhyme position.
Use this skill to extract keyframes from video files using FFmpeg. It covers selecting the right extraction frequency and naming conventions for image sequences.
Extract key frames (I-frames) from video files using FFmpeg. Use this skill whenever the user needs to pull keyframes, thumbnails, or important frames from MP4, MKV, AVI, or other video formats. Outputs PNG image files named with zero-padded indices (e.g., keyframes_001.png).
Use this skill to extract key frames from MP4 video files into a target directory.
Use ffmpeg to extract keyframes from a video file into a target directory.
Extract key frames (I-frames) from video files using FFmpeg.
Extract key frames (I-frames) from video files using FFmpeg. Use this skill when the user needs to pull out keyframes from MP4, MKV, AVI, or other video formats for analysis or processing.
Use this skill to extract keyframes (I-frames) from an MP4 video file using ffmpeg. This produces numbered PNG files in a specified output directory.
Tools and techniques for extracting keyframes and processing video files using FFmpeg.
Extract keyframes from MP4 video files and convert them to grayscale. Use this skill when you need to process video files for analysis by extracting I-frames (keyframes) and converting them to grayscale images for computer vision tasks.
Implements the D3.js force simulation, tooltips, and data interaction logic in visualization.js.
How to generate a properly formatted CSV security audit report from vulnerability scan results, including handling of special characters and proper escaping.
Generate structured CSV security audit reports from vulnerability data with proper filtering and formatting.
Generate structured CSV security audit reports from Trivy JSON vulnerability data with severity filtering and proper field mapping.
Generate structured CSV security audit reports from vulnerability data with proper filtering and formatting. This skill covers CSV schema design for security reports, using Python csv.DictWriter, severity-based filtering, and field mapping from JSON to tabular format.
Process vulnerability scan results from Trivy JSON output, extract HIGH/CRITICAL severity vulnerabilities with complete metadata (CVE, CVSS scores, fix versions, references). Use this skill whenever you need to transform raw vulnerability data into structured format with proper field mapping and CVSS score prioritization.
Extracting specific security metadata (CVE, CVSS, Fix versions) from structured vulnerability reports like npm audit JSON or OSV.
Classical Chinese poetic imagery and techniques for war and peace themes. Use this skill when composing or analyzing Chinese poetry about war, peace, soldiers, refugees, or the suffering of common people during conflict.
Guide to expressing war suffering and peace longing in classical Chinese poetry. Use this skill when composing regulated verse about conflicts, depicting the human cost of war from ordinary perspectives, and yearning for peace through traditional imagery and metaphors.
Computing RMSE (Root Mean Squared Error) and other metrics for water temperature model validation. Use this skill whenever you need to match simulated temperatures with field observations, compute RMSE by depth categories, calculate annual/seasonal subsets, or prepare model evaluation metrics. Essential for lake model calibration and validation workflows.
How to calculate weighted means in Excel using SUMPRODUCT. Use this skill when calculating the weighted average for a group (e.g., GCC Countries) by multiplying values by their corresponding weights (e.g., GDP).
Calculate a weighted average using SUMPRODUCT when weights and values have a one-to-one correspondence. Use this for computing aggregate statistics where different entities have different importance (weights).
Calculate the weighted mean by multiplying Net Exports % by the corresponding GDP values and dividing by the total GDP.
Replace placeholders in Word documents (.docx files) and handle conditional sections. Use this skill whenever you need to fill in {{PLACEHOLDER}} markers in a .docx template, or when working with conditional blocks like {{IF_CONDITION}}...{{END_IF_CONDITION}}.
Compile PR and issue metrics into a report.json file at /app/report.json using the required schema for the December community pulse write-up.
Use when generating all files for a single-page web app: index.html, CSS, and JS. Ensures correct relative paths, proper script loading order, and valid HTML structure.
Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas
Common operations and patterns for using the xlsx skill tool to manipulate Excel files programmatically.
Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.
Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.
Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.
Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks
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