💻 computer science

Do Machines Struggle Where Humans Do? LLM and Human Comprehension of Obfuscated Code

This paper evaluates whether large language models share human failure modes when comprehending obfuscated code, finding that reasoning-tuned models significantly align with human difficulty patterns across various obfuscation tiers, whereas instruction-tuned models do not.

Original authors: Jack Le, Anh H. N. Nguyen, Tien N. Nguyen

Published 2026-07-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jack Le, Anh H. N. Nguyen, Tien N. Nguyen

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to solve a puzzle. Now, imagine someone takes that puzzle and does two things to it:

Renames the pieces: Instead of "King," "Queen," and "Pawn," the chess pieces are labeled "X," "Y," and "Z." Or worse, the "King" is labeled "Pawn" to trick you.
Scrambles the instructions: Instead of a clear path like "Move forward, then turn left," the instructions are broken into tiny, disconnected steps that require a complex map to figure out the order.

This is what code obfuscation does to computer programs. It keeps the program working exactly the same, but makes it incredibly hard for humans to read and understand.

This paper asks a simple but profound question: Do AI models (Large Language Models) struggle with these scrambled puzzles in the same way humans do? Or do they fail in a completely different, mysterious way?

Here is the breakdown of their findings, using everyday analogies:

1. The "Smart" AI vs. The "Trained" AI

The researchers tested different types of AI models. Think of them like different types of students:

The "Coder/Instruct" Models: These are like students who have memorized a massive textbook of code examples. They are great at spotting patterns (like seeing the word "print" and knowing what to do). But when you scramble the puzzle, they get confused because their "pattern matching" breaks. They don't really understand why the code works; they just know what it usually looks like.
The "Reasoning" Models: These are like students who have been taught how to think. They don't just memorize; they try to work through the logic step-by-step.

The Big Finding: The "Reasoning" models struggled with the scrambled puzzles exactly the same way humans did. When the puzzle got harder (more obfuscated), both the humans and the reasoning AIs got slower and made more mistakes. The "Coder" models, however, didn't care as much about the difficulty; they just failed randomly or didn't get harder, showing they weren't actually "thinking" through the problem like a human would.

2. The "Confident Mistake" Trap

One of the most interesting parts of the study involves a specific trick called Adversarial Renaming.

The Scenario: Imagine a function that calculates a tax rate is named calculate_tax. The obfuscator changes the name to calculate_bonus.
The Human Reaction: A human programmer sees "bonus" and thinks, "Wait, that doesn't make sense for tax," but they might still get confused if the code logic is messy.
The AI Reaction: The "Reasoning" AIs sometimes fell for the trap. They saw the word "bonus," assumed the code was about giving money, and confidently gave the wrong answer.

The paper found that this "confident mistake" only happened when two things happened at once: the name was misleading AND the code structure was confusing. It's like if someone handed you a map of a city but labeled the "Hospital" as "Pizza Place," and the streets were all one-way loops. You would confidently drive to the "Pizza Place" (the Hospital) and get lost.

3. The "Thinking Time" Meter

The researchers looked at how much the AI "thought" before answering. They measured this by counting the number of words the AI generated in its "Chain of Thought" (its internal monologue).

The Human Parallel: When humans face a hard puzzle, they take longer to solve it.
The AI Parallel: When the puzzle got harder, the AI generated longer and longer internal monologues.
The Catch: Interestingly, the AI didn't just get better at solving the hard puzzles by thinking longer. In fact, the longer the AI thought, the more likely it was to get the answer wrong. It was like a student staring at a math problem for an hour, writing pages of notes, but still getting the answer wrong because the problem itself was too tricky. The length of the thinking was a sign of difficulty, not a sign of success.

4. The "Expert" Difference

The study also looked at human experts vs. beginners.

