SkillEvolBench

Verify that citations in a document accurately represent their sources. Use this skill when a paper, review article, report, or essay makes claims about external sources and the task is to check whether those cited sources actually support the attributed statements. Focus on verifying that claims, quotes, and numerical assertions are supported by the cited source content.

Generate summaries that must satisfy explicit constraints such as a word limit, required key points, and a requested presentation format. Use this skill when the task is to condense a long document into a shorter summary while staying within a stated word cap, ensuring required points are included, and checking the final draft against those constraints before returning it. Focus on word-limited summaries with required key point coverage.

Draft professional reply emails that reference the prior context of a business email thread. Use this skill when a user provides a thread of 3-5 messages and wants a reply that reads the conversation history, identifies the latest question or request, answers it directly, references relevant earlier context when helpful, and matches the tone of the original sender. Focus on concise professional reply drafting for standard business email threads.

Find direct factual contradictions between multiple information sources. Use this skill when two or more documents make claims about the same facts and the task is to extract those claims, group them by topic, compare the stated values, and report any contradictions with their sources. Focus on direct factual contradictions such as different numbers, dates, names, or statistics for the same fact.

Convert flat documents from one format to another while preserving source content. Use this skill when the task is to migrate content such as Markdown, CSV, or simple key-value text into JSON, and the goal is to keep all body content represented in the target format. Focus on flat-format migration with explicit source-to-target mapping, parser-based conversion, and a final source-versus-target verification step.

Diagnose and resolve Python package version conflicts in pip-based projects. Use this skill when `pip install` fails with resolver errors, when `pip check` reports incompatible versions, or when a Python project's dependency graph contains conflicting version constraints that must be reconciled in `requirements.txt` or `pyproject.toml`. Focus on single-project pip workflows with explicit version conflicts and shared dependencies.

Compare two versions of a plain text or markdown document and produce a clear change report. Use this skill when the task is to load two document versions, identify additions, deletions, and modifications, and report each change with its location, original text, and new text. Focus on text-level diff comparison for plain text and markdown documents using basic line-by-line or paragraph-by-paragraph comparison.

Compare 3-5 options using evidence found in provided source documents. Use this skill when the task is to define comparison dimensions, search source material for evidence on each option, build a comparison matrix with source citations, identify which option is strongest on each dimension, and write a summary recommendation based on the completed matrix. Focus on evidence-based comparison tables built from provided documents.

Identify email threads that are overdue for a response by checking the direction of the last message, whether it contains a question or request, and how many business days have passed since it was received. Use this skill when the task is to scan one or more email threads, find items waiting on your reply, and produce an overdue follow-up list sorted by age. Focus on basic overdue detection based on last-message date and direction.

Classify and prioritize incoming emails using simple category labels and explicit urgency markers. Use this skill when the task is to scan a batch of emails, assign each one to a fixed category, detect clear urgency keywords in the subject or opening sentences, and output a sorted list with High priority first, then Medium, then Low. Focus on keyword-based classification and explicit urgency markers.

Align join keys across data sources before merging. Use this skill when two tables or DataFrames need to be joined but the key columns may differ in name, dtype, or string casing. Focus on simple key alignment before merge - column name matching, type matching, case normalization, and basic merge-result validation.

Find a common meeting time for 2-3 participants across 2 time zones using fixed UTC offsets. Use this skill when the task is to list participants and time zones, convert business-hour availability into UTC, find the overlapping UTC range, convert that overlap back into local times, and suggest a specific meeting time within the overlap. Focus on scheduling with fixed UTC offsets and standard business hours.

Resolve git merge conflicts in Python and JavaScript code by combining changes from two branches correctly. Use this skill when `git merge` reports conflicted files, when a file contains conflict markers like `<<<<<<<`, `=======`, and `>>>>>>>`, or when the user asks for help merging two branches without discarding either side's important changes. Focus on conflicts that git reports explicitly in source files with conflict markers.

Trace and fix bugs that span multiple files in Python and JavaScript projects. Use this skill when the visible symptom appears in one file but the root cause is likely upstream or downstream in another file, and the fix requires coordinated updates across several files. Trigger when a user reports wrong output, a broken flow, a changed function contract, a module move, or any bug where one local edit is unlikely to be enough. Focus on projects with roughly 4-7 files involved in the debugging path.

Merge flat data from 2-3 document sources into a single master document using exact key matching. Use this skill when records from multiple sources need to be combined by a shared identifier, duplicate entities need to be unified, conflicting field values need to be flagged, and a source-priority rule should decide which value is kept in the merged output. Focus on exact-key matching across 2-3 sources with flat data structures.

