- Rating
- 2(+1)
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper presents WebCoder, a frontend development agent trained with artifact-grounded reinforcement learning in an executable environment called Webdev-World. The method combines terminal artifact verification, progress-based credit assignment, context compaction, and message-tree training to support long development trajectories. WebCoder-27B improves over its Qwen3.8-27B base model on Webdev-Bench and Vision2Web, with particularly large reported gains in functional and interaction scores.
Critical strengths
- The paper addresses a meaningful limitation of prior screenshot-to-code work by treating frontend development as a persistent, multi-round process involving generation, modification, debugging, and preservation of existing behavior.
- The experimental section includes comparisons with many proprietary and open-source systems, and examples of both successful and failed applications.
Critical weaknesses
- The reward is not sufficiently aligned with dynamic frontend functionality. The training reward mainly combines deterministic DOM-based checks with VLM judgments of static screenshots. Table 2 explicitly states that interactions are not executed, meaning that buttons, filters, forms, navigation links, or state transitions may appear visually complete while being nonfunctional. This mismatch is especially concerning because functional and interaction performance is a central claim of the paper.
- The paper does not clearly explain why RL produces the reported improvements. The current ablations demonstrate the usefulness of context compaction and artifact-grounded credit assignment within the proposed framework, but they do not isolate the contribution of RL itself. Compute-matched comparisons with SFT, rejection sampling, or other non-RL alternatives are missing. Moreover, the case studies focus mostly on final outcomes rather than showing how reward signals and intermediate credit assignment change the model's behavior during development.
- The empirical validation remains limited. WebCoder is trained only from Qwen3.8-27B, so it is unclear whether the proposed method generalizes across model families and scales. Evaluating other models as inference-only baselines does not address this concern. In addition, the human evaluation is based on screenshots rather than direct operation of the applications, making it insufficient for independently validating interaction-heavy claims.
Questions for authors
- Why does the training verifier not execute required interactions, and how well does the current reward correlate with independently executed functional tests?
- Can the authors provide trajectory-level case studies showing how RL and intermediate credit assignment improve specific behaviors, together with compute-matched SFT or rejection-sampling baselines?
- Does the method remain effective when applied to another base model family or model scale?
6 comments
Author Response (Part 2)
W2: The paper does not clearly explain why RL produces the reported improvements. The current ablations demonstrate the usefulness of context compaction and artifact-grounded credit assignment within the proposed framework, but they do not isolate the contribution of RL itself. (1) Compute-matched comparisons with SFT, rejection sampling, or other non-RL alternatives are missing. (2) Moreover, the case studies focus mostly on final outcomes rather than showing how reward signals and intermediate credit assignment change the model's behavior during development.
Q2: Can the authors provide (1) trajectory-level case studies showing how RL and intermediate credit assignment improve specific behaviors, together with (2) compute-matched SFT or rejection-sampling baselines?
We thank the reviewer for the insightful comments. We add two sets of analyses: (1) a training-paradigm comparison with SFT and RFT (responding to W2-(1) and Q2-(2), with closely matched training-trajectory scale; WebCoder's Avg is 11.7 and 11.1 points higher, respectively); (2) an analysis of how reward and credit assignment affect development behavior (responding to W2-(2) and Q2-(1), from three angles: a post-training same-task behavioral comparison, a per-segment credit case study on a training trajectory, and behavioral changes over the course of training).
(1) Comparison with SFT and RFT (responding to W2-(1), Q2-(2))
Setup. All three methods are initialized from Qwen3.8-27B. SFT performs supervised training on existing development trajectories; RFT filters candidate trajectories with the same reward system as WebCoder's RL and then performs supervised training; WebCoder optimizes with GRPO on its own rollouts. The training-trajectory scales are closely matched: SFT and RFT use about 3.8k and 3.6k trajectories respectively, and WebCoder's training samples about 3.7k rollouts.
Table 3. SFT / RFT / WebCoder on Vision2Web L2.
| Method | Training paradigm | Effective loss tokens | VS | FS | Avg |
|---|---|---|---|---|---|
| SFT | Supervised training on existing trajectories | 337M | 45.7 | 55.6 | 50.7 |
| RFT | Supervised training on trajectories filtered by the RL reward system | 315M | 44.1 | 58.4 | 51.3 |
| WebCoder | Own rollouts + GRPO | 291M | 57.7 | 67.1 | 62.4 |
Results. WebCoder's average score is 11.7 and 11.1 points higher than SFT and RFT, respectively; RFT improves the functional score by 2.8 points over SFT. Under comparable scales of training trajectories and effective loss tokens (with WebCoder using the fewest loss tokens, 291M), neither imitating existing development trajectories nor supervised training on trajectories filtered by the same reward system reaches the performance of WebCoder's RL recipe, providing comparative evidence for adopting RL for iterative policy optimization.
(2) How reward and credit assignment affect development behavior (responding to W2-(2), Q2-(1))
WebCoder first completes a development trajectory; the terminal reward is then computed from the final artifact, and the intermediate artifact potentials assign advantages to the development segments. These signals act on subsequent policy updates rather than instantly changing behavior within the same trajectory. We therefore analyze their effect on behavior from three angles.
1. Post-training same-task behavioral comparison. On the same set of 66 Vision2Web L2 tasks, we compare the development behavior of the full WebCoder with the variant trained without artifact-grounded credit assignment (A1). The follow-up modification rate after failed checks is the fraction of failed checks that are followed, within the same observation chain and before the next check, by at least one project-modifying call.
Table 4. Development behavior of the full WebCoder versus A1 on the same tasks.
| Metric | Full WebCoder | w/o credit assignment (A1) |
|---|---|---|
| Follow-up modification rate after failed checks | 100% | 70% |
| Rate of passing the next check after a post-failure modification | 100% | 83.3% |
| Final scores VS / FS / Avg | 57.7 / 67.1 / 62.4 | 46.7 / 58.4 / 52.6 |
The model trained with artifact-grounded credit assignment follows up on failed checks with modifications more consistently, and its modifications more often pass the next check, corresponding to the 9.8-point gap in final scores: the credit-assignment training changes observable development behavior.
2. A per-segment credit case study on a training trajectory. We select a training trajectory of a long-screenshot replication task, independently render the project states at several segment boundaries, and replay the potentials (the reference page height is about 6,743px).
Author Response (Part 3)
Table 5. Per-segment development behavior, replayed potentials, and independently rendered states of one replication trajectory.
| Segment | Development behavior and project state | Replayed potential | Independent render: text characters / page height |
|---|---|---|---|
| 0 | Reads the reference image, plans, and writes notes; the page is still an empty shell | 0.048 | 27 chars / 18px |
| 1 | Writes the application source files; the page is not yet wired up | 0.186 | 27 chars / 18px |
| 2 | Continues writing and completes the wiring; checks with webshot | 0.601 | 2,451 chars / 6,401px |
| 3–8 | Iterative fine-tuning | 0.601 | — |
| 9 | Continues editing and checks the page | 0.612 | 2,862 chars / 7,181px |
| 10–19 | Continues checking and polishing | 0.612 | final 2,862 chars / 6,804px |
The potential tracks artifact progress by development stage: it rises slightly while the source files are being written (0.048 → 0.186), rises sharply once the wiring is completed and the page renders real content (0.186 → 0.601), changes marginally during the polishing phase, and the final page height converges close to the reference (6,804px versus 6,743px). The large jumps of the potential align with independently verifiable rendering milestones, supporting the design of constructing process signals from artifact states and assigning segment-level credit from progress changes.
3. Behavioral changes over the course of training. Appendix F analyzes training-time behavior based on 1,556 rollouts from Stage 1; here we add the follow-up modification rate after failed checks (defined as above).
Table 6. Development-behavior changes over training (Early / Trough / Recovery).
| Metric | Early | Trough | Recovery |
|---|---|---|---|
| Redundant-operation rate | 0.24% | 2.45% | 0.86% |
| Observed skill invocation rate | 24.1% | 15.7% | 20.8% |
| Observed webshot invocation rate | 79.8% | 66.9% | 78.7% |
| Follow-up modification rate after failed checks | 72.5% | 66.7% | 80.0% |
During the reward trough, redundant operations increase, skill and webshot invocations decrease, and the follow-up modification rate after failed checks also drops; during the reward recovery, all behavioral metrics improve together, while the evaluation score on the fixed anchor set rises from 0.346 to 0.575 over the same period (Figure 4). Reward changes are accompanied by changes in the agent's development behavior, constituting process-level evidence that the reward signal acts on development behavior.
Author Response (Part 1)
We thank Reviewer 4aQb for the thorough and constructive review. Below we provide our detailed responses to the reviewer's comments.
We thank the reviewer for the insightful comments. We first clarify a key distinction: all of the paper's conclusions about functional and interaction performance come from independent evaluations that actually execute interactions; the training reward is only an optimization signal inside the training loop. The Webdev-Bench IS (90.8 versus 79.8 for the base model) is graded by an acceptance agent that actually operates the applications in a browser, item by item (Appendix B.2.3), and the Vision2Web FS (67.1 versus 45.7) comes from functional tests executed with playwright by the benchmark's evaluator (Appendix B.1). Regarding Q1-(1), using a low-cost artifact signal for the training reward is an efficiency-driven design choice, detailed below. Regarding Q1-(2), our new consistency experiment shows that the terminal training reward correlates strongly with independently executed acceptance scores (Spearman ρ = 0.782, Table 1).
Regarding Q1-(1): why the training verifier does not execute interactions.
Regarding Q1-(2): correlation between the terminal reward and independently executed functional tests.
We randomly sample 120 artifacts from training. For each artifact, the source code is placed into a fresh container, dependencies are installed, and the project is built with Vite; an independent acceptance agent (Codex + GPT-6-Astra), which has no access to the training reward, then checks every task requirement in a browser. Each requirement is decomposed into several sub-checks, an acceptance score is computed as the fraction of sub-checks passed, and this score is paired with the artifact's terminal training reward.
Table 1. Correlation between the terminal training reward and independently executed acceptance scores.
Table 2. Measurement cost of the two procedures.
In addition, the intermediate potential signals used during training are validated in the same way: over 421 randomly sampled pairs of adjacent project states from training trajectories, the direction of potential changes agrees with independent execution-based checks at Cohen's κ = 0.856 (the full cross-tabulation and analysis are provided in our response to Reviewer 4Ab4's Q1 and are not repeated here).