Skip to content
Architectra

Cited requirements for code that keeps changing

Requirements that keep up with your code.

Architectra drafts a cited requirements Specification from your repository, and your team decides what is approved. Each pull request is then compared with the approved code and test evidence, and the requirements it touches go to their reviewers.

The problem

Requirements get approved once. The code keeps moving.

Approved requirements and the code that implements them drift apart one pull request at a time. A PR can change cited code, or weaken a test, and merge without anyone who owns the requirement looking at it. Architectra ties each approved requirement to the code and tests it cites, so those changes surface on the pull request.

Requirement ↔ Code

A pull request edits the code a requirement cites.

Approved · REQ-014

Lock an account after 5 failed sign-ins.

PR #482 · auth/lockout.ts

- if (failures >= 5) lock(account)

+ if (failures >= 10) lock(account)

The PR's assessment lists REQ-014, and its reviewer records No impact, Change needed or Cannot determine.

Requirement ↔ Test

A test that covered the requirement gets weaker.

Cited test · lockout.test.ts

it("locks after 5 failed sign-ins")

PR #491 · lockout.test.ts

it.skip("locks after 5 failed sign-ins")

Cited test definitions are evidence too, so this change reaches the requirement's reviewer as well.

Approved ↔ Main

After merges, approved evidence points at code that moved.

Evidence pinned at a1f9c3e

auth/lockout.ts · lines 42–57

main, 30 merges later

Function split; lines 42–57 hold other code

Reconciliation re-anchors evidence after every push. What it cannot confirm is marked unresolved, never guessed.

Examples are illustrative. Architectra's checks are advisory and never block a merge; they show the requirement's reviewer what changed.

How it works

From a repository to reviewed requirements that stay current

Six steps, in the order they happen. AI drafts, people decide, and later changes are compared with what was approved.

Establish a reviewed baseline

  1. Input

    Step 1: Connect a repository

    Architectra pins the default branch at an exact commit and captures the files it will cite.

  2. AI draft

    Step 2: Generate a cited Specification

    AI drafts requirements that cite code, tests and docs at that commit. Drafts are proposals; nothing is approved automatically.

  3. People decide

    Step 3: Review and approve

    The system's owner or a designated reviewer approves each requirement. Review is independent by default, and exceptions are recorded.

Then, as pull requests open and merge

Keep it current as code changes

  1. Advisory check

    Step 4: Check each pull request

    Each PR a person opens is compared with the approved evidence. A GitHub check reports it without blocking the merge, and reviewers record an outcome per affected requirement.

    • No impact
    • Change needed
    • Cannot determine
  2. Automatic

    Step 5: Reconcile after merges

    Every push to the default branch re-anchors approved evidence. Moved code is followed; code that changed is marked unresolved for a person.

  3. Output

    Step 6: Export as CSV

    Download reviewed requirements and their cited evidence, with its current status, for your own tools and records.

Read how it works in detail

Who it's for

You have the code. Now keep the requirements with it.

Architectra is for teams that ship software but have no requirements baseline anyone keeps current. The workflow stays the same across teams: cited drafts, independent review, and advisory checks on each pull request.

Medical software

Medical-device software teams

Context: Often working within IEC 62304 processes

Turn the code you already ship into reviewed, cited requirements, then see which ones each pull request touches. Architectra supplies the evidence; your quality process decides what it means.

  • Implementation and test evidence cited to exact commits
  • Independent review by default; exceptions are recorded
3review outcomes per affected requirement
Robotics

Robotics and embedded teams

Context: Often working within IEC 61508 or ISO 26262 processes

Control code in C and C++ changes constantly. Evidence follows cited functions through formatting changes and moves, and becomes unresolved when the code itself changes.

  • Structural anchors for C/C++, Python and TypeScript/JavaScript
  • Unresolved evidence is shown, never silently re-matched
3language families anchored by syntax
Platform

Platform and API teams

Context: Shared services that other teams depend on

Write down the behavior other teams rely on and keep it reviewed. When a pull request touches cited code, the owning system's reviewer sees which approved requirements cite it.

  • System owners and designated reviewers decide
  • Decisions carry forward only while evidence is unchanged
1assessment per PR version, not one task per file

Standards are named only as the context these teams work in. Architectra does not certify software or establish compliance with any standard; your own process decides how its evidence is used.

Approve the requirements once. Review the changes that touch them.

Connect a repository, review the drafted Specification, and let each pull request show which approved requirements it touches. The checks stay advisory; your reviewers decide.