Beginners: When the code was scrambled, beginners got much worse at solving it.
Experts: Surprisingly, experts sometimes got better at solving the slightly scrambled code. Why? Because they stopped relying on the names of the variables (the "King" or "Pawn" labels) and started looking strictly at the logic and structure.
The AI Gap: None of the AI models, even the smartest ones, could replicate this "expert" behavior. They didn't get better at the slightly scrambled code; they just got worse. This suggests that while AI is getting good at reasoning, it hasn't quite reached the level of human intuition where it can ignore misleading labels and focus purely on the underlying structure.

Summary: What Does This Mean?

Do AIs understand code like humans? The "Reasoning" AIs are starting to. They get stuck on the same hard puzzles humans do. The "Coder" AIs are just pattern-matching machines that fail differently.
Can we trust AI with confusing code? Not blindly. If the code has weird names or confusing structures, the AI might give you a very confident, very wrong answer.
The "Thinking" Signal: If an AI starts writing a very long, rambling explanation to solve a simple problem, it's not a sign of genius; it's a sign that the AI is struggling and might be about to make a mistake.

In short, the paper shows that we are building AIs that are beginning to "think" like humans, but they still have a long way to go before they can handle the messy, confusing, and tricky code that real-world developers deal with every day.

Technical Summary: Do Machines Struggle Where Humans Do? LLM and Human Comprehension of Obfuscated Code

Problem Statement

Code obfuscation is widely used to protect software from reverse engineering by deliberately impairing human code comprehension while preserving program semantics. While prior research (specifically Nguyen et al. [1]) has established that obfuscation disrupts human reasoning patterns—forcing a shift from intuitive "System 1" processing to deliberate "System 2" reasoning—it remains unclear whether Large Language Models (LLMs) exhibit similar failure modes. The central problem addressed is whether LLMs understand obfuscated code in a manner aligned with human understanding or if they fail via different mechanisms. If models fail differently, high benchmark performance on standard tasks may mask a brittle competence that collapses under transformations humans can still navigate.

Methodology

The authors conducted a mixed empirical study comparing LLM performance against a human baseline established by Nguyen et al. [1].

Datasets: The study utilized two datasets. Dataset A (20 snippets from HumanEval-X in Python and JavaScript) was used to directly compare LLMs with human participants across five obfuscation tiers. Dataset B (250 snippets from HumanEval-X, CruxEval-X, and LeetCode) was used for model-only analysis of reasoning traces.
Obfuscation Tiers: Five levels were tested:
- L0: Original code.
- L1: Identifier renaming (replacing meaningful names with incoherent ones).
- L1b: Adversarial renaming (replacing identifiers with semantically meaningful but misleading names).
- L2: Control-flow flattening (decoupling logic from syntax using dispatchers).
- L3: Combination of L1 and L2.
Models: A diverse set of LLMs was evaluated, including reasoning-tuned models (e.g., DeepSeek-R1, SmolLM3), instruction-tuned models, and coder-tuned models, ranging from 0.5B to 8B parameters.
Evaluation Framework:
- Primary Metric: Output prediction accuracy (exact match to ground truth).
- Theoretical Lens: Schulte's Block Model [2] was used to localize failures at four levels: Atoms (lexical elements), Blocks (semantic regions), Relations (dependencies), and Macro Structure (overall algorithm).
- Reasoning Analysis: Chain-of-Thought (CoT) trace length was used as a proxy for mental effort. Confidence metrics (z-scored log-probabilities) and "Identifier Spike Fractions" (token-level uncertainty) were analyzed to detect confident misinterpretations.
Experimental Design: Experiments varied prompt conditions (baseline, System 2 prompting, cognitive interference, token budgets) to isolate reasoning behaviors.

Key Contributions

Formulation of Human-Machine Alignment: The paper establishes a framework for measuring alignment between human and machine understanding of obfuscated code, using human difficulty patterns as a baseline.
Systematic Evaluation: A comprehensive study of LLMs across multiple obfuscation tiers in Python and JavaScript, comparing model behavior against reported human difficulty patterns.
Failure Mode Localization: Using the Block Model and reasoning traces, the authors identify where alignment emerges and where machine understanding diverges from human understanding.
Empirical Findings: The study reports that reasoning-tuned models approximate human sensitivity to code complexity, whereas instruction and coder-tuned models do not.

