- Rating
- 2
- Confidence
- 2
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
The paper argues that sequential skill refinement degrades over iterations. Reasons are missing baselines and credit assignment issues. It frames skill evolution as optimizing the context of an LLM skill generator - effectively RL of a policy. In each round the generator picks an unresolved design dimension, builds skills that differ only on that dimension, and runs each one once on a seed instance. It checks and logs the score gap in that dimension and conclusion. Finally it synthesises only supported choices and drops dimensions that had no impact. On SkillLearnBench with three LLMs, the method beats a set of baselines across instances. The method further scores higher on LLM-judge skill completeness and determinism.
Critical strengths
The core mechanism is simple and adds limited computational cost. It is straightforward to vary one dimension per step and reuse old skills as controls for credit assignment in larger rewrites. It is general in that it should work with any frozen agent. The additional held-out evaluation and excluding the seed instance has only little impact and makes it likely that gains are not based on overfitting.
Critical weaknesses
The comparison isn’t exactly fair on compute or information IIUC. There seems to be no budget-matched (rollouts and verified feedback) search baseline (eg best-of-N), so the paper can’t separate the exact method from more samples and scoring.
For stronger reliability, the paper needs to move away from single stochastic rollouts on single instances: multiple seeds and confidence intervals. The ablations would also benefit from expanding beyond 5 tasks with one model and adding task accuracy (instead of using the judge). The judge itself has some issues with human-authored skills scoring lower than Skill2 on the judge (while having better accuracy).
Questions for authors
How does Skill2 compare with a best-of-N baseline (or evoskill) with the same rollout budget and verifier access? How much variance is there across seeds? Please report CIs, especially where the gain is small. Can you report task accuracy not just judge quality across ablations? Discuss why not if not possible. Does the method keep its advantage on harder/more stochastic environments? How does increased rollout noise affect this? Existing work: please contextualise with prompt optimization (aPSF) for single factor changes and credit assignment and context as policy parameter in training-free GRPO. Minimal: discuss relation, best: rebuttal response on if these are suited as baselines. If yes: please add.
5 comments
Response to Reviewer wW65 (2)
Response to W2 & Q2
How much variance is there across seeds? Please report CIs, especially where the gain is small.
Seed variance. Our single-trial protocol follows SkillLearnBench [1]. Its authors re-ran one representative instance per task three times for each method and generation LLM; accuracy varied with a standard deviation of 13–17% for generated skills, and the ordering of method means matched the single-trial results. This variation comes from individual executions ([1], Appendix E). Our CIs below are computed with a two-stage cluster bootstrap that resamples both tasks and instances within each task, so they already account for this instance-level variance. Repeating the full search under multiple seeds is costly (B=10 containerized agent rollouts per task and backbone), but the three backbones act as independent replicates with consistent gains. Appendix B reports these CIs, pooled and per backbone, together with the pooled paired Wilcoxon tests.
Confidence intervals. Each (method, backbone, task) yields one optimized skill, evaluated on multiple instances of the task. We report 95% CIs from a two-stage cluster bootstrap (resampling tasks, then instances within each task; 10,000 draws) and paired Wilcoxon signed-rank tests over the 20 tasks.
Pooled over the three backbones, Skill$^2$ significantly outperforms every baseline:
| Skill$^2$ vs. | Δ (pts) | 95% CI | Wilcoxon p |
|---|---|---|---|
| No Skill | +19.3 | [8.1, 29.8] | 0.003 |
| One-Shot | +18.0 | [5.6, 30.4] | 0.008 |
| Self-Feedback | +16.5 | [5.2, 27.6] | 0.009 |
| SkillOpt | +14.7 | [6.1, 23.3] | 0.003 |
| SkillGrad | +17.7 | [8.4, 26.9] | 0.001 |
| EvoSkill | +16.5 | [4.7, 28.3] | 0.009 |
| TF-GRPO | +17.2 | [6.6, 27.9] | 0.006 |
Against the strongest baseline chosen separately for each backbone, the pooled gain is +8.5 [-0.1, 16.8] (task-level Wilcoxon p=0.031). Per backbone the gain is positive but the CIs are wide: Gemini-3.8-Flash +16.2 [-2.8, 35.5], GPT-5.6-Luna +7.8 [-12.0, 26.0], DeepSeek-V4-Flash +1.4 [-15.8, 19.7].
[1] S. Zhong et al. SkillLearnBench: Benchmarking Continual Learning Methods for Agent Skill Generation on Real-World Tasks. arXiv:2604.20087, 2026.
Response to W3 & Q3
Can you report task accuracy not just judge quality across ablations? Discuss why not if not possible.
We now report task accuracy for all ablations on all 20 tasks with GPT-5.6-Luna, with the same rollout budget as full Skill$^2$:
| Variant | All (%) | Held-out (%) |
|---|---|---|
| Skill$^2$ (full) | 60.5 | 62.5 |
| w/o Controlled Comparison | 53.5 (−7.0) | 54.3 (−8.2) |
| w/o Control Reuse | 51.2 (−9.3) | 50.3 (−12.2) |
| w/o Synthesis | 52.8 (−7.7) | 50.0 (−12.5) |
Removing any component lowers task accuracy by 7–10 points on all instances and by 8–13 points on held-out instances, so each component contributes to actual task performance.
Response to Reviewer wW65 (3)
Response to Q4
Does the method keep its advantage on harder/more stochastic environments? How does increased rollout noise affect this?
Yes. To verify this, we split the 20 SkillLearnBench [1] tasks by difficulty and take the 10 hardest ones, i.e., those with the lowest No-Skill accuracy averaged over the three backbones (all ≤ 38.9%). Accuracy on these hard tasks:
| Method | Gemini | Luna | DeepSeek | Avg |
|---|---|---|---|---|
| No Skill | 7.3 | 24.7 | 15.3 | 15.8 |
| One-Shot | 27.7 | 19.0 | 24.3 | 23.7 |
| Self-Feedback | 30.0 | 17.0 | 21.0 | 22.7 |
| SkillOpt | 10.7 | 24.3 | 26.7 | 20.6 |
| SkillGrad | 14.0 | 24.7 | 22.0 | 20.2 |
| EvoSkill | 11.7 | 33.0 | 20.7 | 21.8 |
| TF-GRPO | 11.0 | 33.0 | 20.7 | 21.6 |
| Skill$^2$ | 57.3 | 37.0 | 34.0 | 42.8 |
On hard tasks, Skill$^2$ leads the strongest baseline on every backbone (+27.3/+4.0/+7.3 on Gemini-3.8-Flash/GPT-5.6-Luna/DeepSeek-V4-Flash), and its average margin grows to +12.9 points (95% CI [0.3, 24.1]).
As for increased rollout noise, its main risk is that a single noisy rollout leads to a wrong design conclusion. Skill$^2$ does not treat such conclusions as final: later rounds carry earlier-decided values into new skills, so a conclusion drawn from one noisy run is tested again and can be revised if contradicted. See the following case study:
Case study (backbone: Gemini, task: python-scala-translation): in round 2, the companion_module_object entry point failed (0.0) and would have been discarded by a single-shot comparison. In round 6 the same entry point was adopted again on a newer baseline and passed (1.0). The final synthesized skill adopts it. Higher noise thus mainly costs extra rounds to correct, rather than permanently misleading the search.
[1] S. Zhong et al. SkillLearnBench: Benchmarking Continual Learning Methods for Agent Skill Generation on Real-World Tasks. arXiv:2604.20087, 2026.
Response to Q5
Existing work: please contextualise with prompt optimization (aPSF) for single factor changes and credit assignment and context as policy parameter in training-free GRPO. Minimal: discuss relation, best: rebuttal response on if these are suited as baselines. If yes: please add.
Training-Free GRPO [1] It is already included as a baseline with the same rollout budget (Gemini-3.8-Flash/GPT-5.6-Luna/DeepSeek-V4-Flash: 36.0/52.7/43.0 vs. Skill$^2$ 75.7/60.5/47.2).
aPSF [2] also uses single-factor edits with credit assignment, but it is designed for static prompts with a fixed validation set and deterministic execution, so it does not fit our single-instance, noisy agentic setting. Counterfactual credit assignment is only one part of Skill$^2$: with GPT-5.6-Luna on 20 tasks, removing controlled comparison, control reuse, or synthesis each lowers accuracy by 7–10 points according to our ablations.
[1] Y. Cai et al. Training-Free Group Relative Policy Optimization. arXiv:2510.08191, 2025.
[2] H. Liu et al. Adaptive Prompt Structure Factorization: A Framework for Self-Discovering and Optimizing Compositional Prompt Programs. ACL 2026, arXiv:2604.06699.
Response to Reviewer wW65 (1)
We appreciate your feedback. We would like to clarify the points you raised as follows:
Response to W1 & Q1
Our base baselines follow SkillLearnBench [5], which shows that Self-Feedback degrades as the number of refinement rounds grows (accuracy rises after the first revision and then drops sharply; [5], Sec. 5.4), so we adopt its original setting (K=2; [5], Sec. 4.1). For fairness, we evaluate four further baselines (three iterative skill-evolution methods and TF-GRPO), SkillOpt [1], SkillGrad [2], EvoSkill [3] and TF-GRPO [4], with the same rollout budget as Skill$^2$ (B=10 on the seed instance).
Accuracy on all instances / held-out instances (%) with Gemini-3.8-Flash, GPT-5.6-Luna and DeepSeek-V4-Flash, and Exec, the executability score from SkillLearnBench's LLM judge, computed as the average of its four original sub-metrics (completeness, determinism, consistency, usability; rescaled to 0–100; [5], Sec. 3.2.1):
[1] Y. Yang et al. SkillOpt: Executive Strategy for Self-Evolving Agent Skills. arXiv:2605.23904, 2026.
[2] H. Wang et al. SkillGrad: Optimizing Agent Skills Like Gradient Descent. arXiv:2605.27760, 2026.
[3] S. Alzubi et al. EvoSkill: Automated Skill Discovery for Multi-Agent Systems. arXiv:2603.02766, 2026.
[4] Y. Cai et al. Training-Free Group Relative Policy Optimization. arXiv:2510.08191, 2025.
[5] S. Zhong et al. SkillLearnBench: Benchmarking Continual Learning Methods for Agent Skill Generation on Real-World Tasks. arXiv:2604.20087, 2026.