Code Hallucinations: Risks & Remedies

• Code hallucinations is a phenomenon where LLMs generate plausible yet erroneous code that deviates from explicit requirements, introducing functional failures and security vulnerabilities.
• They are categorized into syntactic, runtime, functional, code quality, and context-related hallucinations and measured using metrics like Hallucination Rate and Package Hallucination Rate.
• Mitigation strategies include retrieval-augmented generation, prompt engineering, supervised fine-tuning, static analysis, and dynamic testing to reduce errors and improve reliability.

A code hallucination is the phenomenon where a LLM, during automatic code generation, produces source code that is plausibly structured and often syntactically or semantically valid, yet deviates from ground-truth requirements, misuses non-existent, deprecated, or ill-scoped elements, or introduces unsupported external dependencies. Such hallucinations pose significant risks: they can lead to functional failures, silent defects, security vulnerabilities, and software supply-chain attacks. Code hallucinations are now recognized as a critical failure mode of LLM-based software engineering tools and have become a distinct focus for empirical evaluation, mitigation, and benchmarking across the landscape of LLM-powered program synthesis research (Lee et al., 29 Apr 2025, Tian et al., 2024, Gao et al., 2 Nov 2025, Agarwal et al., 2024).

1. Formal Definitions and Taxonomy

The code-generation research community has developed precise definitions of code hallucinations across several taxonomies, aligning with both their manifestation and underlying causes:

• General Definition: A code hallucination is any segment of LLM-generated code that appears syntactically correct or semantically plausible but either fails to meet the explicit requirements, uses fabricated or unsupported elements, or operates contrary to project, library, or environmental constraints (Lee et al., 29 Apr 2025, Gao et al., 2 Nov 2025, Tian et al., 2024).
• Taxonomy by Manifestation (Lee et al., 29 Apr 2025, Agarwal et al., 2024, Liu et al., 2024):
  • Syntactic Hallucinations: Break grammar or compilation (missing colons, incomplete code, invalid blocks).
  • Runtime Execution Hallucinations: Compile/run but crash at runtime (invalid API use, undeclared references).
  • Functional Correctness Hallucinations: Code runs but is functionally incorrect (logic/requirement deviation).
  • Code Quality Hallucinations: Non-critical errors (unreleased resources, security flaws, dead code).
  • Context and Knowledge Conflicting: Use of APIs, variables, or environmental features with no support in the execution context.
• Hallucination Subtypes (CodeHalu framework (Tian et al., 2024)):
  • Mapping Hallucinations: Data type, structure, or access mismatches (TypeErrors, IndexErrors).
  • Naming Hallucinations: Identity or external source reference errors (NameError, ImportError).
  • Resource Hallucinations: Memory/recursion issues, computational boundaries.
  • Logic Hallucinations: Semantic drift (logic deviation, infinite loops).
• Library/Package/API Hallucinations (Twist et al., 26 Sep 2025, Jain et al., 2024, Spracklen et al., 2024, Zhao et al., 28 Sep 2025):
  • Library Name Hallucination: Importing/invoking non-existent external modules.
  • Library Member Hallucination: Calling functions or members that do not exist in otherwise valid libraries.
  • Package Hallucination: Recommending or generating install instructions for phantom packages.
  • API Hallucinations: Fabricated or misconfigured invocations (incorrect names, arguments, or non-existent endpoints).

2. Measurement, Benchmarks, and Empirical Prevalence

Hallucination quantification relies on several canonical metrics and benchmarks:

