code intelligence

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.

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.

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 to write anything that does not compile.

We benchmarked all 67 prod-code AST tools against prometheus/prometheus: 385K lines of Go, 84 packages, 1,485 error checks, 99% slicing reduction, and Bug #740 fixed in remote module dependencies.

We benchmarked all 67 prod-code AST tools against bevyengine/bevy: 661K lines of Rust, 97 crates, 204 exact code clones, 2 dev-dependency loops, and Bug #739 discovered and fixed in fast-sync.

We benchmarked all 67 prod-code AST tools against astral-sh/uv: 559K lines of Rust, 74 crates, 347 duplicated test clones, a self-referential cycle in uv-preview, and Issue #738 resolved in fast-sync.

We benchmarked all 67 prod-code AST tools against kubernetes/kubernetes: 5.38M lines of Go across 17,823 files, 779 packages, 0% laptop CPU, and fixed Bugs #741 and #742 in Go signature compilation and predicate inversion.

We benchmarked all 67 prod-code AST tools against Alamofire: 39,000 lines of Swift, 92 error egress boundaries, 20 clone groups, and remote Apple Silicon test offloading.

We evaluated prod-code AST tools against arrow-kt/arrow: 72,889 lines of Kotlin across 757 files, 38-module Gradle architecture, structural search for the Raise DSL, and cluster-verified AST refactoring.

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 benchmarked all 67 prod-code AST tools against psf/black: 135K lines of Python, 12-callsite parameter object bundling across 4 files, import cycle detection in concurrency, 99.8% slicing reduction, and mathematical safety proofs in predicate inversion.

We benchmarked all 67 prod-code AST tools against curl/curl: 200,000 lines of C, 1,924 failure and diagnostic egress points, and parameterized AST codemods.

We evaluated prod-code AST tools against detekt/detekt: 132,028 lines of Kotlin across 1,105 files, 41-module Gradle architecture with 4 test cycles, structural search across 31 files, and cluster-verified AST refactoring.

We benchmarked all 67 prod-code AST tools against duckdb/duckdb: 681,000 lines of modern C++, QueryResult slicing, and catch2 matcher guardrails.

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.

We benchmarked all 67 prod-code AST tools against etcd-io/etcd: 220K lines of Go, zero cyclic dependencies across 1,094 files, 99.9% slicing reduction on Raft leadership transfers, 445 structural error returns in 1.2s, and interface contract safety refusals.

We benchmarked all 67 prod-code AST tools against expressjs/express: 21,000 lines of JavaScript, middleware routing DAGs, and prototype guardrails.

We benchmarked all 67 prod-code AST tools against tiangolo/fastapi: 118K lines of Python, 135-occurrence OpenAPI clone groups, 99.8% slicing reduction on dependency solving, parameter object bundling, and classmethod safety refusals in method extraction.

We benchmarked all 67 prod-code AST tools against pallets/flask: 18K lines of Python, blueprint static file clone clusters, 98.6% slicing reduction on request dispatch, dataclass parameter object bundling, and property safety refusals in boolean inversion.

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.

We benchmarked all 67 prod-code AST tools against git/git: 443,000 lines of C, 4,657 fatal and recoverable error exit points, and multi-file structural codemods.

We benchmarked prod-code AST tools against google/guava: 795,118 lines of Java, 5-module DAG resolution in 100ms, and 33-occurrence clone analysis.

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 circular DAG paths, catching a UTF-8 non-char-boundary tokenizer panic, in-memory RAM validation, and 36-test remote execution.

We benchmarked all 67 prod-code AST tools against django/django: 527K lines of Python across 2,932 files, 25 circular check paths, 99.9% slicing reduction, and mathematical safety proofs in Python predicate inversion and parameter bundling.

We benchmarked prod-code AST tools against apache/kafka: 1,717,457 lines across 6,218 Java and 257 Scala files, 64-module DAG resolution, and 125-occurrence data-object clone analysis.

We evaluated prod-code AST tools against Kotlin/kotlinx.coroutines: 113,379 lines of Kotlin across 1,039 files, 25-module clean DAG architecture, structural pattern search across 42 files, and cluster-verified AST refactoring.

We evaluated prod-code AST tools against ktorio/ktor: 295,995 lines of Kotlin across 2,423 files, 134-module Gradle KTS architecture with 100 test-fixture cycles, and cluster-verified AST refactoring.

We benchmarked all 67 prod-code AST tools against moby/moby: 387K lines of Go, 224 Protobuf varint clone occurrences, 99.9% slicing reduction on ContainerStart, 858 structural error returns in 1.9s, and interface protection during boolean inversion.

We benchmarked prod-code AST tools against netty/netty: 652,153 lines across 3,595 Java files, 61-module graph analysis isolating an all-to-bom circular dependency, and 510-occurrence Huffman lookup tables.

We evaluated all 67 prod-code AST tools against vercel/next.js: 1.2M lines of TypeScript, SSR render pipeline slicing, and cross-file boolean inversions.

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 benchmarked all 67 prod-code AST tools against facebook/react: 745,000 lines across 4,445 files, Fiber work loop slicing, and compiler generic guardrails.

We benchmarked all 67 prod-code AST tools against redis/redis: 211,000 lines of C, event loop slicing down to epoll_wait, and static non-call guardrails.

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.

We benchmarked all 67 prod-code AST tools against apple/swift-algorithms: 13,700 lines of Swift, 81 bounds invariants, and remote Apple Silicon test offloading.

We benchmarked all 67 prod-code AST tools against apple/swift-argument-parser: 30,000 lines of Swift, 64 error egress points, and remote Apple Silicon test offloading.

We benchmarked all 67 prod-code AST tools against apple/swift-collections: 71,000 lines of Swift, 1,279 boundary invariants, and remote Apple Silicon test offloading.

We benchmarked all 67 prod-code AST tools against microsoft/TypeScript: 264,411 declarations across 31,433 files, AST clone clusters, transitive slicing, and compiler in-memory validation.

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.

A struct with eleven fields shows ten, so any test value built from that answer is missing one and nothing says so until a build. 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.

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

We pointed the full 67-tool matrix of prod-code at BurntSushi/ripgrep on an idle 32-core cluster node. Sub-millisecond sync, AST slicing, 30 refactorings, in-memory pre-flight validation, and resolving Issue #735.

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

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.

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.

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.

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 rust-analyzer stays 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.

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.