Results

1. Alignment with Human Difficulty (RQ1 & RQ2)

Reasoning Models: Reasoning-tuned models (e.g., DeepSeek-R1-Qwen-7B, SmolLM3-3B) show significant positive correlation ( $\rho \approx 0.30–0.47$ ) with human accuracy across obfuscation tiers. They struggle with the same tasks humans find difficult.
Coder/Instruct Models: Instruction-tuned and coder-tuned models show near-zero correlation with human performance, indicating they fail via fundamentally different mechanisms.
Expertise Levels: Reasoning models align with human difficulty patterns across all experience levels (beginner, intermediate, expert). However, no model reproduces the specific "expert inversion" where human experts perform better under moderate adversarial renaming (L1b) compared to beginners.
Architecture vs. Size: Reasoning models consistently outperform coder and instruct models regardless of size. Notably, Phi-4 Mini (4B) showed the highest alignment with human task-level behavior, despite lower raw accuracy.

2. Chain-of-Thought (CoT) and Effort (RQ3)

Trace Length as Difficulty Proxy: There is a significant negative correlation between CoT trace length and accuracy ( $\rho = -0.52$ ). Longer traces consistently correlate with incorrect answers, suggesting that trace length tracks task difficulty rather than serving as a signal of confusion or productive deduction.
Scaling Effort: Models exhibit a monotonic increase in CoT length as obfuscation increases (L0 to L2), whereas human response times jump from L0 to L1 and then plateau. This suggests models scale computational effort more linearly, while humans switch cognitive modes.
Token Limits: Strong reasoning models collapse under strict token limits, confirming their performance relies on "System 2" deliberation.

3. Adversarial Renaming and Confidence (RQ4)

Confident Errors: Adversarial renaming (L1b) triggers high-confidence incorrect answers (HCI) only when semantic displacement (misleading names) and identifier-level disruption (high token uncertainty/spikes) occur simultaneously.
Atom-Level Failure: This failure mode is localized to the "Atom" level of the Block Model. Misleading identifiers disrupt the mapping between surface cues and computation without necessarily breaking structural reasoning.
Model Variance: The direction of confidence shifts (increase or decrease) under adversarial renaming is task- and model-dependent. Code-specialized models tend toward confidence suppression, while reasoning-distilled models show the opposite.

Significance and Implications

For Software Engineering

Model Selection: For tasks requiring code comprehension, debugging, or review, reasoning-tuned models are preferable not just for accuracy, but because their failure modes align with human developers. This makes their reasoning traces easier to inspect, calibrate, and supervise.
Risk of Over-Reliance: The study cautions against treating verbose reasoning (long CoT) as a sign of reliability; under strong obfuscation, long traces often indicate struggle. Similarly, confident explanations should not be trusted when identifier semantics are suspicious (e.g., in obfuscated or legacy code), as this can lead to high-confidence errors.

For Software Security

Obfuscation Efficacy: Current LLMs do not render traditional obfuscation obsolete. Transformations like control-flow flattening and adversarial renaming still create meaningful comprehension barriers for models, preserving the protective value of obfuscation against LLM-assisted reverse engineering.
Adversarial Vulnerabilities: Adversaries can exploit the "atom-level" vulnerability by using benign-looking but misleading identifiers to cause LLMs to confidently infer safe behavior while missing malicious functionality. This highlights a shared blind spot between humans and machines.
Analyst Assistants: Reasoning-tuned models may serve as effective assistants for malware analysis because they fail more predictably (in ways humans can understand), making them easier to supervise in security workflows where a wrong explanation can have severe consequences.

The paper concludes that while LLMs are powerful, their "understanding" of obfuscated code is not uniform. Reasoning-tuned models offer a closer approximation to human cognitive limitations, making them more suitable for collaborative software engineering and security tasks where human oversight is critical.