🤖 AI Summary
This work addresses the fragility of traditional requirements traceability in safety-critical software development, where reliance on external documentation often leads to silent breakdowns as code, requirements, and tests evolve independently. To overcome this, the paper proposes internalizing traceability as an intrinsic property of code structure by introducing language-native “Traceable” elements that enable compile-time verification of bidirectional links among requirements, implementations, and tests. The approach integrates code generation, metadata embedding, and build-time validation into the development workflow, providing proactive traceability assurance. When requirement changes disrupt traceability chains, the system automatically triggers warnings or build failures, thereby preventing traceability decay and significantly enhancing maintainability and reliability throughout software evolution.
📝 Abstract
Requirements traceability in safety-critical software development remains largely dependent on external documentation maintained separately from the systems it describes. This separation introduces structural fragility: traces degrade silently as requirements, code, and tests evolve independently across tools, repositories, and revisions. Recent advances in LLM-based traceability focus on recovering broken links after the fact - an inherently retrospective approach. This paper introduces ReqToCode, an approach that prevents trace degradation by embedding traceable system elements directly into the codebase, making traceability a compile-time verifiable property of the system rather than an external documentation task. Central to the approach is the concept of the Traceable - a language-native, generated code element that represents a single requirement and carries its metadata. Developers reference Traceables in implementation and test code, creating hard, bidirectional links that are validated automatically during the build process. When requirements change, the system responds through a graduated lifecycle - from deprecation warnings to build failures - providing teams with actionable signals rather than abrupt breakage. We describe the approach, its architectural principles, the Traceable lifecycle, and illustrate it with a generic example spanning requirement definition, artifact generation, code integration, and build-time validation.