Compression is the wrong contest.
Jose Valim argues that programming languages made for coding agents should not optimize around today's syntax and token limits. Agents are not bothered by explicit signatures or repeated forms in the way a person is. Those details can give the compiler and later reviewers more facts to check.[1]
That does not make human ergonomics disposable. People still read diffs, own failures, and maintain the result. It means the agent-specific work belongs in the interfaces around the program. Make structure queryable. Make constraints enforceable. Make running state inspectable without granting a mystery process the keys to production.
The useful question is not, "Can the agent write this language?" Ask, "What can the language stack prove and expose after the code exists?"
Give program structure a query path.
Language servers already know symbols, references, definitions, and often richer relationships. Their common interface is shaped around a person pointing at a file, line, and column. Valim proposes exposing program data through a queryable database so an agent can ask broader questions about callers and data flow.[1]
SCIP shows that part of this idea already has a real artifact. It is a language-neutral protocol for source indexes. Its repository lists indexers for TypeScript, Rust, Java, Python, Ruby, C and C++, .NET, Dart, PHP, and other sources. The protocol supports code navigation such as definitions, references, and implementations.[2]
An index is not a full program database. It also does not prove that a call is safe. It does provide a stable layer that tools can inspect without scraping an editor window. That is a stronger starting point than another chat command named "find references."
Running code needs a different witness.
Static structure stops at the process boundary. OpenTelemetry separates runtime signals into traces, metrics, and logs. Its primer says logs alone often lack the context needed to track execution. A trace ties spans into the path of one request across services.[3]
Erlang's Observer documents a more runtime-specific view. It can inspect supervisor trees, processes, message queues, stack traces, ETS tables, ports, and tracing state. The manual also says to run Observer from a separate node to reduce the effect on the observed system.[4]
These are not interchangeable systems. OpenTelemetry defines portable telemetry concepts. Observer exposes facts from one runtime. Together they make the boundary clear. Code structure answers where a behavior can come from. Runtime signals answer what happened in this execution.
Exposure needs a brake.
A query interface can become a capability interface. Process messages may contain customer data. Traces may carry headers or identifiers. A runtime console may include actions that kill a process or change tracing. Observer's own process menu includes a kill action.[4]
Do not turn "agent observable" into "agent omnipotent." Give read access to the narrowest useful data. Strip secrets at collection time. Separate inspection credentials from mutation credentials. Record the query, target, revision, and result. Require a human gate before an investigation turns into a production change.
Buy the stack, not the slogan.
When a language or framework claims to work well with coding agents, ask for four artifacts. Find the contract checker. Build the index and run a real query. Capture one runtime incident with scoped credentials. Replay the failing case in a test or model. If one of those paths is missing, name the missing path instead of replacing it with a syntax demo.
The language does not have to provide every part itself. A compiler, indexer, runtime, telemetry collector, and test harness can share the job. What matters is that each claim has an inspectable output and a bounded route to obtain it.