ReqToCode: Embedding Requirements Traceability as a Structural Property of the Codebase

TL;DR

ReqToCode embeds requirements directly into the codebase as traceable elements, ensuring compile-time verification of traceability and reducing the risk of degradation over the software lifecycle.

Contribution

The paper introduces Traceables, a novel language-native code element that maintains requirements traceability within the code, validated during build time, unlike prior retrospective approaches.

Findings

Traceables enable automatic validation of requirement links during build.

The approach reduces trace degradation and improves safety-critical software reliability.

Lifecycle management provides actionable signals for requirement updates.

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.