Microsoft’s SkillOpt paper makes a concrete claim that matters to teams running AI agents across tools: a small, optimized Markdown skill file trained in OpenAI Codex can be dropped into Anthropic Claude Code and, on one spreadsheet benchmark, outperform a skill trained directly inside Claude Code. The result is striking — 22.1 to 81.8 on SpreadsheetBench with no further optimization — but its practical value is narrower and more useful than the headline suggests: SkillOpt appears capable of transferring procedures across agent shells, not reliably transporting broad reasoning ability between them. The work comes from researchers at Microsoft, Shanghai Jiao Tong University, Tongji University, and Fudan University. Microsoft Research presented it in June as a way to train agent behavior without modifying model weights, while the accompanying paper and public repository provide the more important evidence: the artifact is a versionable best_skill.md file, and every accepted change is gated against a held-out selection split. Independent coverage from The Decoder likewise identified the project’s unusual premise — the “trained” deliverable is a compact Markdown document rather than a fine-tuned checkpoint.
For Windows administrators and developers building local or cloud-hosted agent workflows, the relevant question is not whether one more prompt optimizer can win a benchmark. It is whether a tested procedure can be trained once, checked into source control, reviewed by a domain owner, and reused when a team changes its coding harness. SkillOpt offers an early, credible demonstration of that model — with important limits in its own data.

Infographic showing spreadsheet skills transferring successfully between AI coding agents, while mathematical reasoning transfers poorly.A Markdown file is the trained artifact​

SkillOpt freezes the target model and treats the skill text as the object being trained. The target agent performs scored tasks; a separate optimizer model reviews successful and failed trajectories; then it proposes bounded additions, deletions, or replacements to the current skill document. A candidate is retained only when it strictly improves the held-out selection score. Ties are rejected.
This is a more disciplined mechanism than asking a model to “improve this prompt” after an error. SkillOpt also keeps rejected edits as negative feedback during the current epoch and uses a protected slow-update region for broader lessons that cannot be overwritten by ordinary step-level edits. The result is an explicit audit trail: the paper says each step writes an edit_apply_report.json recording which edits were accepted or skipped.
The operational payoff is straightforward. A deployment does not need an optimizer model, fine-tuned weights, or a hidden memory store. It consumes best_skill.md alongside the frozen target model. In direct chat that text is inserted into instructions; in Codex and Claude Code, the harness writes the same contents to a task workspace as SKILL.md.
That common workspace contract is more significant than it first appears. Codex and Claude Code are different products with distinct CLIs, command surfaces, execution behavior, and tool/file interfaces. A shared Markdown skill format gives SkillOpt one stable unit to move between them. The research does not show that the harnesses are interchangeable; it shows that some instructions remain useful when the environment changes.

Spreadsheet procedures crossed the Codex–Claude Code boundary​

The strongest table in the paper concerns GPT-5.5 running inside the two agent harnesses. A SpreadsheetBench skill optimized under Codex produced an 81.8 score after transfer to Claude Code. Claude Code’s no-skill score was 22.1, so the imported document yielded a 59.7-point gain. A separately optimized, in-domain Claude Code skill reached 80.4.
The difference between 81.8 and 80.4 should not be overread. The paper reports point scores rather than confidence intervals, standard deviations, or repeated-run statistics for these transfer rows, so it cannot establish that the imported Codex skill is meaningfully better than the native Claude Code skill. It does establish something more durable: the imported skill retained essentially all of the task-specific improvement after the harness changed.
The reverse direction was positive but weaker. A Claude Code-trained spreadsheet skill raised Codex from 27.5 to 71.1, retaining about 76% of the direct Codex gain. That asymmetry is a reminder that transfer results depend on the destination setup; “portable” does not mean “identical.”
Microsoft’s explanation is plausible and is supported by the content of the learned spreadsheet rule. The exported instructions emphasize inspecting workbook structure and formulas, verifying calculations, filling the requested target range, and writing evaluated static values when the grader reads values rather than relying on Excel’s recalculation behavior. Those are workbook-level policies. They do not depend on a particular shell command or proprietary tool API.
For real deployments, this is the useful claim: a team may be able to optimize a spreadsheet-agent procedure in a controlled evaluation environment, then ship the reviewed skill to a different coding-agent product without paying the full training cost again. It also means the training environment can be chosen for cost, access, or testing convenience while the final artifact goes where the work actually runs.

LiveMath shows where portability breaks down​

