design note

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.

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.

A 5.7 MB binary wire block stream took 73 milliseconds to parse with standard MessagePack deserialization, one cost on an ingest thread reported to fall behind in market bursts. How SIMD search and fixed-point integers took per-block latency from 1,623 µs to 129 µs and throughput to 978 MB/s.

We pointed all 67 tools of prod-code at pola-rs/polars on an idle 32-core cluster node. 526K lines of Rust across 33 crates, 4 reported cycles that are dev-dependency edges, catching a UTF-8 non-char-boundary tokenizer panic, in-memory RAM validation, and 36-test remote execution.

We subjected quickwit-oss/tantivy to all 67 prod-code tools on an idle 32-core cluster node. Reported results: 7,156 module cycle paths, 18-file AST renames, clone detection in JIT expressions, and safe-delete invariants.

We pointed all 67 tools of prod-code at tokio-rs/tokio on an idle 32-core cluster node. From 6 reported dependency cycle paths and silent Deref evaluation ordering traps to an unhandled sysroot crash on Box-here is what happened.

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.

A market-data ring in /dev/shm now has identical copies on other hosts, same sequence numbers, same order: about 30 µs across a LAN by multicast, and 51.7 ms p99 across the Pacific with a clock offset good to a few milliseconds.

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.

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.

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.

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.

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.

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.

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.

The hand-off between a market-data reader and a strategy loop is one of the few latencies in a trading process under our control. How we built a lock-free channel for it, what broke on a 128-core ARM box, and where the assembly landed.