> a terminal UI (TUI) on top of an agent loop. ... TypeScript, using Node.js as the framework and V8 for the execution engine, with Ink and React for UI. That’s a respectable choice for a TUI application

Who would respect that???

> And for the needs of a console application, the performance implications in terms of startup, responsiveness, throughput, and memory consumption are also reasonable

Literally none of those things are reasonable and are specific issues people complain about because their expectations formed by other TUI apps are broken with such an approach

> A project that would have taken a whole team of developers a year or two before agents

Or it would've been a project that took less time overall with the better designed stack from the beginning since it could avoid time spent on this rewrite and its pains

In my personal experience, GitHub Copilot is pretty weak. Maybe it's just that I've used smaller models on it, but it just felt like the worst available harness, even behind Google Antigravity's.

Is there any redeeming quality to it nowadays? I'm curious what those eight hundred thousand lines of Rust actually do.

From what I understand, this runtime is used across a bunch of other Microsoft products with the "Copilot" naming. Does anyone understand Microsoft's current naming scheme regarding these products? I couldn't get even GPT 6 Astra to explain it reasonably to me.

Well, I guess I'm not even going to comment on my personal experience with Microsoft Copilot, or whatever bs that dashboard that launches the Office apps with an integrated AI chat is called.

Lastly, but not least:

   > During the port, the runtime took in ~300,000 production lines of TypeScript and shed ~430,000, while ~1,200,000 production Rust lines entered and ~365,000 left. In other words, the apparent stability of the TypeScript line in the above graph was actually hiding significant amounts of TypeScript churn.

This is the part I find really interesting. The resulting runtime is ~830k lines of production Rust. Even using their estimate that ~430k lines of production TypeScript passed through the port, that's still nearly twice as much production code.

They also say that agents wrote most of the Rust. Given how verbose LLM-generated code tends to be, I'd really like to see some analysis of why the implementation grew that much. How much of it is Rust and the new architecture, and how much is simply code the agents generated because generating more code is cheap?

The article points at the hidden TypeScript churn, but to me the much more interesting number is that ~1.2 million lines of Rust entered and ~365k were subsequently removed.