Self-admitted technical debt (SATD) — source-code comments in which developers explicitly acknowledge suboptimal solutions — was recently shown, at the method level, to be associated with lower code quality, higher change-proneness, and higher bug-proneness across 774,051 Java methods, but that study treated SATD as a single undifferentiated category. The open problem is whether the established SATD types (design, defect, documentation, requirement, and test debt) differ in these maintenance impacts: which types drive the observed aggregate associations, how resolution dynamics vary by type, and whether practitioners should therefore prioritize repayment by type. Type taxonomies and type classifiers, per-type removal and repayment-effort studies in adjacent settings, and sentiment-based prioritization studies are all established — but no study measures per-type associations with method-level code quality, change-proneness, or bug-proneness. The question remains open.

Background

Technical debt is a standard metaphor in software engineering for compromises in internal quality — suboptimal design, quick workarounds, incomplete tests — that deliver short-term benefit but are expected to raise future maintenance cost. Self-admitted technical debt (SATD) is the subset that developers explicitly acknowledge in artifacts such as source-code comments (for example, a comment admitting a temporary hack that should be replaced later). Because such comments can be collected automatically, SATD has become the main empirically tractable proxy for technical debt, motivating a large literature on detecting SATD comments and on when the debt is removed.

Whether SATD actually harms maintenance was surprisingly uncertain until recently. Potdar and Shihab (2014) found only weak, often statistically non-significant correlations between SATD and complexity metrics; Bavota and Russo (2016), studying 159 projects, found no correlation between SATD and coupling, complexity, or readability; and Wehaibi et al. (2016) found no clear trend linking SATD to defects. All of these studies operated at file or class granularity, which aggregates many methods (individual functions) with heterogeneous properties. Chowdhury, Kidwai, and Asaduzzaman (2025) re-examined the question at the method level. They tracked 774,051 methods from 49 open-source Java projects using CodeShovel, a tool that reconstructs a method's change history across renames, relocations, and refactorings, labeled methods as SATD-bearing with the text-mining SATD detector of Liu et al. (2018), and compared SATD against non-SATD methods using the Wilcoxon rank-sum test (a nonparametric test comparing two distributions) and Cliff's delta (a nonparametric effect-size measure). Methods containing SATD were larger, more complex, and less readable, underwent more revisions, and were more strongly associated with bug-fix commits; over 60% of SATD instances (about 61%) were never removed, and, among those that were resolved, 20% took more than 1,000 days — consistent with, and sharper than, earlier file-level removal studies such as Maldonado et al. (2017).

A separate line of work, initiated by Maldonado and Shihab (2015), classifies SATD comments into types — most prominently design debt (suboptimal structure), defect debt (acknowledged bugs), documentation debt (outdated or missing documentation), requirement debt (unfulfilled requirements), and test debt (inadequate tests) — and subsequent studies confirmed that these categories recur across languages, artifacts, and domains, with classifiers (including recent large-language-model approaches) able to assign types automatically. The 2025 method-level study, however, deliberately treated all SATD as one category. It therefore cannot say which types carry the observed associations with poorer quality, higher change-proneness, and higher bug-proneness, or whether some types are comparatively benign — a distinction that directly matters for how practitioners should ration limited repayment effort, since repaying documentation debt is a very different activity from repaying defect debt. A per-type method-level replication is directly enabled by existing type classifiers, method-history trackers such as CodeShovel, and the source study's publicly released per-method dataset.

Problem Statement

Determine whether the maintenance impact of self-admitted technical debt differs by SATD type, and whether repayment prioritization should therefore be type-specific. Concretely, replicate the method-level association analysis of Chowdhury et al. (2025) separately for the established SATD types — at minimum design, defect, documentation, requirement, and test debt — over real-world repository histories, and establish, for each type, whether SATD-bearing methods differ from non-SATD methods in (a) code quality metrics such as size, complexity, and readability, (b) change-proneness, (c) bug-proneness, and (d) how often and how quickly the SATD is resolved; then assess whether the per-type differences are material enough to justify differentiating repayment priorities across types. All requested results serve one objective: an empirical decomposition of the aggregate SATD effect into type-specific effects that either supports or refutes type-specific SATD management. The decomposition is per-type: estimates with effect sizes and uncertainty for each type, pairwise type comparisons, an explicit attribution of which types drive the aggregate associations found in the source study, and the prioritization implications that the effect sizes support; a well-supported conclusion that the types do not differ materially also answers the question.

