DeveloperSkillHubsCode2Skill researchTechnical report · 2026
ResearchDeveloper tools

Give developers and coding agents reusable procedures grounded in real implementations.

Code2Skill turns maintained source implementations into inspectable developer skills: operational records that describe when a procedure applies, how it works, what it must preserve, how it fails, and where its evidence came from.

Code2Skill Research · Developed by Ant International AI Research Team

Abstract

Reusable skills can carry procedural knowledge across tasks, but common acquisition routes depend on successful target-agent trajectories or documents that may not expose implemented behavior. Source code offers a different substrate: it is available before downstream interaction and remains concrete enough to inspect after abstraction.

Code2Skill selects behavior-rich source units, lifts them into typed procedures, and challenges each candidate through source-body-blind reconstruction and source-aware comparison. Accepted records retain workflows, boundaries, provenance, and construction state for later use and audit.

Code2Skill construction pipeline from source-unit selection through typed skill extraction, reconstruction, source-aware verification, and evidence-preserving storage.
Figure 1

Code2Skill construction pipeline. Source units are ranked, converted into atomic, composite, or recurring-pattern skill records, checked through source-body-blind reconstruction and source-aware comparison, and retained with evidence for downstream use.

DATASET / CONSTRUCTION OUTPUTS

Built before the target agent acts.

The bank is produced offline from public code, then kept as an evidence-rich archive with compact task-facing views.

Source pool: GitHub repositories available by April 14, 2026, curated toward popular, actively developed public software. Counts describe distinct stages; 147,465 is not a claim of unique skills.

19,769source repositories

Public repositories curated for adoption and maintenance signals

1,006,822accepted skill records

Stored with provenance and construction state

6,115repository groups

Groups contributing accepted records

147,465feature-tagged records

A task-facing layer drawn from 778 repositories

01 / WHAT CHANGED

Broad gains, with meaningful boundaries.

Across seven model settings with complete matched results, the macro-average increased from 41.13 to 46.12. The tables retain the paper's matched comparisons instead of hiding variation.

The gain is broad, not uniform. Every matched SWE-bench Verified and AIME pair improves, as does every reported TerminalBench pair; BigCodeBench under reasoning and AgentBench-OS remain mixed. That is the boundary behind the headline—not every task benefits equally.

TABLE 01 / COMPLETE MODEL SETTINGS

Unweighted mean across the eight displayed benchmarks.

ModelReasoningNo skill+ CodeSkillΔ
DS4-FlashNo35.6243.01+7.39
DS4-FlashYes44.4551.76+7.31
Qwen3.5 27BNo32.8936.61+3.72
Qwen3.6 27BNo37.7440.00+2.26
Gemini 2.5 ProDefault37.3242.09+4.77
GPT 5.2No43.1549.16+6.01
GPT 5.2Yes56.7360.23+3.50
Macro-average41.1346.12+4.99

Every complete model-setting average improves; relative gains range from 6.0% to 20.7%.

TABLE 02 / MATCHED BENCHMARK CELLS

Improved pairs out of all reported matched pairs.

BenchmarkImprovedObserved pattern
SWE-bench Verified9 / 9Every matched pair improved
BigCodeBench6 / 9Three pairs were lower
AIME 20269 / 9Every matched pair improved
HMMT 20258 / 9One pair was lower
GPQA8 / 9One pair was lower
TerminalBench7 / 7Every reported pair improved
LongCLI4 / 7Three pairs were flat
AgentBench-OS5 / 9Three lower · one flat
All benchmarks56 / 6882.4% of matched cells improved
TABLE 03 / SKILL SOURCE UNDER A SHARED AGENT LOOP

Mean ± standard deviation over five runs.

MethodSWEBigCodeAIMEHMMTTerminalLongCLIAgentBenchAvg
Trace2Skill6.0 ± 0.831.9 ± 1.563.3 ± 5.846.7 ± 6.76.9 ± 1.318.8 ± 4.243.1 ± 2.731.0
ExpeL7.5 ± 1.129.4 ± 2.250.0 ± 6.720.0 ± 5.822.2 ± 2.518.8 ± 4.247.4 ± 3.127.9
SkillRL-Bank36.8 ± 1.929.4 ± 1.843.3 ± 6.226.7 ± 6.031.9 ± 3.310.4 ± 3.151.2 ± 2.832.8
Code2Skill44.7 ± 1.642.3 ± 1.770.0 ± 5.253.3 ± 6.145.2 ± 2.630.0 ± 4.861.3 ± 2.249.5

