Paper deep dive

Comprendia: AI-Augmented Code Comprehension

Costain Nachuma, Minhaz F. Zibran

Year: 2026Venue: arXiv preprintArea: cs.SEType: PreprintEmbeddings: 30

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%

Last extracted: 8/13/2026, 5:05:10 AM

Summary

The paper introduces Comprendia, an Eclipse plugin for Java program comprehension that integrates structural dependency visualization with Large Language Model (LLM)-powered code explanation. The core innovation is Graph-Aware Callee Pruning (GACP), a deterministic algorithm that selects relevant code callees based on graph distance, inheritance collapse, and edge-type weighting, ensuring auditable and reproducible prompts across different LLM families. The tool also features clone-detection and CVE risk overlays on a unified graph substrate.

Entities (8)

Comprendia · software-tool · 98%Graph-Aware Callee Pruning · algorithm · 96%Java · programming-language · 95%Eclipse · software-platform · 92%LLM · technology · 90%OSV.dev · databaseapi · 88%CloMan · software-engine · 85%quickbite · software-project · 82%

Relation Signals (8)

Comprendia → implements → Graph-Aware Callee Pruning

confidence 95% · Comprendia introduces GACP, an algorithm that uses the same dependency graph as the relevance signal for prompt construction.

Comprendia → supportslanguage → Java

confidence 95% · shared interactive graph for Java program comprehension

Graph-Aware Callee Pruning → usesinput → Dependency Graph

confidence 94% · GACP uses graph distance, inheritance collapse, and edge-type weighting to produce prompts

Comprendia → runson → Eclipse

confidence 92% · Comprendia is an Eclipse plugin that integrates structural dependency visualization

Comprendia → uses → LLM

confidence 90% · integrates structural dependency visualization with LLM-powered code explanation

Comprendia → integrates → OSV.dev

confidence 88% · CVE risk overlay powered by OSV.dev

Comprendia → integrates → CloMan

confidence 85% · Comprendia integrates the CloMan clone-detection engine [32] with the dependency graph

Comprendia → evaluatedon → quickbite

confidence 82% · We illustrate GACP’s behaviour on six method-body selections from the quickbite open-source Java benchmark

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Comprendia is an Eclipse plugin that integrates structural dependency visualization with LLM-powered code explanation on a shared interactive graph for Java program comprehension. The tool rests on four pillars: (1) a multi-edge-type dependency graph with live search and multiple layouts; (2) LLM explanations grounded in Graph-Aware Callee Pruning (GACP), an auditable strategy that selects relevant callees using the same graph the developer navigates; (3) a clone-detection overlay that highlights duplication and suggests extract-to-parent refactoring opportunities; and (4) a CVE risk overlay powered by this http URL. GACP uses graph distance, inheritance collapse, and edge-type weighting to produce prompts that are reproducible across LLM families and traceable to visible graph nodes. We demonstrate Comprendia on a Java project containing known clones and vulnerabilities, showing how the unified graph substrate supports comprehension while keeping the developer in control. Screencast: this https URL

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

28,329 characters extracted from source content.

Expand or collapse full text