References

  1. S. Chowdhury, H. Kidwai, M. Asaduzzaman, 'Evidence is All We Need: Do Self-Admitted Technical Debts Impact Method-Level Maintenance?', in 2025 IEEE/ACM 22nd International Conference on Mining Software Repositories (MSR), 2025, pp. 813–825, DOI: 10.1109/msr66628.2025.00118, https://doi.org/10.1109/msr66628.2025.00118 (preprint: arXiv:2411.13777, https://arxiv.org/abs/2411.13777)
  2. A. Potdar, E. Shihab, 'An exploratory study on self-admitted technical debt', in 2014 IEEE International Conference on Software Maintenance and Evolution (ICSME), 2014, pp. 91–100, DOI: 10.1109/icsme.2014.31, https://doi.org/10.1109/icsme.2014.31
  3. E. d. S. Maldonado, E. Shihab, 'Detecting and quantifying different types of self-admitted technical debt', in 2015 IEEE 7th International Workshop on Managing Technical Debt (MTD), 2015, pp. 9–15, DOI: 10.1109/mtd.2015.7332619, https://doi.org/10.1109/mtd.2015.7332619
  4. G. Bavota, B. Russo, 'A large-scale empirical study on self-admitted technical debt', in Proceedings of the 13th International Conference on Mining Software Repositories (MSR), 2016, pp. 315–326, DOI: 10.1145/2901739.2901742, https://doi.org/10.1145/2901739.2901742
  5. S. Wehaibi, E. Shihab, L. Guerrouj, 'Examining the impact of self-admitted technical debt on software quality', in 2016 IEEE 23rd International Conference on Software Analysis, Evolution, and Reengineering (SANER), vol. 1, 2016, pp. 179–188, DOI: 10.1109/saner.2016.72, https://doi.org/10.1109/saner.2016.72
  6. E. D. S. Maldonado, R. Abdalkareem, E. Shihab, A. Serebrenik, 'An empirical study on the removal of self-admitted technical debt', in 2017 IEEE International Conference on Software Maintenance and Evolution (ICSME), 2017, pp. 238–248, DOI: 10.1109/icsme.2017.8, https://doi.org/10.1109/icsme.2017.8
  7. Z. Liu, Q. Huang, X. Xia, E. Shihab, D. Lo, S. Li, 'SATD detector: a text-mining-based self-admitted technical debt detection tool', in Proceedings of the 40th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion), 2018, pp. 9–12, DOI: 10.1145/3183440.3183478, https://doi.org/10.1145/3183440.3183478
  8. F. Grund, S. Chowdhury, N. C. Bradley, B. Hall, R. Holmes, 'CodeShovel: Constructing method-level source code histories', in Proceedings of the 43rd International Conference on Software Engineering (ICSE), 2021, pp. 1510–1522, DOI: 10.1109/icse43902.2021.00135, https://doi.org/10.1109/icse43902.2021.00135
  9. J. Liu, Q. Huang, X. Xia, E. Shihab, D. Lo, S. Li, 'An exploratory study on the introduction and removal of different types of technical debt in deep learning frameworks', Empirical Software Engineering, vol. 26, 2021, DOI: 10.1007/s10664-020-09917-5, https://doi.org/10.1007/s10664-020-09917-5
  10. Zhaoqiang Guo, Shiran Liu, Jinping Liu, Yanhui Li, Lin Chen, Hongmin Lu, Yuming Zhou, 'How far have we progressed in identifying self-admitted technical debts? A comprehensive empirical study', ACM Transactions on Software Engineering and Methodology, vol. 30, no. 4, 2021, DOI: 10.1145/3447247, https://doi.org/10.1145/3447247
  11. Yikun Li, Mohamed Soliman, Paris Avgeriou, Jie Tan, Jiakun Liu, 'Text tells the cost: Predicting and analyzing repayment effort of self-admitted technical debt', arXiv:2309.06020, 2023, https://arxiv.org/abs/2309.06020
  12. N. Cassee, N. Ernst, N. Novielli, A. Serebrenik, 'Negativity in self-admitted technical debt: how sentiment influences prioritization', Empirical Software Engineering, vol. 30, 2025, DOI: 10.1007/s10664-024-10611-z, https://doi.org/10.1007/s10664-024-10611-z
  13. M. S. Sheikhaei, Y. Tian, S. Wang, B. Xu, 'An empirical study on the effectiveness of large language models for SATD identification and classification', Empirical Software Engineering, vol. 29, 2024, DOI: 10.1007/s10664-024-10548-3, https://doi.org/10.1007/s10664-024-10548-3
  14. M. S. Sheikhaei, Y. Tian, S. Wang, B. Xu, 'A large-scale empirical evaluation of LLMs for automated self-admitted technical debt repayment', ACM Transactions on Software Engineering and Methodology, 2026, DOI: 10.1145/3796704, https://doi.org/10.1145/3796704
  15. Sota Nakashima, Yuta Ishimoto, Masanari Kondo, Tao Xiao, Yasutaka Kamei, 'How far have LLMs come toward automated SATD taxonomy construction?', arXiv:2506.09601, 2025, https://arxiv.org/abs/2506.09601
  16. Phuoc Pham, Murali Sridharan, Matteo Esposito, Valentina Lenarduzzi, 'Descriptor: C++ self-admitted technical debt dataset (CppSATD)', arXiv:2505.01136, 2025, https://arxiv.org/abs/2505.01136
  17. Shahidul Islam, Ashik Aowal, Md Sharif Uddin, Shaiful Chowdhury, 'HistoryFinder: Advancing method-level source code history generation with accurate oracles and enhanced algorithm', arXiv:2507.14716, 2025, https://arxiv.org/abs/2507.14716
  18. Shahidul Islam, Md Nahidul Islam Opu, Shaowei Wang, Shaiful Chowdhury, 'A first look at the self-admitted technical debt in test code: taxonomy and detection', arXiv:2510.22409, 2025, https://arxiv.org/abs/2510.22409
  19. Ibuki Nakamura, Yutaro Kashiwa, Bin Lin, Hajimu Iida, 'Understanding self-admitted technical debt in test code: an empirical study', arXiv:2510.22249, 2025, https://arxiv.org/abs/2510.22249
  20. Ethan Friesen, Sasha Morton-Salmon, Md Nahidul Islam Opu, Shahidul Islam, Shaiful Chowdhury, 'The repeat offenders: characterizing and predicting extremely bug-prone source methods', arXiv:2511.22726, 2025, https://arxiv.org/abs/2511.22726