Stop Using AI to Write Code. Start Using It to Read the Code You’re Terrified Of.

You know that feeling. You crack open a binary, fire up your decompiler, and what stares back at you is a wall of sub_4012A0, v1, v2, v3 — a spaghetti monument to every developer who left the company before you. You scroll. You squint. You whisper “what the hell does this even do?” to an empty room at 2 AM.

Now here’s the twist everyone’s missing.

While the entire tech world is drooling over AI coding agents that write new code — generating React components, spinning up CRUD apps, churning out boilerplate — almost nobody is talking about the problem that actually keeps developers and security researchers awake at night: making sense of the code that already exists.

The messy code. The undocumented code. The malicious code. The 40-year-old COBOL running your bank. The obfuscated malware payload. The third-party binary with no source and no docs and no original developer because they died in 2011.

That’s the real battlefield. And AI agents are barely showing up.

Writing new code is the easy problem. Reading old code is the one nobody solved.

Think about it. Generating code from a prompt is a party trick — impressive, sure, but the spec is right there in front of you. Reverse engineering is different. You’re starting from the ending. You have a compiled binary, stripped of names, stripped of structure, stripped of intent, and you have to reconstruct the human reasoning that produced it. That’s not generation. That’s archaeology.

And here’s where it gets genuinely interesting — and a little unsettling. The same AI agents that accelerate code creation are also accelerating code obfuscation. Malware authors use LLMs to generate polymorphic variants. Legitimate developers use agents to ship faster, generating code nobody fully understands. We’re building a world where code is produced at machine speed but comprehended at human speed.

That gap is going to eat us alive.

Enter Kuna, a decompiler built for this exact moment. Not a decompiler that just translates assembly to pseudo-C and leaves you to figure out the rest — but one that acknowledges the reality of 2025: if AI can write the code, AI should be able to read it back.

The traditional decompiler workflow is a relic. You dump disassembly, you rename variables by hand, you trace data flow mentally, you build a mental model function by function, and after six hours you realize you mislabeled something in hour one and have to start over. It’s painstaking, error-prone, and it scales exactly as well as one human brain can scale — which is to say, badly.

An agentic decompiler changes the math. Instead of you tracing data flow, the agent tracks it — across functions, across modules, across calls you didn’t even know existed. Instead of you guessing that sub_4012A0 is probably a string decoder based on context, the agent synthesizes a name from the data flow patterns, the call sites, the surrounding context. It’s the difference between reading a map and having a guide who’s already been there.

The best reverse engineer of the future won’t be the one who reads assembly fastest. It’ll be the one who asks the agent the best questions.

Now let me be clear about something, because this is where I take a side. This is not about AI replacing reverse engineers. That take is lazy and wrong. The people who say “AI will replace developers” have never stared at a stripped binary and tried to figure out whether that weird arithmetic is a custom crypto routine or just a broken compiler optimization. Context matters. Experience matters. The smell test — “this doesn’t feel right” — matters.

What AI agents do is handle the mechanical misery. The renaming. The flow tracing. The pattern matching across 10,000 functions where no human has the patience to check all of them but an agent absolutely does. They clear the underbrush so you can see the forest.

And here’s the recursive loop that makes this genuinely profound: AI agents generate code. That code gets compiled, shipped, abandoned, obfuscated, or weaponized. Then AI agents are needed to decompile, understand, and verify that same code. Creation and analysis become a closed loop — machines writing for machines to read. Humans become the orchestrators, the question-askers, the ones who decide what matters.

We’re not just changing how code is written. We’re changing who gets to understand it.

That last sentence matters more than you think. Right now, reverse engineering is a rare skill. The number of people who can look at a stripped binary and say “this is a C2 beacon” with confidence is vanishingly small. If agentic decompilers work — and they will — that skill gets distributed. A junior analyst with a good agent can do what used to require a graybeard with twenty years of experience. The bottleneck moves from “can I read this?” to “do I know what to look for?”

That’s democratization. That’s also disruption. Some people will be uncomfortable with that. Good.

Because the alternative is worse. The alternative is a world where code is generated at infinite speed by agents, shipped into production by teams who don’t fully understand it, exploited by attackers who do, and defended by humans who can’t keep up. That’s not a future. That’s Tuesday.

So here’s where I land: stop treating AI coding agents as just forward-development tools. The real unsolved problem — the one that actually matters for security, for legacy maintenance, for trust in software itself — is using them to read, understand, and verify the code we’ve already got. The backlog is enormous. The binaries are opaque. The malware is evolving.

The agents that write code are a productivity story. The agents that read code are a survival story. And if you’re in security, in reverse engineering, in any role where understanding existing code is your job — your workflow is about to change whether you’re ready or not.

The question isn’t whether AI will understand the code we can’t. It’s whether you’ll be the one directing it — or the one being replaced by someone who is.