web-edit 0.1a1 Released: A Practical Sample of AI Relay Optimization for Performance

Simon Willison released web-edit 0.1a1. It looks like a simple version number update on the surface, but behind it lies an AI workflow with real specimen value.

The division of labor behind a version number

The core content of this release is just one sentence: it includes performance optimizations. But what is truly interesting is how these optimizations came about — they were written by Claude Opus 5.5, and the input Claude received was a profiling report generated by GPT-6 Astra targeting Python 3.15.

In other words, from locating performance bottlenecks to rewriting code, two models from different vendors each played their part: one handled "diagnosis," the other "prescription." The role of human developer Simon Willison in this chain was to feed the diagnostic report as context to the second model, then review, merge, and publish the result.

Profiling refers to the technique of measuring the execution time, call counts, and resource consumption of various parts of a program through runtime sampling or instrumentation, in order to locate performance bottlenecks. Common tools include Python's cProfile, py-spy, and various sampling profilers. A profiling report typically contains structured data such as call stacks, cumulative time (cumtime), and self time (tottime). Its value lies in turning the vague feeling that "the program is slow" into quantifiable facts like "which line of code, which function, how many times was it called, and what percentage of total time it consumed." Precisely because it is highly structured, it is well suited to being passed between different tools or models as a machine-readable intermediate artifact.

What the two models in relay are each good at

This chain is worth unpacking. A profiling report is inherently data-intensive — it requires finding the truly worthwhile hotspots from a large number of call stacks and time distributions, and producing a readable conclusion. This is exactly why GPT-6 Astra was chosen for this kind of task: processing structured performance data and generating human-readable analysis.

Once Claude Opus 5.5 received this already-structured conclusion, what it did was rewrite code at the implementation level. It did not need to redo the performance analysis; it only needed to understand "what is slow and why," then write the corresponding optimized implementation. According to the information in PR #1, this work was submitted directly as a pull request, indicating that the output is a reviewable, mergeable engineering artifact rather than a code snippet that must be manually moved by a human.

Pull Request (PR) is the standard mechanism on Git collaboration platforms such as GitHub for proposing code changes: a developer modifies code on a separate branch, then opens a PR requesting that it be merged into the main branch. A PR includes a diff (line-by-line changes), commit history, and a discussion area, allowing the changes to be reviewed line by line, commented on, and requested to be revised before finally being merged. It matters because a PR is a kind of "reviewable engineering artifact" — whether the changes are generated by a human or a model, they must go through the same review process before entering the mainline. When AI submits optimizations directly in the form of a PR, it means its output has been incorporated into the existing code review and version control system, rather than floating outside the process.

Why this is worth paying attention to

A single AI writing code is no longer novel. What is genuinely informative is this: this chain turns "model capability" into "model collaboration capability."

In the past, when we discussed AI programming, the default scenario was one model plus one developer. What appears here is a division of labor closer to a real engineering team: the analysis role and the execution role are separated, with a structured document (the profiling report) serving as the handoff protocol in between. The document itself is not meant for humans to read, but for the next model to read — it carries the function of context transfer.

This yields a reusable pattern: when you have a tool that excels at analysis and a tool that excels at execution, you do not have to force the same model to do everything. Formatting the former's output as the latter's input may instead produce more stable results, because the task boundary at each step is very clear.

Multi-model orchestration refers to having different models each take on the stages they are good at within a single pipeline, rather than using one model end-to-end to complete a task. Its typical form is a separation between "analyzer" and "executor": the former handles data-intensive tasks that require synthesis and judgment (such as extracting conclusions from performance data), while the latter handles generation-intensive tasks that must follow constraints (such as rewriting code according to conclusions). Between the two, there needs to be a handoff protocol — usually a structured intermediate artifact, such as a report, schema-based JSON, or specification document. The benefit of this design is that the task boundary at each step is clear and independently verifiable, thereby reducing context drift and error accumulation that can occur when a single model works on an overly long task.

Python 3.15 as a background variable

The report mentions that the profiling targeted Python 3.15. This is only mentioned in passing in the original text, but it explains why a dedicated performance analysis was needed: the behavior of a new interpreter version may change the hotspot distribution of existing code, and old optimization experience may no longer hold.

For developers maintaining long-term projects, this is a reminder — after upgrading the Python version, re-profiling may reveal new optimization opportunities, and the exploration and implementation of those opportunities can now partly be handed off to AI models.

Why interpreter version upgrades change performance hotspots: Each major Python version adjusts internal interpreter implementation details, such as the bytecode instruction set, the adaptive specializing interpreter, inline caches, and garbage collection strategies. These changes can make previously expensive operations cheaper, and can also strip away the advantages of code that relies on old implementation details (such as excessive caching or hand-written manual optimizations). Therefore, optimization experience summarized in the past is version-dependent and cannot simply be carried over. Periodically re-running profiling on a new version is essentially a re-mapping of the "current real hotspots," which is also why generating analysis results specifically for Python 3.15 in the report has practical significance.

The signal sent by the version number 0.1a1

Judging from the version number, web-edit is still at an early stage. 0.1a1 means the first iteration on the alpha channel. Releases at this stage are usually not about feature completeness, but about validating direction.

Completing performance optimization in such an early version itself shows one thing: AI-assisted code optimization is lowering the cost of "doing performance work early." In the past, performance optimization was often postponed until after a project matured, because it required dedicated engineering time. Now that the threshold for this chain has been lowered, early-stage projects also have the capacity to deal with performance issues along the way.

The project has been tagged with profiling and projects, making it convenient to later search by topic and track the evolution of this workflow.

One-line Summary

web-edit 0.1a1 completes performance optimization through a two-model relay in which GPT-6 diagnoses and Claude prescribes.

Paragraph Summary

Simon Willison released web-edit 0.1a1. The core update is performance optimization, but what is truly noteworthy is how these optimizations were produced: GPT-6 Astra generated a profiling report for Python 3.15 to locate performance bottlenecks, and Claude Opus 5.5 then rewrote the code based on that report and submitted it as a PR. Two models from different vendors formed an "analysis—execution" relay, with the human developer only responsible for feeding in context, reviewing, and merging. The article argues that this marks a shift: the discussion focus is moving from the capability of a single model to the collaboration capability between models, with the structured profiling report serving as the handoff protocol between models. This pattern lowers the cost of performance optimization for early-stage projects, so performance work no longer has to be postponed until after a project matures.