Series

prod-code

Part 1 · 2026-09-21 · design note
Your laptop is the wrong place for rust-analyzer
Ten coding agents in ten worktrees means ten analyzers and ten cargo builds on one machine. We moved the analyzer, the builds and the tests to Linux nodes on the LAN, mirror the checkout there by content hash, and let the laptop do the one thing it is good at: editing.
7 min
Part 2 · 2026-09-21 · design note
Salsa has no branches
Two agents on two worktrees of one repository, sharing one analyzer database, answer each other's questions. A benchmark that forks four worktrees and asserts what each should see, and why we stopped trying to share anything writable.
7 min
Part 3 · 2026-09-22 · design note
A mirror, not a mount
The analyzer runs on a node across the LAN and needs your code there. Not over a network filesystem, and not by uploading the tree every time: a manifest of hashes, a watermark per node, and a watcher that syncs only when something changed.
6 min
Part 4 · 2026-09-22 · design note
Never grep for a line number again
LSP is positional: to ask who calls a function you must first know its file, line and column. Agents get that by grepping, and grep does not know what a symbol is. We made every tool take the name instead.
5 min
Part 5 · 2026-09-23 · design note
The analyzer already knows your patch is broken
An agent writes a file, runs a build, reads the errors and tries again. The database that answered its last hover could have told it in 100 ms, without writing anything. What that takes, and the one error class the rust-analyzer build we embed stayed silent about.
6 min
Part 6 · 2026-09-24 · notes
Where the milliseconds went
A 32-core node sitting at 2% load, a one-millisecond network, and half the queries taking 40 ms. Three things we found while measuring instead of guessing, including one optimisation that did not work and one that deadlocked.
7 min
Part 7 · 2026-09-25 · design note
Stop letting agents test in your working tree
The agent harnesses we run use the same loop: write a candidate fix into your checkout, run the tests, revert, try the next one. We moved that loop into overlay shadows of the mirrored workspace, mounted at the workspace's own path: candidates run in parallel and the checkout stays untouched.
7 min
Part 8 · 2026-09-26 · design note
Your comments are the search index
An agent that knows what it wants but not what it is called has nothing to ask. We gave it a question box, then looked at what the answers tracked in a five-question sample: not the ranking, which was the same everywhere, but the prose your team did or did not write above each function.
9 min
Part 9 · 2026-09-27 · notes
Both bugs said no matches
A structural rewrite that found nothing, twice, for two unrelated reasons in two different layers. What it takes to tell an empty answer from a broken one, and why the fix was tracing rather than thinking harder.
6 min
Part 10 · 2026-09-28 · notes
The files are not the answer
An agent asked to change one function opens three files and spends most of its context on code that has nothing to do with the task. A slice is the other shape of the same question: the declarations the function depends on, and nothing that merely lives beside them.
8 min
Part 11 · 2026-09-29 · notes
Hover lies by omission
A struct with eleven fields shows ten, so any test value built from that answer is missing one, and the only hint is an ellipsis the agent ignored. What it takes to generate a fixture you can trust: read the declaration rather than the summary, and type-check the result before handing it over.
7 min
Part 12 · 2026-09-30 · notes
The refactor no tool owns
Rename is everywhere; changing what a function takes is nowhere. Building it meant letting the declaration write the rule, checking the result against the analyzer's own reference list, and refusing, under a normal apply, to write what the analyzer rejects.
6 min
Part 13 · 2026-10-01 · notes
One field, three spellings
Cross-language schema rename needs semantic edits for identifiers and separate text edits for wire names. A polyglot fixture shows how prod-code plans the change, validates it, and reports what remains.
7 min
Part 14 · 2026-10-02 · notes
A killed process writes no profile
Coverage went from 53% to 87% and every file in the coverage report crossed 80%. Three things cost a day each: a SIGKILL that silently erased a whole daemon's coverage, a test that passed by skipping, and a read with a deadline it never checked.
9 min
Part 15 · 2026-10-03 · notes
The refactoring that is mostly imports
Moving a function to another module is cut and paste and then an unbounded amount of fixing every file that imported it. Building the tool that does both, and the two bugs that made it quietly skip the second.
7 min
Part 16 · 2026-10-04 · notes
Zero errors, and it did not compile
Every write tool in this series ends by saying the analyzer accepts the result. Building the one that bundles parameters into a struct produced a case where that sentence was printed and the code still did not build - and a four-line probe that says exactly how far the promise goes.
7 min
Part 17 · 2026-10-05 · notes
The refactoring that changes nothing
Promoting a magic value to a parameter is only safe if every existing caller keeps passing the value it had. That constraint is the whole design - and it is also why the tool refuses some extractions outright, and why the analyzer's answer to 'what function is this in' was the wrong question.
6 min
Part 18 · 2026-10-06 · notes
A hundred and twenty-seven problems, three of them real
Changing a type is the refactoring with the widest blast radius and the least help. Using the analyzer's diagnostics as the work list is the obvious design and it produced a report that was about 98 percent noise (124 of 127) - for a reason worth knowing about any tool built on an IDE's engine.
6 min
Part 19 · 2026-10-07 · notes
The argument that landed in the wrong call
Four bugs fixed in one afternoon, in the tools that write your code, and every one of them was a place where a tool took something on trust: a position, a write, a verdict, a line number. What each one did, how it was found, and what it checks now.
7 min
Part 20 · 2026-10-08 · notes
The errors were there before the edit
A new refactoring made a field private and rewrote every access to it, and its diff was right. Its verdict was 124 errors. The unchanged file reported the same 124, and every write tool had been counting them; our reading is that none of them was the edit's.
9 min
Part 21 · 2026-10-09 · notes
The dry run someone else paid for
A dry run is supposed to be the cheap step. Here it cost the next query, whoever asked it, twenty seconds. Moving validation onto a second analyzer fixed that, but the first measurement of the fix was taken on the wrong machine, and the second showed the cost had only moved.
8 min
Part 22 · 2026-10-10 · notes
Every place a struct is built
Turning a value computed inside a method into a field is three small edits. The hard part is the third: finding every place the struct is built, among everything the analyzer calls a reference to it. Imports, return types and `Self` all qualify, and a pattern that lists every field breaks.
5 min
Part 23 · 2026-10-11 · notes
The function that was a file
Checking a proposed edit to a large file took half a minute, and running the check on sixteen threads changed almost nothing. The cause was a single function. Splitting it with the tool itself took the check to four seconds; the work turned up six bugs in the tool.
7 min
Part 24 · 2026-10-12 · notes
What checking a fix revealed
September's prod-code fixes exposed a per-file exception that skipped its own case, a refusal that said too much, and an estimated cost replaced by a reported measurement. What those records teach about checking a fix.
4 min
Part 25 · 2026-10-13 · notes
The callers a return-type assist leaves behind
A September rust-analyzer probe wrapped a function’s return type without updating its callers. The first prod-code implementation added propagation candidates and a report of unresolved calls. Its limits show why the caller side needs a separate check.
5 min
Part 26 · 2026-10-14 · notes
The receiver that did something
Removing an unused receiver can still remove an evaluation at the call site. A September prod-code implementation blocked selected receiver shapes; its textual rule shows why type checks alone cannot establish that a rewrite preserves behaviour.
5 min
Part 27 · 2026-10-17 · notes
Two negations, one meaning
Inverting a boolean predicate requires changing both its body and its uses. Three direct-call shapes explain the negations and parentheses; a September prod-code implementation also shows the limits of reference discovery and textual rewriting.
5 min
Part 28 · 2026-10-18 · notes
The caller nobody edited
A declaration edit can leave call text unchanged while breaking type inference. The original generify report illustrates why callers still need checking, and why failed caller discovery must stop the plan.
5 min
Part 29 · 2026-10-19 · notes
Two conversions, three decisions
A type migration that writes .into() at every broken site sounds like the dangerous version. It holds up when the analyzer decides which conversions stay: only the ones that type-check and break nothing else are kept; the rest are taken back and left for a person. Type-correct, not judged right.
6 min
Part 30 · 2026-10-21 · notes
The diff that was empty
Turning an associated function into a method is the mirror of making a method static, and the easier half. Writing it turned up something else: every write tool in the project reported an empty diff once it had applied its edit, because the old text was read after it was overwritten.
5 min
Part 31 · 2026-10-27 · notes
The tree the node was building
A remote build is only as good as the copy it builds. Three bug reports filed within one minute showed three ways the gateway's copy had drifted from the checkout: files cut by extension, directories that never went away, and a Swift package that never reached the Mac.
6 min
Also in this series

Standalone notes published alongside the series. They sit outside the numbered reading order.

2026-10-11 · design note
Offloading the language server to a cluster
A Swift subproject can sit inside a Rust checkout, and a validation request can disturb the engine answering navigation queries. How prod-code v0.3.29 chooses a compatible node and separates proposed edits from ordinary analysis.
4 min
2026-10-02 · notes
Sharing rust-analyzer across Git worktrees: in-memory overlay architecture and concurrency lessons
In a multi-agent coding fleet, running separate rust-analyzer instances for every Git worktree multiplies memory consumption. Here is how an in-memory VFS overlay shares a single analysis database across worktrees, the Salsa concurrency traps we encountered, and our proposal to upstream.
6 min
2026-10-02 · notes
Outside any function
In a mixed Go/JavaScript checkout, impact analysis reported zero changed functions and claimed every edit fell outside all functions. Why root manifests blind polyglot analyzers, how arrow functions hide from LSP kinds, and why missing symbols must be a gap rather than a verdict.
3 min
2026-10-01 · design note
Language detection: what sixty test cases prove
prod-code v0.3.19 expands workspace detection, but a detected language is not proof of semantic support. The marker matrix and release artifacts show what the version provides.
4 min