From Apollo to AI agents: A short history of requirements traceability

From Apollo to AI agents: A short history of requirements traceability

“Let customers cancel a scheduled export” is enough to start a conversation with a coding agent. But can a viewer cancel someone else’s export? What happens if a worker has already picked up the job? An agent can make different interpretations look plausible in a pull request. The team still has to decide which behavior it wants and how to verify it.

That is where requirements traceability earns its keep. The practice predates agile software development, enterprise modeling suites, and AI coding agents by decades. What has changed is how easily teams can keep those links close to the work and make them available to both humans and agents.

Before the matrix was a spreadsheet

In the 1960s, MIT and NASA worked together on the Guidance and Navigation System Operations Plan, which served as the software requirements document for each Apollo mission. NASA established a Software Configuration Control Board in 1967 to manage changes. Mission-specific requirements and controlled changes were already practical engineering concerns when software teams were still learning how to organize the work. NASA’s history of Apollo guidance software.

In 1988, the U.S. Department of Defense made traceability explicit in DOD-STD-2167A. Section 4.2.6 required contractors to document links between requirements and design. Section 4.3.4 required the software test description to identify which requirements each test case satisfied in full or in part. A test can exercise one part of a requirement while leaving another part unexamined. DOD-STD-2167A text.

In 1994, Orlena Gotel and Anthony Finkelstein drew attention to the part of the trail that a design-to-test matrix can miss. They distinguished pre-specification traceability, which covers a requirement’s life before it enters the specification, from post-specification traceability, which covers what happens afterward, including design, implementation, and verification. Knowing that a test exists tells you where to look when behavior changes. Knowing why the requirement exists tells you whom to consult and what trade-off to revisit. An Analysis of the Requirements Traceability Problem.

What a traceability matrix shows

A requirements traceability matrix (RTM) shows the links between requirements and other artifacts. Here is a compact version for the export example.

RequirementOriginImplementationVerification
Only the export owner or a workspace admin can cancel a queued export.Workspace access policyCancellation handler and authorization policyTests for the owner, admin, and a viewer who does not own the export
Once the worker starts an export, cancellation returns a conflict.Export lifecycle decisionCancellation handler and job state transitionRace between cancellation and worker start still needs a test

Read the matrix forward to find what a requirement affects. Read it backward from a test or a piece of code to find the behavior it is intended to support. The cancellation handler appears in both rows because the relationships are many-to-many. If you change that handler, both requirements deserve a look. If a test is linked, review its assertions and check its latest run before drawing a conclusion about the behavior. NASA Software Engineering Handbook on bidirectional traceability.

From Rational Suite to the Scrum backlog

The early 2000s offered a commercial answer to the problem of keeping those links together. Rational Suite bundled tools for different roles in the delivery process. Rational Rose was the visual modeling tool, Rational RequisitePro managed requirements, and the Rational Unified Process provided process guidance. Other Suite components covered activities such as change management. Meanwhile, Telelogic DOORS organized requirements in structured modules and used links to connect requirements across modules. IBM later moved support materials for legacy Telelogic DOORS releases to its own site. Rational Suite 2002 product overview, Telelogic DOORS 9.1 manual, IBM’s notice on legacy DOORS support.

Scrum emerged in the 1990s. Ken Schwaber and Jeff Sutherland first presented it together at OOPSLA in 1995, and the 2001 Agile Manifesto’s principles welcomed changing requirements even late in development. In Scrum, the Product Owner is accountable for managing the Product Backlog, including ordering its items. Refinement makes items smaller and more precise. During a Sprint, the Developers and Product Owner can renegotiate scope as they learn, while protecting the Sprint Goal. At the Sprint Review, the Scrum Team and stakeholders inspect the outcome and discuss what to adapt next. Agile Manifesto principles, The Scrum Guide.

A backlog item describes work the team wants to do. A requirement can describe behavior the product must preserve long after that item closes. The next Sprint might introduce scheduled retries and reopen the question of when an export can be canceled. A durable link from the current requirement to its rationale and tests lets the team revisit that decision without reconstructing it from old tickets.

When English becomes the interface to implementation

With a coding agent, a developer can spend more of an afternoon writing and revising requirements in English than writing implementation code by hand. A useful instruction says who can cancel, which job states allow it, and what an API caller sees if the worker wins the race. Those details give the agent a bounded task and give a reviewer something concrete to check.

Agents can draft the wording, surface ambiguities, and propose tests. Humans still decide what the product should promise, which exceptions are acceptable, and what evidence is sufficient to ship. That judgment matters especially when an agent writes both the implementation and the test. Both can agree on an interpretation the team never approved.

Plain language also makes those decisions reviewable by people who work outside the implementation language. A product owner can approve the policy in English. An engineer can inspect the worker transition. An agent can follow the same requirement ID to both. Versioning the agreed requirement makes a change to the product promise visible in a review, alongside changes to code and tests.

What teams can use today

  • Requirements and lifecycle platforms. IBM DOORS Next supports requirements change and traceability. Siemens Polarion ALM links requirements to test cases and test records. Jama Connect brings requirements, reviews, and verification into a shared workflow. IBM DOORS Next, Siemens Polarion ALM, Jama Connect.
  • Work tracking and delivery platforms. Azure DevOps links work items to tests, commits, pull requests, builds, and releases. Jira can surface development and deployment information on work items through integrations. These links help a team follow a change from backlog to delivery. Azure DevOps traceability, Jira development and deployment integration.
  • Spec workflows for coding agents. GitHub Spec Kit provides a workflow from specification through planning and implementation. Kiro’s feature specs connect requirements, design, and tasks. OpenSpec organizes proposed changes and their spec updates in the repository. GitHub Spec Kit, Kiro Specs, OpenSpec.

spec11

Keeping track of how a product evolves is one of my challenges. When AI changes hundreds of lines of code in a single pull request, the requirements can get buried in the diff. That’s why I built spec11. It helps me navigate a repository and gives my coding agent a way to follow the links between requirements, code, and tests.

spec11 reads requirements from Markdown and looks for their IDs in test names and source comments. It lists the references it finds, flags requirements with no test references, and shows which requirements a Git diff touches. You can browse the results in a web dashboard or use the command line. A coding agent can query the same results through the Model Context Protocol (MCP).

spec11 is written in Rust and works offline. One local release build for Apple silicon produced a 7.6 MB executable. In a separate benchmark on one Mac, a release build without the web UI generated a full report for a synthetic repository with 8,000 requirements in a median of 113 ms over 10 runs. The benchmark ran without a CodeGraph index. Benchmark details.

If your repository has a local CodeGraph index, spec11 reads it to find static links between files, such as a call from a test to a function defined elsewhere. CodeGraph.

Try it on your repository, share your feedback, and pass it along if it helps. spec11 on GitHub, feedback.

Konstantin Pavlov

Konstantin Pavlov

Software Engineer working with Java, Kotlin, Swift, and AI. Focusing on software architecture and building AI-infused apps. Passionate about testing and Open-Source projects.