Search and filter the most relevant documents from a collection of 10-20 sources on a given topic. Use this skill when the task is to quickly scan a set of articles, papers, reports, or similar documents, score them for topical relevance, select the top 5 candidates, and rank those selected sources from most to least relevant. Focus on relevance-based selection using keyword matching, topic fit, specific data/examples, and source credibility.

Chain two API calls into a simple workflow where the output of the first call is used as input for the second call. Use this skill when a request pattern looks like authenticate then fetch, look up an ID then retrieve details, or any other two-step sequence where Call B depends directly on a value extracted from Call A. Focus on simple two-step API chains only.

Handle missing values correctly during data filtering and aggregation in pandas. Use this skill when a DataFrame contains NaN values and the task involves filtering rows, filling missing values, or computing aggregates such as mean, sum, or count. Focus on pandas NaN handling with isna(), dropna(), fillna(), and built-in aggregate functions before drawing conclusions from filtered or aggregated data.

Retrieve the complete dataset from offset-based paginated REST APIs by fetching every page in sequence. Use this skill when an API returns results in numbered pages such as `page=1&per_page=25` and the user needs all records, not just the first page. Focus on page-number plus page-size pagination with JSON results that can be combined into one list.

Validate REST API request parameters locally before sending the request. Use this skill when parameters come from user input, config, or upstream code and an invalid request would waste quota or fail predictably. Focus on single-request validation for required fields, types, ranges, enums, and string formats before making the API call.

Validate REST API responses before using the data, and fall back to a secondary source when validation fails. Use this skill when an HTTP response must pass top-level checks for status code, content type, JSON parsing, and required top-level fields before the payload is trusted. Focus on simple response validation plus optional fallback handling.

Verify processed tabular results with basic sanity checks before using or returning them. Use this skill after a pandas or SQL data-processing pipeline when you need to confirm that the final output has a reasonable row count, contains the expected columns, looks plausible in sample rows, and does not contain unexpected NaN values in critical fields. Focus on simple final-output verification with df.shape, df.columns, df.describe(), and df.isna().sum().

Retry synchronous REST API calls when server errors occur. Use this skill when an HTTP request may temporarily fail with a 5xx response and the caller needs a simple retry loop with a fixed delay between attempts. Focus on straightforward retry handling for synchronous API calls with status-code-based decision rules.

Safely restructure Python code to improve clarity, reduce duplication, and increase maintainability without changing external behavior. Use this skill when the user asks to refactor, clean up, simplify, rename, extract functions or classes, remove dead code, or reorganize Python code while keeping the existing behavior intact. Focus on Python projects with an existing test suite and structural changes only.

Inspect CSV files and SQL tables before writing queries or data-processing code. Use this skill whenever the user asks for filtering, aggregation, joins, or analysis on tabular data and the schema must be checked first. Focus on quick practical inspection of columns, types, shape, sample rows, and join-key presence before any query is written.

Extract structured data from semi-structured documents such as invoices, forms, and reports, then convert the extracted fields to JSON. Use this skill when a document contains label-value pairs, markdown-style tables, or section headers that organize fields into simple categories. Focus on flat key-value extraction from single-format documents, with basic field validation after extraction.

Systematically diagnose and fix runtime errors in multi-file Python and JavaScript/TypeScript projects. Use this skill when a task includes a traceback, stack trace, failing command, failing test, or clear crash across 3-7 source files and you need to trace the root cause through the call chain. Focus on failures with explicit error output or crashes. Trigger on requests like "fix the bug", "resolve the traceback", "debug this project", or "make the failing test pass" when the failure already points to a concrete runtime error.

Fill a template document using information found in one or two context documents. Use this skill when a template contains blank fields or placeholders and the task is to locate matching information in surrounding context, insert it into the template, and return a completed version. Focus on straightforward fill-from-context work with one template, one or two context documents, simple field-name matching, and basic output review.

Extract explicit action items from formal business email threads. Use this skill when the task is to read an email conversation, identify direct requests, named assignments, and explicit sender commitments, and output structured action items with a task description, assignee, deadline, and source email. Focus on extracting explicit action items from professional email threads.

Normalize inconsistent pandas column types before sorting or comparing values. Use this skill when a dataframe column mixes date formats, stores numbers as strings, or represents booleans in multiple textual forms and must be standardized before order-dependent operations. Focus on date, numeric, and boolean normalization in pandas DataFrames.