Comprendia: AI-Augmented Code Comprehension Costain Nachuma Minhaz F. Zibran Abstract Comprendia is an Eclipse plugin that integrates structural dependency visualization with LLM-powered code explanation on a shared interactive graph for Java program comprehension. The tool rests on four pillars: (1) a multi-edge-type dependency graph with live search and multiple layouts; (2) LLM explanations grounded in Graph-Aware Callee Pruning (GACP), an auditable strategy that selects relevant callees using the same graph the developer navigates; (3) a clone-detection overlay that highlights duplication and suggests extract-to-parent refactoring opportunities; and (4) a CVE risk overlay powered by OSV.dev. GACP uses graph distance, inheritance collapse, and edge-type weighting to produce prompts that are reproducible across LLM families and traceable to visible graph nodes. We demonstrate Comprendia on a Java project containing known clones and vulnerabilities, showing how the unified graph substrate supports comprehension while keeping the developer in control. Screencast: https://youtu.be/1wlh_RYehzA I Introduction Modern developers rely increasingly on large language models (LLMs) to write code [17, 14]. Likewise, they are using LLMs to explain unfamiliar code regions inside their integrated development environment (IDE). The dominant interaction paradigm, shared by Copilot Chat, Cursor, and Claude Code, treats the developer’s text selection as the LLM’s entire view of the project [8, 2]. This is empirically insufficient: even short methods routinely call into project-internal helpers whose behaviour is essential to a complete explanation, and a selection-only prompt forces the model to guess at those helpers from their names alone. Recent empirical work on AI-assisted programming finds that the gap between what the model is shown and what it needs to reason over is a frequent source of hallucinated identifiers and shallow, name-driven explanations [4, 19], in line with longstanding findings on the cognitive demands of code comprehension [26, 13, 25]. Tools that attempt to close this gap rely on embedding-similarity retrieval [27, 15, 28] or perplexity-based prompt compression [11, 30, 12, 23]. Both families share three limitations: their selection criteria are approximate (a similarity score, not a structural guarantee), not reproducible across LLM families, and not auditable by the developer. We argue that the IDE’s own dependency graph, which the developer can see, navigate, and trust, should be the relevance signal. This paper presents Comprendia, an Eclipse plugin for software comprehension that integrates dependency-graph visualization, LLM-assisted code explanation, and clone-refactoring discovery onto a single graph substrate. Comprendia makes three contributions, each grounded in the team’s prior published empirical work [4, 16, 19] and unified by a single design principle: the visualization the developer sees is the data structure the tool reasons over. Contribution 1: A multi-edge-type structural substrate Comprendia renders an Eclipse Java project’s dependency graph as an interactive visualization with five structural edge types (inheritance, interface, field-type, method-parameter, method-return). Edge-type filters, four layout algorithms, and in-graph search are exposed through a single toolbar. This extends Zibran’s management-oriented [31, 24, 33] clone-visualization line [32] from a single-edge overlay to a comprehensive structural graph, complementing code-city work [29] and industrial program-comprehension research [22]. Contribution 2: Graph-Aware Callee Pruning (GACP) Comprendia introduces GACP, an algorithm that uses the same dependency graph as the relevance signal for prompt construction. GACP (i) admits callees within k graph hops, (i) collapses near-duplicate siblings sharing an inheritance ancestor into a single delegate, and (i) allocates the remaining budget under an edge-type-weighted score. Every emitted callee carries an inclusion reason mapping one-to-one onto a visible graph node, making decisions auditable and reproducible. Section˜IV gives the full specification. Contribution 3: Clone-refactoring discovery as a graph overlay Comprendia integrates the CloMan clone-detection engine [32] with the dependency graph by painting clone-group members as red-highlighted nodes. Clicking a group focuses the graph on its members and reveals extract-to-parent refactoring opportunities [1]. Because the overlay shares the same substrate, clicking a cloned class yields both its graph context and a GACP-enriched explanation via the inheritance-collapse phase. All three contributions share a single substrate: the project dependency graph that GACP queries, the clone overlay paints onto, and the developer reads to verify the tool’s reasoning. Comprendia also exposes a CVE risk badge via OSV.dev [16, 10], but we exclude this from the contribution claim as its graph integration is forthcoming work. The plugin, benchmark, and replay harness are publicly available [18]. I Related Work I-A IDE-Native LLM Code Explanation Several tools embed LLM-powered code explanation directly in the developer editor. GitHub Copilot Chat [8] and Cursor [2] send the text selection for the developer to the model with no additional project context; the model must infer callee behaviour from names alone. Sourcegraph Cody [27] and RepoFuse [15] go further by retrieving project-internal code via embedding similarity, ranking candidate snippets by cosine distance to the selection. In all cases the inclusion decision is approximate (a similarity score above a threshold), not reproducible across embedding models, and not auditable by the developer: there is no visible structure the user can inspect to verify why a snippet was included. Patel et al. [20] offer a valuable conceptual framework, arguing that unreviewed AI-generated code causes long-term knowledge erosion; GACP’s auditable citations operationalize a concrete, tool-level countermeasure to exactly this risk. I-B Prompt Compression for Long Contexts A complementary line of work starts from too much context and compresses it. LLMLingua [11] and its long-context extension LongLLMLingua [12] use a small language model’s perplexity scores to drop low-information tokens, with question-aware compression for long contexts. RECOMP [30] trains extractive and abstractive compressors to select or rewrite retrieved passages before they enter the prompt. These techniques effectively reduce token costs, but their compression decisions are model-internal: different perplexity estimators or compressor checkpoints yield different prompts, and the developer cannot trace a retained token back to a project-level structure. GACP differs in kind: its only relevance signal is the dependency graph the developer already sees, making every inclusion decision traceable to a visible graph node and reproducible across LLM families. I-C Structural Visualization in IDEs Structural visualization tools help developers navigate large codebases. CodeCity renders software metrics as 3D cityscapes [29]; Lattix, Structure101, and Eclipse Zest (used by Project Usus [21]) render dependency matrices, layered diagrams, or general-purpose graphs within the Eclipse platform. Quante [22] evaluates dynamic object-process graphs for industrial program comprehension. Zibran [32] proposes clone analysis and visualization with respect to inheritance hierarchies and call graphs as necessary support for clone refactoring. Comprendia continues this line: it extends Zibran’s clone-visualization substrate from a standalone clone view to a multi-edge-type dependency graph that supports navigation, AI explanation, and refactoring discovery on the same surface. None of the tools above combine structural visualization with LLM-driven code explanation. I-D Position of Comprendia Table˜I summarises the gap. Comprendia is, to our knowledge, among the first IDE-native systems to use the project’s dependency graph as the relevance signal for prompt construction, making callee-inclusion decisions auditable and reproducible. TABLE I: Position of Comprendia among related approaches. AI-explanation Graph-grounded IDE-native Auditable Copilot Chat / Cursor ✓ – ✓ – Cody / RepoFuse ✓ – ✓ – LLMLingua / RECOMP – – – – CodeCity / Zest – ✓ ✓ ✓ Comprendia (GACP) ✓ ✓ ✓ ✓ I Tool Overview I-A User-Facing Workflow A developer opens an unfamiliar Eclipse Java project and right-clicks Visualize Dependencies. Comprendia parses the workspace incrementally via JDT and renders a dependency graph inside the IDE: nodes are classes, interfaces, and enums; edges encode five structural relationships (inheritance, interface, field-type, method-parameter, method-return). The developer toggles edge types, switches among four layout algorithms (spring, tree, radial, grid), and uses in-graph search to locate a class of interest. Double-clicking a node opens the corresponding source file. To understand a method, the developer highlights its body and clicks Explain with AI. Comprendia invokes GACP (Section˜IV) to select project-internal callees from the graph, assembles a prompt containing the selection and the chosen callee snippets, and routes the request to the configured LLM backend. The explanation appears in the InsightPanel with callee citations the developer can click to navigate to the referenced source. Because each cited callee maps one-to-one onto a visible graph node, the developer can verify the tool’s reasoning against the same structure used to produce it. Two overlays enrich the graph without leaving it. Running Detect Clones invokes the CloMan clone-detection engine [32] via a reflection bridge; clone-group members are highlighted in red, and clicking a group focuses the graph on its members, exposing candidate extract-to-parent refactoring opportunities. Independently, parsing the project’s pom.xml and querying the OSV.dev vulnerability database [9] paints CVE-severity borders on affected nodes (red for critical, orange for high), grounded in our prior finding that 62.89% of latest Maven releases carry transitive vulnerabilities [16]. Figure 1: Comprendia showing the dependency graph with OrderService selected. The InsightPanel (left) displays the GACP-grounded AI explanation with callee citations. The toolbar (top) exposes edge-type filters, layout selection, and search. The CVE risk banner (bottom) reports detected vulnerabilities. Figure 2: Clone overlay: CloMan detects two clone groups (6 occurrences). The four-class BaseRepository group (k=4k=4) is highlighted in red; non-clone nodes are grayed. The tooltip shows code metrics for the selected member. This is the group GACP’s Phase 2 collapses in Section˜V. I-B Architecture and Infrastructure Comprendia is organized in five layers. The UI layer hosts the graph view (Cytoscape.js [7] in an SWT Browser), the InsightPanel, and the toolbar. The analysis layer builds the graph via JDT AST parsing [5], runs GACP, and bridges CloMan for clone detection. The AI layer exposes a single AiGateway interface with three production backends (Anthropic Claude, OpenAI, Ollama) plus a deterministic mock for offline use; all receive the same GACP-assembled prompt, enabling the cross-LLM comparison in Section˜V. The data layer reads JDT models, queries OSV.dev [9] for CVE data, and accesses git history via JGit [6]. An opt-in telemetry service logs feature activations and task timestamps to a local JSONL file for controlled user studies [3]. I-C Practical Use Scenarios Comprendia targets three recurring needs. A developer onboarding onto an unfamiliar module clicks Explain with AI and receives an explanation whose callee citations resolve to the graph already on screen, rather than an opaque summary. A maintainer preparing a refactoring sprint runs Detect Clones to surface duplicate implementations and their common-ancestor candidates before writing code. A team triaging a dependency advisory uses the CVE overlay to see which classes touch a flagged package. For researchers, GACP’s parameterized, auditable selection offers a controllable variable for studying how context-selection strategy affects LLM-assisted comprehension. IV Graph-Aware Callee Pruning This section specifies GACP, a pure, static function that chooses project-internal callees for the LLM-explanation prompt. Given the enclosing class FQN, AST-extracted callees (filtered to project-internal symbols via JDT), a read-only GraphIndex over the dependency graph, and a token Budget, it returns a ranked list of GacpCallee records. Each record carries the callee’s FQN, graph distance, snippet mode (FULL_BODY or SIGNATURE_ONLY), rendered prompt fragment, and a structured inclusionReason (e.g., “distance-1 INHERITANCE; full body”) that maps one-to-one onto a visible graph node. The function contains no randomness, no LLM calls, and no UI dependencies. IV-A Phase 1: Reachability Filter Phase 1 admits a candidate callee if its declaring class lies within Kmax=2K_ =2 hops from the enclosing class on the dependency graph; self-calls (distance 0) are admitted directly. The cutoff is a hard structural admission rule, not a soft penalty. Two hops covers a selection’s direct callees and their immediate structural context while bounding prompt size; deeper callees add tokens faster than comprehension signal. Candidates are de-duplicated by declaring class so that Phases 2 and 3 operate at owner granularity. The snippet mode is distance-dependent: distance-≤1≤1 callees are rendered as FULL_BODY, distance-2 as SIGNATURE_ONLY. IV-B Phase 2: Topological Redundancy Elimination Any group of ≥2≥2 surviving candidates whose declaring classes share an immediate inheritance ancestor A is replaced with A itself (rendered as FULL_BODY) plus a single concrete delegate. The “immediate” qualifier guards against false collapses through java.lang.Object. This phase yields the largest savings on clone-touching selections. For example, when the developer requests an explanation inside one of four sibling repository classes sharing BaseRepository, Phase 2 collapses the four near-duplicate method bodies into the BaseRepository contract (rendered in full) plus one concrete delegate, producing an explanation that describes the shared contract rather than repeating sibling implementations (Section˜V). IV-C Phase 3: Edge-Type-Weighted Budget Allocation The final phase ranks survivors by edge-type weight divided by squared graph distance, favoring inheritance and interface edges (weight 1.01.0) over field-type (0.60.6) and method-parameter or method-return (0.40.4) relationships. Candidates are emitted greedily under the token budget, skipping degenerate snippets. Given fixed inputs, GACP returns the same output on every invocation: Phase 1 is O(|V|+|E|)O(|V|+|E|); Phases 2 and 3 are O(|C|log⁡|C|)O(|C| |C|) on the surviving set, which is single-digit in practice. Section˜V confirms identical prompts across three LLM families. V Demonstration We illustrate GACP’s behaviour on six method-body selections from the quickbite open-source Java benchmark (33 classes, 6 packages), replayed against three LLM families (Claude Sonnet 4.6, GPT-4o-mini, Llama 3 via Ollama). The harness compares four modes per fixture: Selection-only (no callee context), Legacy (dedup-and-cap at 5 callees), Gacp-sig (GACP with signature-only rendering), and Gacp-body (GACP with full bodies for distance-1 callees, the shipping default). All modes share the same JDT AST visitor and prompt scaffolding; they differ only in callee filtering and rendering. Table˜I lists the six fixtures: three exercise Phase 1’s reachability filter without engaging collapse; three engage Phase 2 with group sizes k=2,3,4k=2,3,4. TABLE I: Benchmark fixtures from quickbite. Selection Category Calls into placeOrder no-collapse 7 helpers across 4 pkgs recommendationEngine no-collapse 5 model + util helpers pricingEngineSurge no-collapse 4 engine/util helpers baseRepoCollapse collapse k=4k=4 4 sibling repositories reviewableCollapse collapse k=3k=3 3 Reviewables abstractUserCollapse collapse k=2k=2 2 user subclasses V-A Token Cost Table˜I reports prompt-token cost per fixture. Values are identical across all three LLM families, confirming that the algorithm’s output is gateway-independent. TABLE I: Prompt tokens by mode. Identical across all three LLM families. Selection Sel Leg Sig Body placeOrder 197 249 297 604 recommendEngine 158 199 214 386 pricingSurge 158 199 213 364 baseRepoCollapse 144 186 181 193 reviewCollapse 132 161 164 195 userCollapse 108 134 143 159 Mean (all 6) 150 188 202 317 Mean (no-collapse) 171 216 241 451 Mean (collapse) 128 160 163 182 Gacp-sig trades a modest token premium (+7.5% overall) for graph-grounded inclusion decisions. On collapse fixtures the cost is near-parity (+1.5%), because Phase 2 replaces k sibling bodies with one parent contract plus one delegate. On the k=4k=4 case, Gacp-sig actually saves 2.7% (186→ 181 tokens). On no-collapse fixtures, Gacp-sig admits more callees than Legacy’s cap: placeOrder emits 7 vs. 5, including two structurally proximate helpers that the cap drops (+19.3%). Where the cap is not binding (recommendationEngine, pricingEngineSurge), the two modes emit identical callee sets. Gacp-body roughly doubles the prompt on no-collapse fixtures (+109.3%) by including full method bodies. On collapse fixtures, Phase 2 limits the increase to +13.7%. Table˜IV shows the reshape on the three collapse fixtures. Phase 2 fires on all three and replaces k near-duplicate siblings with the common ancestor plus one concrete delegate; this is algorithm-only and LLM-independent. Prompt-token counts are identical across all three LLM families for every fixture×mode combination, confirming that GACP’s output is a pure function of the graph and the selection. TABLE IV: Phase 2 reshape: Legacy emits k siblings; GACP emits parent + delegate. Fixture Legacy emits Gacp emits baseRepo (k=4k=4) 4 sibling repositories BaseRepository + CustomerRepository reviewable (k=3k=3) MenuItem, Restaurant, Driver Reviewable + MenuItem abstractUser (k=2k=2) Customer, Driver AbstractUser + Customer VI Limitations and Future Work Single benchmark project The evaluation draws from one subject system, quickbite, chosen for its seeded clone groups at three sizes (k=2,3,4k=2,3,4). The algorithm is project-agnostic; running it on additional codebases is on our follow-on agenda. Coarse accuracy rubric The keyword-match accuracy score saturates to 2/2 across all modes and LLM families. Quality claims in Section˜V therefore rest on the algorithm-output comparison (callee-set composition and collapse behaviour), which is LLM-independent. A behaviour-test rubric would discriminate more finely but is follow-on work. Token estimator Prompt tokens are estimated as character-count/4. Absolute counts under provider-specific tokenizers differ by ± 10–15%, but relative comparisons, which are the basis of every claim, are preserved. No human-comprehension claim This paper measures the algorithm’s effect on the prompt, not whether developers comprehend code faster. A controlled user study on quickbite is designed but postdates this submission. Personalization and graph granularity GACP treats every developer as equivalent and operates on a class-level dependency graph. Method-level call graphs and expertise-adaptive pruning are future directions. Baseline and parameter scope Section˜V compares GACP against Selection-only and a fixed-cap Legacy baseline, not against an embedding-retrieval system (e.g., Cody, RepoFuse); a head-to-head comparison on the same six fixtures is future work. We likewise did not sweep GACP’s design parameters (KmaxK_ , edge-type weights); confirming that collapse behaviour is stable under alternative settings is a natural next step. VII Conclusion This paper presented Comprendia, an Eclipse plugin that integrates dependency-graph visualization, LLM-assisted code explanation, and clone-refactoring discovery onto a single graph substrate. The unifying design principle is that the visualization the developer sees is the data structure the tool reasons over: GACP queries the graph for callee distances, the clone overlay paints onto the graph, and the developer reads the graph to verify both. GACP’s callee-inclusion decisions are auditable against visible graph nodes and reproducible across LLM families, distinguishing Comprendia from embedding-retrieval and perplexity-based approaches whose relevance signals are model-internal. On the quickbite benchmark, GACP’s inheritance-collapse phase reshapes prompts on clone-touching selections from k sibling duplicates to a parent-contract-plus-delegate form, and the graph-distance cutoff admits structurally proximate helpers that a fixed cap drops. The plugin, benchmark fixtures, and replay harness are publicly available [18]. References [1] A. AlOmar, W. Mkaouer, and A. Ouni (2022) Toward the Automatic Classification of Self-Affirmed Refactoring. J. of Systems and Software. Cited by: §I. [2] Anysphere (2026) Cursor: The AI-First Code Editor. Note: https://cursor.comAccessed: May 2026 Cited by: §I, §I-A. [3] M. Basha, A. Ribeiro, J. Javahar, G. Rodriguez-Perez, and C. de Souza (2025) CodeWatcher: IDE Telemetry Data Extraction Tool for Understanding Coding Interactions with LLMs. In IEEE International Conference on Software Maintenance and Evolution, Tool Demo Track, Cited by: §I-B. [4] A. I. Champa, M. F. Rabbi, C. Nachuma, and M. F. Zibran (2024) ChatGPT in Action: Analyzing Its Use in Software Development. In Proceedings of the 21st International Conference on Mining Software Repositories (MSR), Lisbon, Portugal, p. 182–192. External Links: Document Cited by: §I, §I. [5] Eclipse Foundation (2026) Eclipse Java Development Tools (JDT). Note: https://w.eclipse.org/jdt/Accessed: May 2026 Cited by: §I-B. [6] Eclipse Foundation (2026) Eclipse JGit: Java Implementation of Git. Note: https://w.eclipse.org/jgit/Accessed: May 2026 Cited by: §I-B. [7] M. Franz, C. T. Lopes, G. Huck, Y. Dong, O. Sumer, and G. D. Bader (2016) Cytoscape.js: a graph theory library for visualisation and analysis. Bioinformatics 32 (2), p. 309–311. External Links: Document Cited by: §I-B. [8] GitHub (2026) GitHub Copilot Chat. Note: https://github.com/features/copilotAccessed: May 2026 Cited by: §I, §I-A. [9] Google Open Source Security Team (2026) OSV: Open Source Vulnerabilities Database. Note: https://osv.dev/Accessed: May 2026 Cited by: §I-A, §I-B. [10] C. Improta (2023) Poisoning Programs by Un-Repairing Code: Security Concerns of AI-Generated Code. In Proceedings of the International Symposium on Software Reliability Engineering Workshops, Cited by: §I. [11] H. Jiang, Q. Wu, C. Lin, Y. Yang, and L. Qiu (2023) LLMLingua: Compressing Prompts for Accelerated Inference of Large Language Models. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (EMNLP), p. 13358–13376. External Links: Document Cited by: §I, §I-B. [12] H. Jiang, Q. Wu, X. Luo, D. Li, C. Lin, Y. Yang, and L. Qiu (2024) LongLLMLingua: Accelerating and Enhancing LLMs in Long Context Scenarios via Prompt Compression. In 62nd Annual Meeting of the Association for Computational Linguistics, p. 1658–1677. External Links: Document Cited by: §I, §I-B. [13] T. LaToza and B. Myers (2010) Hard-to-answer questions about code. In Evaluation and usability of programming languages and tools, p. 1–6. Cited by: §I. [14] H. Li, H. Zhang, and A. E. Hassan (2025) The rise of ai teammates in software engineering (se) 3.0: how autonomous coding agents are reshaping software engineering. External Links: 2507.15003, Link Cited by: §I. [15] M. Liang, X. Xie, G. Zhang, X. Zheng, P. Di, W. Jiang, H. Chen, C. Wang, and G. Fan (2024) RepoFuse: Repository-Level Code Completion with Fused Dual Context. CoRR abs/2402.14323. Note: arXiv preprint. Cited by: §I, §I-A. [16] C. Nachuma, M. M. Hossan, A. K. Turzo, and M. F. Zibran (2025) Decoding Dependency Risks: A Quantitative Study of Vulnerabilities in the Maven Ecosystem. In Proceedings of the 22nd International Conference on Mining Software Repositories (MSR), p. 270–280. External Links: Document Cited by: §I, §I, §I-A. [17] C. Nachuma, M. F. Rabbi, A. I. Champa, and M. F. Zibran (2025) Analyzing chatgpt assistance in programming. In Software Engineering and Management: Theory and Applications: Volume 17, p. 203–215. Cited by: §I. [18] C. Nachuma and M. F. Zibran (2026) Comprendia: AI-Augmented Code Comprehension (ICSME 2026 Artifact). Zenodo. Note: https://doi.org/10.5281/zenodo.20436759 External Links: Document Cited by: §I, §VII. [19] C. Nachuma and M. Zibran (2026) When AI Teammates Meet Code Review: Collaboration Signals Shaping the Integration of Agent-Authored Pull Requests. In Proceedings of the 23rd International Conference on Mining Software Repositories (MSR), Brazil, p. 1–5. External Links: Document Cited by: §I, §I. [20] M. S. Patel, R. Dhawan, L. Bramhanwade, and D. J. Mishra (2026) Code Comprehension Gaps in AI-Assisted Development: A Conceptual Framework for Knowledge Erosion Patterns. IEEE Access 14 (), p. 66740–66757. External Links: Document Cited by: §I-A. [21] Project Usus Contributors (2017) Project Usus: Eclipse Plug-Ins for O Design Metrics and Dependency Visualization. Note: https://github.com/usus/usus-plugins/wikiAccessed: May 2026 Cited by: §I-C. [22] J. Quante (2008) Do Dynamic Object Process Graphs Support Program Understanding? A Controlled Experiment. In 16th IEEE International Conference on Program Comprehension, p. 73–82. External Links: Document Cited by: §I, §I-C. [23] R. Ravi, D. Bradshaw, S. Ruberto, G. Jahangirova, and V. Terragni (2025) LLMLOOP: Improving LLM-Generated Code and Tests through Automated Iterative Feedback Loops. In IEEE International Conference on Software Maintenance and Evolution, Tool Demo Track, Cited by: §I. [24] C. Roy, M. Zibran, and R. Koschke (2014) The vision of software clone management: past, present, and future. In proceedings of the IEEE CSMR-18/WCRE-21 Software Evolution Week (SEW’14), Vision Keynote, p. 18–33. Cited by: §I. [25] S. Scalabrino, M. Linares-Vásquez, R. Oliveto, and D. Poshyvanyk (2018) A Comprehensive Model for Code Readability. Journal of Software: Evolution and Process 30 (6), p. e1958. Cited by: §I. [26] J. Siegmund, C. Kästner, S. Apel, C. Parnin, A. Bethmann, T. Leich, G. Saake, and A. Brechmann (2014) Understanding understanding source code with functional magnetic resonance imaging. In 36th international conference on software engineering, p. 378–389. Cited by: §I. [27] Sourcegraph (2026) Cody: AI Coding Assistant That Knows Your Codebase. Note: https://sourcegraph.com/codyAccessed: May 2026 Cited by: §I, §I-A. [28] R. Tufano, S. Masiero, A. Mastropaolo, L. Pascarella, D. Poshyvanyk, and G. Bavota (2022) Using Pre-Trained Models to Boost Code Review Automation. In Proceedings of the 44th International Conference on Software Engineering (ICSE), p. 2291–2302. External Links: Document Cited by: §I. [29] R. Wettel and M. Lanza (2008) CodeCity: 3D Visualization of Large-Scale Software. In Companion Proceedings of the 30th International Conference on Software Engineering (ICSE Companion), p. 921–922. External Links: Document Cited by: §I, §I-C. [30] F. Xu, W. Shi, and E. Choi (2024) RECOMP: Improving Retrieval-Augmented LMs with Context Compression and Selective Augmentation. In 12th International Conference on Learning Representations, Cited by: §I, §I-B. [31] M. F. Zibran and C. K. Roy (2012) IDE-based real-time focused search for near-miss clones. In Proceedings of the 27th ACM Symposium On Applied Computing (SAC), p. 1235–1242. Cited by: §I. [32] M. F. Zibran (2015) Analysis and Visualization for Clone Refactoring. In Proceedings of the 9th IEEE International Workshop on Software Clones (IWSC), Montréal, Canada, p. 47–53. Cited by: §I, §I, §I-C, §I-A. [33] M. F. Zibran (2016) Towards implementation of an integrated clone management infrastructure. In Proceedings of the 10th IEEE International Workshop on Software Clones (IWSC), p. 60–61. Cited by: §I.

Instant research discovery