• Metrics:
  • Hallucination Rate (HR): Fraction of generated samples exhibiting hallucinations: $HR = \frac{1}{N} \sum_{i=1}^N S(i)$, where $S(i)=1$ if sample $i$ is hallucinated (Tian et al., 2024).
  • Response Hallucination Rate (RHR) / Task Hallucination Rate (THR) (Twist et al., 26 Sep 2025):
  • $$\mathrm{RHR} = \frac{\#\text{responses w/ hallucinations}}{\text{total responses}} \times 100$$
  • $$\mathrm{THR} = \frac{\#\text{tasks w/ any hallucinated response}}{\text{total tasks}} \times 100$$
  • Package Hallucination Rate (PHR): Fraction of all recommended packages that are not in the official registry (Spracklen et al., 2024).
  • Version-Conflict Error Rate (VCER): Fraction of scripts failing due to mismatches between generated code and active library versions (Oli, 24 Feb 2026).
• Benchmarks:
  • CodeHaluEval (Tian et al., 2024): 8,883 samples over 699 Python programming tasks, covering 8 hallucination types via execution-based verification.
  • CodeMirage (Agarwal et al., 2024): 1,137 snippets, each annotated with one of five injected hallucination types, derived from HumanEval and MBPP.
  • HalluCode (Liu et al., 2024): 5,663 instruction–code pairs with 19 hallucination subtypes for recognition and repair experiments.
  • CloudAPIBench (Jain et al., 2024): ~600 Python tasks covering AWS/Azure APIs at varying public-domain frequency.
  • ManiBench (Oli, 24 Feb 2026): Manim code generation evaluating syntactic and visual-logic hallucinations.
  • Collu-Bench (Jiang et al., 2024): >13,000 instances from code and repair tasks, designed for evaluating hallucination localization and prediction.
• Empirical Findings:
  • Prevalence:
  • Overall hallucination rates in state-of-the-art LLMs range from 8–40% for library/API hallucinations (Miranda-Pena et al., 9 Apr 2026), 20–43% in practical repository-level generation (Zhang et al., 2024), and 33–60% across all error types in general Python codegen (Tian et al., 2024, Liu et al., 2024).
  • Package hallucinations occur at 5–22% for commercial/open-source models, with over 205,000 unique phantom package names surfaced in large-scale sampling (Spracklen et al., 2024).
  • Library name hallucinations reach 99% of tasks when completely fake names are inserted into prompts (Twist et al., 26 Sep 2025).
  • Hallucination rates increase sharply for low-frequency APIs, recent-topic prompts, and code requiring recent or obscure dependencies (Jain et al., 2024, Twist et al., 26 Sep 2025).

3. Error Mechanisms and Root Causes

Research in the field identifies multi-level mechanisms contributing to code hallucinations:

• Model-internal:
  • Probabilistic sampling and exposure bias (discrepancy between teacher-forcing during training and open-ended decoding at inference) (Gao et al., 2 Nov 2025).
  • Lack of hard grounding in dynamic project symbol tables, leading to "plausible invention" of APIs and members (Eghbali et al., 2024).
  • Drift due to high temperature and overgeneralization (semantic blending of domain patterns not supported by ground-truth context) (Spracklen et al., 2024, Zhang et al., 2024).
• Prompt and Input Characteristics:
  • Ambiguous or under-specified requirements leading to speculative completions (Gao et al., 2 Nov 2025, Zhang et al., 2024).
  • User typos, variations (misspellings, fake names), and temporal modifiers ("from 2025" or "modern") can trigger hallucination spikes of 80%+ (Twist et al., 26 Sep 2025).
• Training Data and Knowledge Limitations:
  • Stale training cutoffs and missing recent repository statistics mean models cannot verify package/library existence beyond their knowledge horizon (Spracklen et al., 2024, Twist et al., 26 Sep 2025).
  • Pollution by noisy, fictitious, or ill-maintained code in the pretraining corpus (Gao et al., 2 Nov 2025, Lee et al., 29 Apr 2025).
• Project/Repository Context:
  • Context window limitations cause LLMs to hallucinate project-specific functions or dependencies absent from the prompt (Eghbali et al., 2024, Zhang et al., 2024).
• Systemic Factors:
  • Lack of runtime version information and build context leads to hallucinated or incompatible APIs, especially in fast-evolving ecosystems (e.g., Manim GL→CE API drift (Oli, 24 Feb 2026)).

4. Detection, Localization, and Analysis Tools

A spectrum of methodologies and tools exists for detecting, localizing, and analyzing code hallucinations:

• Static Analysis (Miranda-Pena et al., 9 Apr 2026, Khati et al., 27 Jan 2026):
  • Off-the-shelf (Mypy, Pyright), GBNF grammar constraints, and custom AST analysis detect between 14% and 85% of library-related hallucinations, with theoretical upper bounds of 48–77% in amenable benchmarks.
  • Deterministic AST analysis, using introspected knowledge bases, reaches 100% precision and 87.6% recall in detecting knowledge conflicting hallucinations, with 77% auto-correction (Khati et al., 27 Jan 2026).
• Execution-based Verification (Tian et al., 2024, Jiang et al., 2024, Oli, 24 Feb 2026):
  • Automated code execution against unit or functional tests classifies logic, mapping, naming, and resource hallucinations.
  • Coverage in benchmarks such as CodeHaluEval, Collu-Bench, and ManiBench reveals large tails of hard-to-detect failures and the need for fine-grained metric reporting (Pass@k, Hallucination Rate, VCER).
• Localization/Explainability (Jia et al., 30 Dec 2025, Jiang et al., 2024):
  • Probing hidden layer vectors after fine-tuning enables line-level localization of hallucinated code, improving developer review and debugging efficiency.
  • Best current methods achieve 73.6% Top-5 line-level accuracy on annotated datasets (Jia et al., 30 Dec 2025).
• Fuzz and Adversarial Testing for Security (Zhao et al., 28 Sep 2025):
  • HFuzzer’s phrase-based approach systematically exposes model vulnerabilities by generating diverse, semantically-rich prompts, surfacing 2.6x more unique phantom packages than mutation baselines.
  • Package hallucinations remain exploitable for software supply-chain attacks even in advanced models like GPT-4o.

5. Mitigation Strategies and Effectiveness

Mitigating code hallucinations is an area of accelerated innovation, with approaches spanning training, inference, and post-processing:

• Retrieval-Augmented Generation (RAG) (Jain et al., 2024, Twist et al., 26 Sep 2025, Eghbali et al., 2024, Spracklen et al., 2024, Zhang et al., 2024):
  • Augmenting prompts with documentation, code snippets, or API indices reduces low-frequency API hallucination by up to 17pp and package hallucination rates by up to 49% (RAG, self-refinement, and fine-tuning ensembles).
  • Selectively triggering RAG for rare/unrecognized names (DAG++ strategy) preserves high-frequency API coverage (Jain et al., 2024).
• Post-generation Repair and Static Analysis (Khati et al., 27 Jan 2026, Miranda-Pena et al., 9 Apr 2026, Tian et al., 2024):
  • Deterministic static analysis corrects hallucinated APIs/parameters with high precision and recall, and LLM-in-the-loop repair increases execution rates by 4–8pp.
• Prompt Engineering (Twist et al., 26 Sep 2025, Oli, 24 Feb 2026):
  • Explicit-check and self-analysis interventions yield mean reductions up to 17.1% in library hallucination rate in high-risk settings.
  • Chain-of-thought and step-back prompts can unexpectedly amplify hallucinations unless rigorously validated.
  • For version-dependent domains (e.g. Manim), supplying explicit anti-legacy constraints eliminates version-conflict error rate.
• Consensus and Abstention via Semantic Triangulation (Dai et al., 15 Nov 2025):
  • Transforming the problem (e.g., generating and verifying mutual forward/inverse programs) decorrelates error patterns and increases reliable code selection by up to 21% compared to standard high-confidence voting.
• Fine-tuning (Spracklen et al., 2024, Tian et al., 2024):
  • Supervised fine-tuning on high-quality, hallucination-free datasets decreases package hallucinations by up to 83% in DeepSeek Coder, albeit sometimes at the expense of pass@1 accuracy.
• Hybrid and Multi-Stage Pipelines (Lee et al., 29 Apr 2025, Gao et al., 2 Nov 2025):
  • State-of-the-art recommendations now combine RAG, static/dynamic analysis, grammar-constrained decoding, and test-driven prompts, balancing cost, latency, and coverage.

6. Security, Supply-Chain, and Software-Engineering Implications

• Security Threats:
  • Library/package hallucinations facilitate typosquatting/slopsquatting attacks, enabling adversaries to inject malicious code into the software supply chain (Twist et al., 26 Sep 2025, Zhao et al., 28 Sep 2025, Spracklen et al., 2024).
  • Discrepancies in install instructions (phantom “pip install” commands) produce exploitable opportunities even when code correctness is superficially maintained.
  • Automated code agents/installers that trust LLM output are particularly vulnerable.
• Build, Integration, and Maintainability Hazards:
  • Hallucinated dependencies (imports, APIs) cause build failures, slow integration, and undermine trust in LLM-based code assistance (Twist et al., 26 Sep 2025).
  • Silent or late-detected logic and quality hallucinations can persist in production, incurring organizational cost and technical debt (Lee et al., 29 Apr 2025).
• Ecosystem-Specific Risks:
  • Rapidly changing APIs (Manim, cloud services) expose models to version drift and misaligned domain knowledge (Oli, 24 Feb 2026, Jain et al., 2024).
  • Projects with unique conventions/context are especially susceptible to context/knowledge conflicting hallucinations (Eghbali et al., 2024, Zhang et al., 2024).

7. Open Challenges and Future Directions

• Holistic and Evolving Benchmarking: Existing benchmarks are Python-centric; extension to broader language coverage, real-world, and multi-modal settings is required (Gao et al., 2 Nov 2025, Lee et al., 29 Apr 2025).
• Fine-Grained Explainability: Determining not just “if” but “where” and “why” hallucinations arise is a continuing challenge (Jia et al., 30 Dec 2025, Jiang et al., 2024).
• Online and Continual Learning: Automated registry validation, adaptive prompt selection, and model editing are necessary to keep up with evolving APIs (Lee et al., 29 Apr 2025, Jain et al., 2024).
• Security-Aware Decoding: Developing decoding algorithms that explicitly prioritize code security and dependency integrity (Spracklen et al., 2024, Zhao et al., 28 Sep 2025).
• Integrated Static–Dynamic Verification Loops: Combining type analysis, code execution, and retrieval, while minimizing user burden and response latency.
• Abstention and Uncertainty Quantification: Reliable code generation should include calibrated confidence reporting, refusal strategies on ambiguous prompts, and abstention mechanisms in consensus (Dai et al., 15 Nov 2025).
• Counterfactual and Attributional Analysis: Tracing hallucination triggers to specific training artifacts or model subcomponents for targeted improvement (Gao et al., 2 Nov 2025).

---

In summary, code hallucinations represent a complex, multi-faceted pathology arising from the interplay of pretraining distributional bias, prompt ambiguity, knowledge staleness, and context window limitations in LLMs for code generation. Their impact spans functional correctness, security, and maintainability, and their detection and mitigation require integrating advances from static analysis, retrieval-augmented generation, prompt engineering, and probabilistic consensus. Contemporary research demonstrates progress but also highlights persistent challenges, particularly for logic and requirement-aligned generation, security-sensitive contexts, and codebases requiring up-to-date, project-specific code knowledge (Lee et al., 29 Apr 2025, Twist et al., 26 Sep 2025, Dai et al., 15 Nov 2025, Khati et al., 27 Jan 2026, Zhao et al., 28 Sep 2025, Tian et al., 2024).