acceptodds
Under review as a conference paper at ICLR 2027

Visible Features, Hidden Flaws: Vulnerability Persistence in LLM-Generated Software

Abstract

Large language models LLMs increasingly drive automated multi-file software synthesis, yet frequently generate insecure backend implementations. Conventional code security evaluations treat generated artifacts as independent, post hoc evaluation samples, overlooking whether model generated failures share structured, reusable representations across generation tasks. In this work, we formalize and investigate vulnerability persistence: the hypothesis that generative coding models exhibit stable architectural biases that tightly couple user facing workflows with specific latent backend security flaws. We introduce the Feature-Security Table (), a model-specific empirical prior mapping standardized, observable user-interface interactions directly to ranked distributions of latent vulnerabilities without requiring access to victim source code, prompting history, or internal model weights. Evaluating six state-of-the-art code LLMs across multi-file applications in WebGenBench reveals strong vulnerability recurrence: recovers true latent vulnerabilities with up to 85.67% average attack success rate (ASR) and 84.97% average coverage (ACR) on held out application domains excluded entirely during construction, outperforming matched-budget baselines by up to 6.9. Notably, our recurrence framework demonstrates an unexpected universality gap cross domain vulnerability transfer consistently exceeds within domain recurrence by approximately 18 points proving that these security failures originate from model level coding habits rather than local prompt memorization or task specific artifacts. These findings establish that LLM-generated software exposes a predictable, observable attack surface, demonstrating that security evaluations must account for systematic, model level implementation biases rather than benchmarking generated programs independently. Our code is available at .

Primary area:
learning on time series and dynamical systems
Keywords:
code generation, large language models, software security, vulnerability persistence, AI safety, empirical priors, automated software synthesis, model habits

Reviews

Among:
Shape:
1234this paper, Bottom 2%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.33 over 3 reviews, above 2% of the others.
Reviewer_sPE6OpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

The paper finds that LLMs generate related code security vulnerabilities across applications for the same given implementation feature classes. For instance, for different applications that are all equipped with a login feature, this specific login feature is likely to exhibit the same security vulnerability across the independently generated applications. The evaluation relies on static analyzers, and shows that on two independent splits of applications, the LLMs generate a largely overlapping set of vulnerabilities as found by the SAST tools.

Critical strengths

The observation that LLMs have a "typical set" of vulnerabilities that they generate across similar settings is interesting and could be transformer into valuable contributions, or be used to demonstrate speed-ups/efficiency gains in cyberattacks against LLM-generated applications.

Critical weaknesses
  • The paper is extremely hard to understand, and its writing strongly resembles typical weak patterns of inlegible AI writing. Frequent non-linear argumentation, contrastive sentences such as X and not Y, and other typical patterns hint LLM writing. But even beyond this, the paper is very difficult to follow, to the extent to which I am unable to verify any of it claims, as it is unclear what is being even presented.
  • Other presentation flaws not aiding understanding are the unclear placement of figures in the middle of the text, the abrupt ending of the paper, the convolutedly and unexplainedly defined metrics and measures in Section 3, and the convoluted and unclear explanation of the experimental setting (it sounds like only 5 samples are used from each benchmark for testing?).
  • The paper's initial idea of trying to categorize LLM-generated vulnerabilities in a predictive framework is neat, but the actual execution and especially the evaluation completely underdelivers. It would have been more interesting if it could be demonstrated how an actual adversary with the goal of exploiting the applications can use this lookup table to speed up their attacks. Additionally, for any such lookup table, to validate their construction, it would need to be demonstrated that it is not just better than no table, but also, it is better than a generic vulnerability to exploit map (as even independently of LLMs, for frontend/backend features we can already expect a quite small set of typical vulnerabilities that are well-documented in vulnerability databases such as the MITRE CWE classification).

Overall, this paper is clearly below the bar.

Questions for authors

No questions.

Reviewer_y7MPOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper introduces a black-box attack exploiting coding LLM vulnerabilities via feature-security lookup table (FSTabs) to break the security of generated code. FSTabs are constructed by mapping front-end features (e.g., login interface) to know security vulnerabilities that the adversary exploits at runtime to attack a target application developed with LLM agents. The proposed approach has been evaluated on six code LLMs across benchmarks like WebGenBench, achieving an ASR of > 80%.

Critical strengths
  • The paper explores an important security problem in code LLMs, used for vibe-coding or by developers who interfere less with LLM generated code to audit their security.
  • The front-end to backend vulnerabilities matching and mapping is a smart idea for quick vulnerability retrieval and testing.
  • Broad evaluation on multiple code LLM models and benchmarks (WebGenBench and E2EDev)
Critical weaknesses
  • The paper’s idea about using a lookup table (FSTabs) is promising but its scalability is unclear. How does the lookup table scale to unknown and complex content features or unclear back-end security vulnerabilities. The authors should clarify the limits of the methods or propose a fair transferability analysis on how the framework would perform under totally unknown features or provide more details on the overlap between WebGenBench and E2EDev.
  • The selected frontend features seem trivial and rigid (in Table 1). I wonder how the construction strategy would go deeper into identifying even more complex frontend features that can be attack entries but are too implicit to be easily identifiable.
  • Baselines are not clearly defined in the experimental setup and the comparison results are not even shown as a table or a figure in the main paper. There’s only a paragraph that claims a baseline comparison but it seems very disconnected from the rest of the evaluation sections (with no supported evidence). Baselines comparison is very important, and should be clear in the main paper (not even buried in the appendix). Also the authors should pick strong baselines for comparison, including recent LLM-driven methods for vulnerability detection and exploitation.
  • The cross-domain results should be supported by data on the overlap between the two benchmarks. If the overlap is strong, then transferability results are not valid. Also, Transferability claims should be supported by results on more than one dataset (E2EDev), adding more benchmarks would strengthen the approach’s transferability.
  • Finally, the novelty of the proposed method should be clear in the paper. In the current format, the proposed framework seems an Ad-hoc rigid method and what distinguishes it from recent methods still remains unclear. So authors should make efforts in clearly listing their scientific (not only technical) contributions and set strong baselines to showcase the novelty.
Questions for authors
  • How does the lookup table scale to unknown and complex content features or unclear back-end security vulnerabilities?
  • How the construction strategy would go deeper into identifying vulnerabilities in non-trivial and more complex frontend features?
  • Please identify strong baselines and provide a comprehensive comparison against them.
  • Could you conduct a transferability analysis on more benchmarks and clearly explain if there is any overlap?
  • Could you clarify the scientific novelty of the proposed approach?
Reviewer_LBWAOpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper investigates whether vulnerabilities in LLM-generated software can be predicted from visible frontend features without accessing the backend code. It introduces FSTab, a lookup table that links frontend features to recurring security vulnerabilities. Experiments across six LLMs show promising results, suggesting that LLMs exhibit consistent vulnerability patterns across different applications.

Critical strengths

1- The idea that LLMs repeatedly generate similar security vulnerabilities across different applications is important, and interesting research problem 2- The method could help security analysts prioritize vulnerabilities when source code is unavailable.

Critical weaknesses

1- The novelty is limited, FSTab mainly uses feature–vulnerability co-occurrence statistics and a lookup table. The contribution is more empirical than algorithmic. 2- I think the paper need a strong baseline like global vulnerability-frequency ranking and feature-conditioned frequency ranking.

Questions for authors

How well does FSTab perform on real-world applications outside WebGenBench and E2EDev?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.