Code2Skill ranks first on all seven shared benchmarks and averages 49.5, compared with 40.1 for a per-benchmark oracle selecting the strongest trajectory-derived baseline.

02 / WHERE THE SKILLS COME FROM

Why begin with source code?

Trajectories capture what an agent has already experienced. Documents describe intent. Source code provides a different substrate: implemented behavior that exists before target-agent interaction and remains inspectable after abstraction.

Trajectory-derived skills expose procedures only after a target policy has produced useful episodes, while documents can describe goals and conventions without retaining an implementation against which operational claims can be inspected. Source code occupies a different position: it is available before target-agent interaction and records implemented control flow, state changes, constraints, and failure paths.

Code2Skill therefore treats maintained source as procedural evidence rather than as text to summarize. The objective is to recover transferable behavior while preserving enough provenance for each abstraction to be challenged, refreshed, and audited.

03 / HOW IT IS BUILT

From implementation to inspectable procedure.

Source grounding happens at verification, where each candidate is tested against the implementation rather than accepted as a plausible summary. This quality gate separates generated descriptions from the records admitted to the bank.

The pipeline first parses functions, methods, command-line entry points, and file-level components, then ranks them using signals for reusable intent, operational structure, control flow, boundary conditions, contextual sufficiency, and non-triviality. Retained units remain candidates rather than accepted skills.

Each candidate is lifted into an atomic operation, composite workflow, or recurring pattern. The abstraction is then used to reconstruct comparable behavior without revealing the original source body. A source-aware judge compares the reconstruction with the implementation and routes the record to direct acceptance, adjudication, or rejection.

Accepted records keep their repository, file, symbol, source span, decision rationale, and construction status. Separate task-facing fields and compact summaries make those records usable without turning the full evidence archive into prompt context.

04 / WHAT A SKILL CONTAINS

A procedure with boundaries and receipts.

Records are shaped for action and inspection. The operational core tells an agent what to do; the evidence layer keeps the abstraction connected to the implementation that motivated it.

A developer skill records the condition under which a procedure should be used, its transferable control rule, the ordered workflow, and the invariants and failure cases that constrain execution. Anti-goals state tempting but incorrect behavior; source coordinates and the acceptance trace provide the receipt.

ONE GROUNDED EXAMPLEADGUARD DNS
A Code2Skill composite workflow record for bounded recovery from a cached DNS-over-QUIC connection failure.
recoverDoQAfterCachedQUICFailureCOMPOSITE WORKFLOW · ABRIDGED

The AdGuard example shows a composite workflow for recovering from a cached DNS-over-QUIC connection failure. Its reusable insight is not “retry on error,” but a bounded recovery policy: retry only a failed cached connection, close it before reacquiring, and clear token state only for 0-RTT rejection.

05 / SEMANTIC PROFILE

What the skill bank actually contains.

Semantic annotations over 750,748 generated skill records. Percentages report label prevalence; dimensions are multi-label and do not need to sum to 100%.

Across the annotated bank, multi-step procedures and constraint reasoning dominate shallow API calls. The panels below expose the problem types, transfer mechanisms, knowledge dependencies, correctness risks, and agent-facing reuse forms behind that profile.

01

Problem archetypes

Problem archetypes across Code2Skill skill records.
02

Transfer mechanisms

Transfer mechanisms across Code2Skill skill records.
03

Reasoning depth

Reasoning depth across Code2Skill skill records.
04

Pipeline family

Pipeline family across Code2Skill skill records.
05

Knowledge required

Knowledge required across Code2Skill skill records.
06

Correctness and risk

Correctness and risk across Code2Skill skill records.
07

Agent relevance

Agent relevance across Code2Skill skill records.
08

Reuse form

Reuse form across Code2Skill skill records.
09

What the skill teaches

What the skill teaches across Code2Skill skill records.
10

Problem archetypes by pipeline family

Problem archetypes by pipeline family across Code2Skill skill records.
11

Problem and transfer co-occurrence

Problem and transfer co-occurrence across Code2Skill skill records.

Conclusion

