remote development

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.

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.

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.

We evaluated prod-code AST tools against dotnet/aspnetcore: 1,757,169 lines of C# across 10,685 files, 625 projects in a single repository, Roslyn generator snapshot clones, and cluster-verified OmniSharp refactoring.

We evaluated prod-code AST tools against dotnet/BenchmarkDotNet: 120,810 lines of C# across 1,175 files, 29 projects in an acyclic DAG, 1,120 benchmark harnesses, and cluster-verified OmniSharp refactoring.

We evaluated prod-code AST tools against dotnet/efcore: 1,749,818 lines of C# across 5,778 files, 58-project acyclic architecture, Northwind clone clusters, and cluster-verified OmniSharp refactoring.

Historical Ghostty terminal emulator analysis with prod-code: Zig source counts, VT test clones, cleanup patterns, and a ZLS refactoring limitation. Native applications support macOS and Linux.

Historical Apache Pekko actor runtime analysis with prod-code: Scala and Java source counts, 41 extracted SBT modules, 3.5% reported clone density, and a remote Metals refactoring example.

Historical Play Framework analysis with prod-code: Scala and Java source counts, 44 extracted SBT modules, form and router clones, and a remote Metals refactoring example with verification limits.

We evaluated prod-code AST tools against dotnet/roslyn: 6,499,949 lines of C# across 18,176 files, 394 projects, 15,300+ compiler invariants, and cluster-verified OmniSharp refactoring.

Historical Scalameta Scala metaprogramming analysis with prod-code: 106,270 Scala and Java lines, 24 extracted SBT modules, 202 reported @ast declarations, and a remote Metals refactoring example.

Historical Apache Spark analysis with prod-code: Scala and Java source counts, 52 extracted modules, 0.7% reported clone density, and a remote Metals refactoring example with verification limits.

We benchmarked prod-code AST tools against spring-projects/spring-boot: 880,132 lines of Java, 448 Gradle modules in a zero-cycle DAG, and 55-occurrence autoconfiguration duplication.

Historical Zig compiler and standard library analysis with prod-code: source distribution, x86_64 codegen clones, errdefer patterns, and a remote ZLS refactoring example. Zig is now hosted on Codeberg.

An agent that knows what it wants but not what it is called has nothing to ask. We gave it a question box, then measured what decides whether the answer is any good: not the ranking, the prose your team did or did not write above each function.

Every agent harness runs 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, and it got faster, not just cleaner.

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.

Prod keeps agents' terminals on a server and shows them on a Mac and an iPhone. Three emulators disagreed about the same bytes, so we replaced them with one Rust engine that moves its state instead of a picture of it.

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.

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.