# 100k lines of AI-ported Rust nobody can review is not an achievement

> Source: <https://dev.to/adioof/100k-lines-of-ai-ported-rust-nobody-can-review-is-not-an-achievement-3pf8>
> Published: 2026-06-30 10:09:12+00:00

Someone ported 100k lines of TypeScript to Rust in a month using AI. They don't know Rust. People are calling it an achievement.

I'm calling it a liability.

Here's the setup. A developer fed a massive TypeScript codebase into an AI tool and got Rust out the other side. 100k lines. One month. Zero prior Rust experience.

In theory, it all seems amazing. In practice, it raises a question nobody wants to ask: **who reviews this code?**

This is the part that is so painful. If you are not familiar with Rust, you didn’t really port anything, you just told a machine to produce output in a language you are unable to assess.

That isn't engineering at all. It's more like a trust exercise using a random text generator.

Skilled Rust developers who reviewed the output raised red flags right away. The excessive use of `Arc<Mutex<...>>`

wrappers – a common anti-pattern indicating a lack of understanding of Rust's ownership system, where everything is wrapped in thread-safe reference counting simply to silence the compiler. The code compiles. It runs. But the essence of using Rust is lost.

→ Rust's value is zero-cost abstractions and compile-time safety guarantees

→ Slapping `Arc<Mutex<>>`

on everything turns Rust into a slower, harder-to-read Go

→ The compiler stops complaining, but the architecture is lying to you

Here's the other thing. **No test suite was ported first.**

Just think about it for a moment. You are in possession of 100k lines of code that were automatically generated using a language that is foreign to you, and you don't have a tool to automatically check if the behavior is similar to the original one. Is it functional? You can't be sure. You just have to believe it.

The first step in a true port is to have tests. You transfer the test suite, then you transfer the implementation, then you execute the tests. This might not be the most exciting or glamorous process, but it is the most effective one. It's also the only version that actually works.

If there are no tests, you basically end up with 100k lines of unverified Rust code that no team member can update. It's not really a port. It's just accumulating technical debt that happens to have a Rust logo on it. 🦀

I’m not against AI code generation. I use it every day. But there’s a huge difference between using AI as a tool to speed up things when you get what the results are and using AI as a substitute for getting the results.

When an issue occurs in that 100k-line codebase — and it's inevitable — a person must debug Rust. Not "request AI to debug Rust." You have to read the borrow checker errors, comprehend the lifetime annotations, follow the ownership graph. If there's no one on the team able to handle that, you're screwed iterating errors through the AI and crossing your fingers.

→ AI-generated code you understand is a productivity multiplier

→ AI-generated code you don't understand is a time bomb

→ The explosion is just deferred, not prevented

Though the caption reads "One month", a blitzkrieg approach devoid of understanding isn't really speed; it's movement.

I've seen teams rewrite systems in half the time by cutting scope ruthlessly and understanding every line. Conversely, I have seen teams "move fast" for the same amount of time and then struggle for the next two years. The second group always started out bragging about speed too.

The flashy version of this would be: “I used magic AI to learn Rust and port 20k critical lines in three months with a single test failing but it was right. Then a griffin delivered my performance improvements.” But that’s boring. And also how it works. 💡

Writing code is no longer difficult. **Understanding code is the hard part.** It always was, honestly. AI just made it possible to skip the understanding step at scale, which means the consequences of skipping it also scale.

If your team can't review it, maintain it, and debug it at 3 AM when production is down — you didn't ship an achievement. You shipped a future incident report.

**What's your bar for "good enough" when it comes to AI-generated code in a language the team doesn't know?**