Across the 750,748 annotated records, the bank is dominated by reusable procedural knowledge rather than shallow API facts. Multi-step procedures (57.3%) and constraint reasoning (33.5%) far exceed surface API calls (8.6%). Data transformation and state updates are the most common problem types, while parameterization, validation, and state-machine patterns are the leading transfer mechanisms. The heatmaps show that these labels are structurally coherent: state updates align with state-machine reuse, decision validation with validation patterns, external interaction with API usage, and error recovery with robustness.

That procedural structure is both implementation-specific and agent-facing. Nearly half the records depend on library/framework, language-semantics, or schema knowledge; 79.6% are correctness-critical. The dominant use cases are code generation (69.1%), SWE agents (58.3%), and tool use (41.8%), while the records most often teach what to check (79.1%) and how to structure a solution (66.7%). Together, the profile describes an external source-grounded memory for planning, checking, and stateful execution—not a collection of isolated code snippets.

06 / HOW TO USE THE SKILLS

Put the skill at a decision point that can use it.

A skill can guide first-pass generation, constrain a plan, inspect an existing candidate, or serve as a reward-side reference. The interface determines the role the knowledge plays.

The same record can enter an agent workflow at different points. Before execution, its conditions and workflow can constrain a plan. During first-pass generation, the model must translate the procedure directly into an answer. After a draft exists, invariants, failure cases, and anti-goals become concrete review criteria. In coding RL, the record can instead be exposed to the policy, the reward-side verifier, or a post-generation reviewer.

PlacementRoleObserved pattern
First-pass generationDirect procedural contextMixed and model-dependent
PlanningTask decomposition and constraints8 of 8 shared pairs improved
Post-generation reviewCandidate-grounded checksBroadest positive pattern
Coding RLPolicy, verifier, or reviewer referenceAll four interfaces exceeded control at step 150

07 / LEARNING SKILLS INTO THE MODEL

Skills can move from context into models' parametric knowledge.

Source-grounded procedures do not have to remain prompt-time references. In coding RL, they can shape the policy, the reward-side verifier, or a post-generation reviewer so that procedural knowledge participates in learning.

At the shared step-150 checkpoint, the no-skill control resolved 24% of tasks. Four skill interfaces reached 31–38%, with post-generation review reaching 38%. This is an early signal that developer skills can supervise model behavior, not only provide runtime context.

The pilot reports one shared checkpoint without repeated seeds or aligned learning curves. It does not yet establish faster learning or stronger final convergence.

CODING RL / SHARED STEP 150RESOLVE RATE
No skillNone
24%
Full promptPolicy · full
32%
Summary promptPolicy · compact
31%
Reward referenceVerifier
31%
Post-generation reviewReviewer
38%

All four skill interfaces exceed the no-skill control at the shared checkpoint; post-generation review is highest in this pilot.

08 / WHAT WE LEARNED

Useful knowledge must meet the right task at the right moment.

The experiments point to an interface-level view of skills: retrieval quality matters, but so do representation length, task structure, and the point at which the agent sees the record.

Placement changes the computational role of a skill. Planning improved all eight shared model–benchmark pairs, first-pass prompting was mixed, and the broader post-generation evaluation showed the most stable positive pattern. This is a workflow-level observation rather than a causal ranking of insertion points.

The procedural core can carry most of the utility. At k=3, summary rendering reduced average retrieved text from 6,352 to 707 characters while matching or improving full-record performance for both evaluated models. Full records remain useful for provenance and audit, but need not be exposed at every invocation.

More retrieval is not automatically better. Increasing depth from k=1 to k=10 expanded average context from 2.1K to 17.8K characters with little extra utility, and purpose indexing had mixed effects. Relevant, compact procedures mattered more than volume in these tests.

Task structure determines where procedures help. The strongest patterns occur when navigation, multi-step action, or candidate review can directly use workflows and failure cases. BigCodeBench under reasoning was more mixed, suggesting less leverage on short, self-contained problems.

CONTEXT LENGTH / k=388.9% LESS CONTEXT
FULL RECORDS6,352avg characters
SUMMARIES707avg characters

Both evaluated models matched or improved full-record performance under summary rendering.

Conclusion

Code2Skill builds external procedural memory before a target agent has accumulated successful trajectories, while its verification quality gate keeps accepted skills connected to the implementation evidence that supports them.