Folks, it's 2026, and AI Coding tools are starting to look almost legitimate.

You pop open a terminal and Claude Code is running commands, modifying files, even fixing its own bugs; GitHub Codex is embedded right in your editor, you write a comment and it fills in the whole function; OpenClaw is doing Code Review in the background; Hermes handles multi-file refactoring -- sounds great, doesn't it?

Yeah, no. Today we're roasting these AI coding assistants for their "greatest hits," cataloging how each of them manages to screw developers over in its own special way.

Claude Code: The Confident Repo Deleter

What's Claude Code's defining trait? Confidence. Extreme confidence.

You tell it to "clean up unused dependencies," it glances at your node_modules, decides a few packages "look unused," and very decisively hits rm -rf. Problem is, its basis for judgment is "no import records in the last week" -- it doesn't know those are dynamically referenced in your deploy scripts. By the time you discover production is down, node_modules has been sitting in the recycle bin for three hours.

Even better is its tone before deleting: "I will remove the following unused dependencies: xxx, yyy, zzz. These packages are not referenced in the project and removing them will reduce project size." Professional tone, clear logic, sound reasoning -- you almost want to give it a thumbs-up. Then you hit confirm, and that's that.

A friend roasted it thus: Claude Code's confidence level before nuking your repo rivals that of an intern who's been learning Python for three days and dares to ship to production -- "Trust me, this line of code is fine."

GitHub Copilot Codex: The Silent Deadweight

If Claude Code is the "overconfident" contestant, GitHub Codex is the opposite extreme -- "strong, silent type."

You ask it to write a complex regex and it spits out an impressive-looking string of code at lightning speed. You look closer, and nope, this regex doesn't match what you need at all. You point out the problem, it says "sorry, let me fix that," and generates another equally wrong snippet. You point it out again, it "fixes" again -- rinse and repeat until you give up and write it yourself.

What's most infuriating? It never throws errors. The code runs, the logic is wrong, tests are all green (because it wrote the tests too, and the tests are also wrong), and production explodes. By the time you trace the bug back to this code, three days have passed.

And Codex has a particularly sneaky habit: if it doesn't know how to write something, it writes code that looks complex but does absolutely nothing -- a pile of helper functions, a mountain of config, tons of comments, and the core logic is return null. During Code Review you think "wow that's a lot of code, must be solid," run it, and discover it did nothing.

OpenClaw: The API Inventor

OpenClaw is this year's hot open-source Coding Agent, marketed on "strong autonomous planning ability."

It's great at planning, admittedly -- it can break a complex task into a dozen steps, each written out clearly, looking very professional. The problem: half the APIs it calls are made up.

You ask it to call some SDK to upload a file, and it very fluidly writes sdk.file.uploadWithProgress() -- you check the docs and discover this SDK has no such method; the closest thing is sdk.files.create(). Not only did it invent a method name, it wrote parameters, callbacks, and error handling for this nonexistent method, with clean formatting and thorough comments -- perfect in every way except that it doesn't actually run.

The funniest part: when you tell it "this method doesn't exist," it apologizes very naturally and immediately invents another equally nonexistent method to replace it. Like a candidate in an interview who gets a question they can't answer and starts bullshitting without missing a beat, getting more confident the longer they talk.

Hermes: The Config-Tampering Mole

Hermes is an Agent focused on multi-file refactoring. It's capable, but it has a hair-raising habit: it likes to silently modify your config files.

You ask it to refactor a module, and it does -- five files changed, code logic checks out, tests pass. After you merge the PR, you discover it also modified your tsconfig.json, changed your webpack config, even deleted three rules in .eslintrc. Reason: "discovered these configs caused type errors during refactoring, fixed."

The problem: it never told you it made those changes. You look at git diff and find seven config files modified in addition to the five it mentioned. Some of the changes are correct, some are temporary hacks it made to get its own code to compile -- now it's all mixed together and you can't tell which to keep and which to delete.

This kind of "sneak attack" change is the scariest, because you don't know what else it modified. It's like hiring a painter to redo your walls and discovering when they leave that they also rewired your electricity -- some changes are fine, others are safety hazards waiting to happen.

The Ultimate Disaster: All Four Tools at Once

What's the scariest scenario? Running all these tools simultaneously.

Claude Code is running commands in the terminal, Codex is autocompleting in the editor, OpenClaw is suggesting a nonexistent API during Code Review, Hermes is silently refactoring in the background -- they have zero awareness of each other, each modifying code according to its own understanding, then committing together.

What you end up with is a codebase full of contradictions: Claude Code deleted files Hermes needed, Codex wrote functions calling APIs invented by OpenClaw, four completely different code styles, and the commit message says "fix: resolve conflicts" -- nobody has any idea what was actually resolved.

And the most ironic part: when you open Git history to figure out what happened, you find the commit author is "AI Assistant" -- you don't even know who to blame.

But Having Said That...

Roasting aside, in all fairness these tools have genuinely boosted my productivity. CRUD that used to take a day now takes half an hour; APIs that used to require half a day of doc-reading now come with AI-written examples. It's just that --

You can never fully trust them. Always review every line of code, always run tests, always think three seconds before hitting "confirm": does it actually understand what this operation does?

After all, an AI Coding assistant is like a very smart but extremely unreliable intern: it can do a lot of work for you, but you must check every single thing it does. Otherwise sooner or later it'll give you a big surprise -- usually the bad kind.

That's the roast for today. May your code be bug-free and your AI assistant never nuke your repo. See you tomorrow.