If Agents Write the Code, Why Keep Paying the Interpreter Tax?

Evis Drenova, co-founder of the data security startup Neosync, spends 70 seconds making one bet about where programming languages go next. When AI agents write most of the code, the human-ergonomics advantage of interpreted languages like Python and JavaScript stops mattering, and compiled, statically typed languages like Go, Rust, and C++ start winning by default. The video is a single talking-head take, filmed on a couch with the caption "Interpretered vs compiled" pinned on screen the whole way through. The typo stays up for all 70 seconds, which is a fitting reminder that humans still ship the captions.

The Core Claim

Drenova says he "wouldn't be surprised if you start to see interpreted languages like JavaScript and Python start to lose a lot of market share among developers." His reasoning is a cost-benefit question: if your agent can write your code in a fast, compiled, statically typed language, "why would you accept the overhead of an interpreted language with dynamic typing?" The overhead he means is runtime overhead. Interpreted languages trade execution speed for developer convenience, and dynamic typing trades compile-time guarantees for flexibility. Both trades were made with a human author in mind.

Ergonomics Was the Whole Selling Point

The strongest part of the argument is the history. "Python, for example, is created to make programming easier for humans. But we don't really have that constraint anymore." He applies the same logic to TypeScript, which "was created to make JavaScript have static types." These languages won because they lowered the cost of human authorship: readable syntax, fast iteration, no compile step. If an agent is the author, those costs drop toward zero in any language. An agent does not get tired of Rust's borrow checker or C++ template errors. The selection pressure that made Python dominant weakens when the thing feeling the friction is a model, not a person.

The Rewrite Wave Is Already Visible

Drenova points to what he sees on Twitter: "I can't tell you how many times you'll see somebody saying I'm rewriting XYZ in Rust. Postgres in Rust. Postgres was written in C, but you get the point." That example is real. A project called pgrust, an AI-assisted Rust rewrite of PostgreSQL, hit Hacker News claiming to pass 100 percent of the Postgres regression suite, built largely by parallel coding agents. It is explicitly not production ready, and commenters pushed hard on the benchmark claims, but it demonstrates the mechanism Drenova is describing. Rewrites that used to cost person-decades now cost agent-hours plus review time, which changes which rewrites are worth attempting.

Where the Argument Gets Thin

Drenova hedges once: interpreted languages may keep growing "amongst people who want to continue supporting applications that are already written in that." That hedge deserves more weight than he gives it. Python's position in AI itself is a counterexample, since the ecosystem of libraries, notebooks, and glue code is the product, not the syntax. Ecosystems, hiring pools, and billions of lines of existing code have kept COBOL alive for 60 years. His closing question, "why would you not choose the fastest tool for the job when you have that option," assumes runtime speed is the binding constraint. For most CRUD apps and scripts it is not, and never was.

Key Takeaways

The thesis: AI agents remove the human-ergonomics reason interpreted languages exist, so compiled, statically typed languages become the rational default for new code.
Python and TypeScript were both designed around human limitations. Agent authorship weakens that design rationale directly.
The "rewrite it in Rust" trend is a leading indicator. The pgrust project shows agents can now attempt rewrites that were previously uneconomical, even if the results are not production ready.
The main counterweight is ecosystem gravity: existing codebases, libraries, and hiring pools, which the video acknowledges only in passing.
Watch new greenfield agent-written projects, not rewrites, for the real signal on whether language market share actually shifts.