The same cross-harness experiment gives the counterexample that prevents SkillOpt from being marketed as a universal agent adapter. On LiveMathematicianBench, the Codex-to-Claude Code move increased the score only from 40.8 to 42.4 — a 1.6-point gain. Claude Code-to-Codex did better, moving 35.2 to 48.0, but that retained only about 30% of the direct Codex gain.
By the paper’s own numbers, the Codex-to-Claude Code LiveMath transfer preserved just 10% of the direct Claude Code improvement. It was still above the no-skill baseline, which is a legitimate positive result. It was not close to a substitute for retraining in the destination environment.
The evidence points to a practical dividing line. SpreadsheetBench rewards repeatable operating procedures: inspect files, identify the range, preserve structure, calculate and write values, reopen the saved workbook, and check the output. Those steps travel well. The LiveMath tasks appear to require more harness- and model-sensitive reasoning behavior, and the learned rules travel much less well.
That distinction should guide any enterprise pilot. Start with workflows where correctness can be automatically verified and where the work can be written as durable operational rules: spreadsheets, fixed-format reporting, document extraction, artifact validation, test remediation, or routine code transformations. Do not extrapolate from the 81.8 SpreadsheetBench result to incident triage, architectural reasoning, or open-ended research tasks.

Model-scale transfer is real, but stays inside one GPT family​

SkillOpt also tested skills trained on GPT-5.4 against GPT-5.4-mini and GPT-5.4-nano. The results are uniformly above each target’s no-skill baseline, but they vary sharply.
On SpreadsheetBench, the skill took GPT-5.4-mini from 36.1 to 45.5. A native mini-optimized skill reached 47.5, so the transferred document retained roughly 82% of the in-domain gain. That is strong reuse. On GPT-5.4-nano, the transferred skill raised the score only from 23.5 to 26.5, compared with 42.5 for a native skill — roughly 16% retention.
LiveMath produced the stranger result. The GPT-5.4 skill brought GPT-5.4-nano from 23.2 to 28.8, which exceeded the 27.2 score from a skill optimized directly on nano. Again, the absence of repeat-run statistics means the 1.6-point edge should not be treated as a proven superiority claim. But it does reinforce the paper’s central argument that some learned procedures can be less dependent on the target model than expected.
The important omission is equally clear: SkillOpt did not test GPT-to-Qwen transfer. The main evaluation includes Qwen models, but the cross-model transfer table remains inside the GPT-5.4 family. No reader should interpret seven evaluated target models as evidence that a skill optimized for a GPT agent will survive migration to an open-weight Qwen agent, a local model in Ollama, or a future Windows-hosted Copilot runtime.
Cross-benchmark transfer was also positive but modest. A skill optimized on OlympiadBench improved Omni-MATH by 3.7 points on GPT-5.4, 1.8 on GPT-5.4-mini, and 1.3 on GPT-5.4-nano. Since the paper does not report an in-domain Omni-MATH SkillOpt result, these rows demonstrate an improvement over no skill; they do not reveal how much of an Omni-MATH-specific optimization the transferred document preserved.

The economics favor reuse — where evaluation exists​

SkillOpt’s final skill files ranged from 379 to 1,995 tokens across six case studies, with a median near 920 tokens. They were built from only one to four accepted edits. That is a manageable artifact for a repository, pull-request review, environment-specific overrides, and rollback.
The training cost is less tidy. SpreadsheetBench consumed 21.4 million training tokens, reported as 0.6 million tokens per absolute test-point gain. DocVQA consumed 188.2 million tokens, or 46.4 million per point. Microsoft is correct that the optimizer is absent at deployment, but “zero inference-time optimizer calls” does not mean the optimization is free. It means the bill moves to an offline training stage and only amortizes if the skill is reused enough times.
SkillOpt also depends on a reliable scoring mechanism. The paper explicitly limits its strongest applicability to tasks with automatic verifiers, executable checks, exact-match metrics, or similarly dependable feedback. A subjective customer-support conversation or an ambiguous architectural recommendation has no equivalent of a spreadsheet grader unless an organization builds one, pays humans to review it, or accepts model-judged feedback with its own failure modes.
The immediate consequence is clear: SkillOpt is an early but serious case for treating SKILL.md files as deployable operational assets rather than disposable prompt text. Its SpreadsheetBench transfer result makes the case for portability across Codex and Claude Code; its LiveMath results show that the portability is conditional. Teams that can define a real verifier should begin by training and versioning procedural skills, then test the same artifact in every harness they intend to operate.

References​

  1. Primary source: MarkTechPost
    Published: 2026-08-06T00:37:42+00:00
  2. Related coverage: microsoft.github.io
  3. Related coverage: microsoft.github.io
  4. Related coverage: atalupadhyay.wordpress.com
  5. Related coverage: github.com
  6. Related coverage: promptgenius.net
  7. Related coverage: deepwiki.com
  8. Related coverage: sourceforge.net
  9. Related coverage: ai-all.info
  10. Related coverage: smartscope.blog
  11. Related coverage: nothans.com
  12. Related coverage: starlog.is
  13. Related coverage: techcommunity.microsoft.com
  14. Related coverage: marketingassets.microsoft.com
  15. Related coverage: cdn-dynmedia-1.microsoft.com