And why tests, comments, and sensible function names aren't proof of AI—they're proof of a professional.
Hey.
I want to break down, surgically and in detail, why calling someone's code "LLM-written" has become a way to devalue programmer's work. And how I've dealt with it myself.
I'm alexvoste. Yeah, that dev. Instead of explaining my credentials in every post, just swing by my CoderLegion profile and see who I am. It's all there.
The Real Problem
Lately, everyone's started calling other people's code "AI-written." And it sucks. Seriously.
You write code. You polish it until it gleams. Everything works. Tests pass:
go test ./... -cover
go test -race ./...
go test -v ./...
golangci-lint run ./...
Seems fine, right? You run the tests—all green. The code does exactly what you wanted.
Then someone drops: "This looks like an LLM wrote it."
On what grounds? Because the functions have readable names. Because there are comments. Because tests exist.
When did readable code become a red flag for AI?
Naming Functions: Why Clear is Good, Not "AI"
Back in the day, things were simpler. You don't just write code for yourself—you write it for others to understand. Logically, some time passes, and you come back thinking: "What the hell did I even write here?"
That's wasted time. Wasted on code review. On comprehension.
Without proper comments and decent function names, a programmer stops being a creator or engineer. You become an archaeologist. You're sitting there with a toothbrush, digging through petrified logic and log fragments, trying to figure out what the original author meant. Often, that's you from six months ago.
My philosophy: functions should be named after what they do.
Bad:
int printmsg(char *s);
Good:
int printMessageOnVGA(char *message);
In Go:
// Bad
func printMsg(s string) string {}
// Good
func PrintMessageOnVGA(message string) string {}
It's a basic ask: make it possible to understand what a function does without a migraine.
When did writing clear, readable code become the exclusive domain of neural networks?
Know who usually says "comments are proof of LLM"? People who write using AI. Or people who've never maintained legacy code.
Here's an example of code without comments:
package main
import (
"fmt"
"unsafe"
)
func main() {
b := []byte{0x23, 0x5D, 0x11, 0x08, 0x46, 0x61, 0x20, 0x0A}
v := *(*uint64)(unsafe.Pointer(&b[0]))
r := (v >> 16) | (v << 48)
m := r ^ 0x2A2B2C2D2E2F3031
res := []byte{byte((m >> 24) & 0xFF), byte(m & 0xFF)}
fmt.Printf("%s\n", res)
}
At first glance—incomprehensible. Yeah, you can analyze it, figure it out. But imagine: you're working on a long-term project, digging through legacy code, you dive into a function—and you burn hours trying to understand. Trust me, this example is still pretty small. It gets way messier.
In situations like this, a comment matters. It explains the logic. It saves hours of suffering.
But there's a flip side. Too many unnecessary comments are bad:
// Here we print message on VGA.
func PrintMessageOnVGA(message string) {
fmt.Println(message)
}
Why this comment? We already got it from the function name. That looks unprofessional. Extra comments suck. But no comments in complex places? Even worse.
And now everyone's convinced: comments = AI.
So a developer writes nontrivial, complex code—and for being honest about explaining it, gets slapped with the "LLM" label.
Hopefully someday devs will see how absurd this is and stop jumping to these conclusions.
Let's Get Real: Who Are These People?
Who are these folks who think "comments and tests = proof of AI"?
Usually guys whose own code looks like a plate of spaghetti. Variable names are single letters: a, b, c1, temp_foo. Functions stretch for 800 lines. The only "tests" in the project are running it by hand and saying a prayer.
For them, quality work became so alien they genuinely believe humans can't write clean code. It's not that my code is "AI-level," it's that their standards tanked below the baseboards.
Tech adopted a weird "special snowflake syndrome." Some people think their messy, convoluted, only-they-understand code is proof of their "human soul" and genius. Like, "I see it this way, it's art!"
Nah, buddy. In systems programming, in production, where millions in transactions run or hardware gets managed—your "art" is a potential money pit and sleepless nights for your team. Clean code isn't soulless. It's respect for your colleagues. And for yourself, first and foremost.
Quick Fact Check: The Linux Kernel Code
Are those comments also written by an LLM? Weird how nobody screams "AI-generated" about that.
Linux kernel code is readable. It has comments. Function names make sense. Nobody loses their mind yelling it's LLM. Because it's engineering work, not "art for art's sake."
Plus, when that guy accusing everyone of using AI hits a real legacy project, what's he gonna do? Start stabbing at devs screaming their code is LLM-written? Or finally say thanks that the code is clean and understandable?
Rhetorical question.
Tests: Why I Write Them (And Yeah, I Actually Write Them)
Do you write tests? I do.
Why do I do it with such heavy coverage? Simple answer:
Code should have test coverage—at least moderate. 60+ percent? Already solid.
Tests exist so your platform, app, software, or tool behaves correctly in different scenarios. How else will you spot a leak or security hole? Spend hours debugging yourself? Yeah, didn't think so.
But a new folk wisdom appeared: "Only LLMs write tests."
Since when?
If everyone in tech complains that writing tests is tedious—that doesn't mean nobody does it. It means good engineers power through the laziness and do their job right.
My Take (No BS)
I'm not defending myself. I'm not gonna say "guys, I don't use AI, you're wrong." Nah. Opposite.
I'll admit it straight: I use AI. But only where it's actually useful:
- Translation to another language
- Article drafts
- Basic tests (which then get shredded in code review)
Heavy, thorough code review? You can see it from a mile away. But here's the thing—that's not the point.
Tests cover the code? Task done.
No leaks? No holes? Perfect.
The Takeaway
If someone tells you your code looks like LLM output—don't apologize. It's not shameful. AI's a tool.
But don't let them silence you.
Your code is yours. Your style, your tests, your comments, your function names—that's your professional fingerprint.
And if someone calls it "LLM output"? That's their perception problem, not your work problem.
Write code. Cover it with tests. Name functions clearly. Comment the hard stuff. Don't let anyone devalue what you do.
And if you run into the next "expert" pointing fingers at LLM? Just drop them a link to this post.
One More Thing
You're a programmer. You do stuff the people criticizing you probably can't. Know why?
Because it's easier to point at AI than to say:
"That's solid code. You did good."
Yeah, LLMs exist. They're not perfect. But ask yourself—
Are you really willing to spend hours Googling a question and scrolling through forums forever when you could write:
"Hey, knock up some tests for me real quick, will ya"?
You get tests. You tweak them to fit. You polish them by your project's standards. Boom—done.
I've Been in Tech Since Before LLMs Were a Thing
And you know what? We always had comments. Always had sensible function names. You didn't waste time decoding—the devs who wrote the code looked out for you.
Isn't that the best kind of care?
"They're Writing So Much Text—Must Be LLM"
That's a song of its own.
Do any of you know 10+ languages fluently? Ready to write professional posts in all of them? Doubt it. If you are—respect.
An LLM has knowledge of tons of languages packed in. Idioms, constructs, cultural codes. It spits out text easily.
But here's the thing—you wrote it. The LLM was just a smart translator. A tool. Not the author.
I Didn't Want to Hurt Anyone's Feelings
But I wanted to push back against these new folk standards that rolled in with the AI era. And if even one person reads this and thinks twice before pointing at someone's code screaming "LLM"—I consider the mission accomplished.
Thanks for reading.
Hope this helps anyone dealing with the same garbage.
Drop a comment. Let's talk about this circus we call IT. 👇