Systems and records
Software requirement change chronology: which version should a coding agent follow?
By SourceX Editorial · Updated
9 sections
Short answer
After a mid-project change, a coding agent should follow the latest requirement version that someone with authority accepted and that applies to the branch or release it is working on. Build a software requirement change chronology from issues, comments, reviews, decision records and commits, record who could change what, and stop to ask when those facts do not single out one version.
Agent run
Software requirement change
Key takeaways
- The governing requirement is the latest authorized version for the scope in question, not simply the newest text.
- Requirement changes hide in issue edits, comments, reviews, decision records and commits, each with its own timestamp.
- Authority should come from a written project rule; code owner settings are supporting evidence.
- Tasks built from history need superseded-behavior tests so outdated implementations fail.
- When authority or scope is unclear, asking the right role is the correct outcome.
Which requirement version should a coding agent follow after a mid-project change?
The agent should follow the latest version that was changed by someone with authority to change it and that applies to the branch, release or ticket the agent is working on. That is often, but not always, the newest text. A comment from a contributor who cannot decide scope, an edit made on a branch that was never merged, or a change that takes effect in the next release does not replace the version in force for the current task.
So the agent needs three facts before it writes code: the full chronology of requirement versions, the authority behind each change, and the scope in which each version applies. When those three facts do not single out one version, the right behavior is to stop and ask, not to pick the most recent wording.
This guide shows where requirement versions hide in a typical GitHub-style workflow, how to establish authority and effective scope, a change chronology and authority task specification for building evaluation tasks from real project history, an illustrative mid-project change, and the cases where the agent should not decide alone.
Why the newest wording can be the wrong instruction
Requirements in software projects rarely live in one document. They are spread across an issue description, its comments, a design note, review comments on a pull request and sometimes a chat thread that someone summarized. Each of these can carry a change, and each has a different relationship to authority.
Four patterns cause most mistakes. A participant proposes a change in a comment and nobody with decision rights accepts it. The issue description is edited after work starts, and the agent sees only the final text without knowing what changed or when. A change is agreed for a later release while the current branch must ship the earlier behavior. Or a decision record is replaced by a newer one, but the older one is still the first search result. An agent that always follows the newest text will be wrong in all four, and a dataset that stores only the final requirement will never teach it otherwise.
Even the link between work and requirement can depend on the branch. GitHub interprets closing keywords such as fixes or resolves in a pull request description only when the pull request targets the repository's default branch; on any other branch no link is created and merging does not close the issue. A task built from history should therefore read the links that exist, not assume that every merged change answered the issue it mentioned.
Where do requirement versions and their timestamps live?
Build the chronology from every place a requirement can change, and record which timestamp you used for each event. Git itself keeps two times on each commit: the commit object holds the author name, email and date, and separately the committer name, email and commit time. A rebased or cherry-picked commit can therefore carry an author date long before the change reached the branch, which matters when you ask what the code looked like at the moment a requirement changed.
| Source | How a version appears | Timestamp to use | Common trap |
|---|---|---|---|
| Issue description | Edited text of the original request | Each edit time from the edit history | GitHub keeps description edit history unless the author or a person with write access removes it |
| Issue and pull request comments | A proposal, clarification or decision in a thread | Comment creation time | A proposal is mistaken for a decision |
| Pull request reviews | Requested changes that alter expected behavior | Review submission time | A stale approval is read as approval of later code |
| Decision records | A design decision with a status such as accepted or superseded | The record's own decision date | The superseded record is still found and followed |
| Commits | Code and tests that encode the behavior | Committer time for when it reached the branch; author time for when it was written | Using the author date after a rebase |
| Release notes or changelog | The version in which a change takes effect | Release date and tag | A change planned for a later release is applied now |
Who had authority to change the requirement?
Authority should come from a written rule the project already uses, not from the job title of whoever commented last. Record the rule alongside each change, so a reviewer can check the agent's choice without guessing.
Repositories often encode part of that rule. GitHub's code owners feature requests reviews from the owners of the files a pull request touches, uses the CODEOWNERS file from the pull request's base branch, and gives the last matching pattern precedence; with required reviews enabled, an administrator can also require a code owner's approval before merging. That tells you who must approve the code, which is a strong signal for who may change behavior in that area, though not proof of product authority.
Decision records make authority explicit. The MADR template, one of several published formats for architectural decision records, includes a status that can read superseded by a later record, a date when the decision was last updated, and the decision-makers involved. When a project uses such records, the authority test is simple: the governing version is the accepted record that has not been superseded.
Approvals can also go stale. GitHub's protected branch settings can dismiss an approving review when new commits change the diff, because the approval covered the diff as it stood when it was given. If a requirement changed after approval and the code changed with it, an approval from before the change is not evidence that the new behavior was accepted.
The change chronology and authority task specification
Use this specification to turn one real mid-project change into a task that tests whether an agent follows the right version. Each field is required unless marked optional, and each has a check a second reviewer can apply.
At a glance
The change chronology and authority task specification
| Field | Content | Check |
|---|---|---|
| task_id and repository snapshot | A stable task identifier and the commit the agent starts from | The snapshot builds and its existing tests run |
| requirement_versions | Every version of the requirement in order, with source, time, author role and full text | No gap between versions; each version quotes its source |
| authority_rule | The project rule that says who may change this requirement | Rule exists in project records, not inferred after the fact |
| authority_per_change | For each change, whether the author met the rule and who accepted it | Every accepted change names an accepting role |
| effective_scope | Branch, release or ticket each version applies to | The agent's task scope maps to exactly one version |
| governing_version | The version the agent should follow, with a one-sentence reason | Two reviewers agree independently |
| tests_for_governing | Tests that fail before the change and pass with a correct implementation | They fail on the start snapshot and pass on the reference change |
| tests_for_superseded | Tests that pass only if the agent follows an outdated version | A correct solution fails them |
| review_and_outcome | Review rationale, merge, release and any later fix or revert | Linked by reference to merge and release records |
| ambiguity_flag (optional) | Marks tasks where the correct behavior is to ask | Graded on whether the agent asked, not on code |
What lets someone outside the team rerun a requirement-change task?
A task is only usable if someone else can rebuild the starting state and rerun the checks without the original team. Public benchmarks show a workable shape. SWE-bench instances carry the repository, the base commit, the problem statement, a creation date, the reference patch, a test patch and two lists of tests: those that should go from failing to passing and those that should keep passing.
A requirement-change task needs the same parts plus the chronology. Add the superseded-behavior tests as a third list, so a solution that implements the old version is caught even if it passes everything else. Pin dependencies in the snapshot, record the runtime version, and store the reference change separately from anything the agent can see.
Where production evidence exists, attach it by reference: the release that shipped the change, any incident or support ticket that showed the behavior in use, and any later revert. A change that was reverted a week later because the requirement was misread is one of the most informative tasks you can build, as long as the chronology shows why.
Worked example: a rate limit that changed scope mid-sprint (illustrative)
Illustrative case, not a real project. An issue asks for an API rate limit of a fixed number of requests per minute per user. Two days into the sprint, a backend engineer comments that the limit should be per organization instead. The next day the product owner, who under the team's written rule decides API behavior, edits the issue description: per organization for paid plans, per user for free plans, effective in the next minor release. A pull request opened before the edit already implements per-user limits and was approved.
The chronology has three versions. Version two, the engineer's comment, has no authority under the rule and is recorded as a proposal. Version three is authoritative and governs the next minor release. The pull request targets the main branch that will become that release, so version three governs the task, and the earlier approval is stale because the behavior it approved changed.
The task specification records 3 requirement versions, 1 authority rule, 4 tests for the governing version, covering paid and free plans, and 2 superseded-behavior tests that pass only with a pure per-user limit. A correct agent implements the split, notes that the earlier approval needs renewing, and does not implement the engineer's per-organization-for-everyone proposal.
The exception: the same repository has a maintenance branch for the current release, where version one still applies until the minor release ships. The same agent assigned a bug on that branch should keep per-user limits. One requirement history, two correct answers, decided by scope.
When should the agent stop and ask instead of choosing?
Asking is a correct outcome, and tasks should reward it when the record does not settle the question. Grade these cases on whether the agent identified the conflict and asked the right role, not on the code it might have written.
- Two changes conflict and both authors appear to meet the authority rule.
- The latest change has no recorded acceptance and the rule requires one.
- The effective scope is missing, so the version for the current branch cannot be determined.
- The description was edited and its edit history was removed, so earlier versions cannot be confirmed.
- The requirement touches security, privacy or contractual commitments to customers, where a wrong guess has consequences beyond the codebase.
- Tests in the repository encode one version and the latest accepted requirement says another, with no note explaining which is current.
Can engineering history become licensed task data?
Projects that kept issues, reviews, decision records and release history together hold exactly the evidence this specification needs, and some companies license such histories to developers building and evaluating coding agents. Rights matter first: code may include third-party or open-source components under their own licenses, and customer-specific requirements may be confidential.
Engineering histories like these can reach AI developers through SourceX, which carries out the rights review, contracting, preparation and delivery. The assessment that opens the process needs no uploaded files, and the company's approval of scope and terms, with its signature, precedes any delivery.
Frequently asked questions
Should a coding agent always follow the most recent requirement?
No. It should follow the most recent version that someone with authority accepted and that applies to the branch or release in scope. A newer comment without acceptance, or a change planned for a later release, does not replace the version in force.
How do you know who has authority to change a requirement?
Use the project's own written rule, such as a product owner for behavior or the accepted decision record for architecture. Repository settings like code owners show who must approve code in an area, which is useful evidence but not the whole rule.
What is a superseded-behavior test?
It is a test that passes only if the code implements an outdated version of the requirement. Including it in a task catches agents that follow the old text while still passing the other tests.
Which git timestamp should a requirement chronology use?
Git stores an author date and a separate committer date on each commit. Use the committer time to place a change on the branch timeline and keep the author time for when the work was written, especially after rebases.
Can an approval from before a requirement change still count?
Usually not for the changed behavior. GitHub's protected branches can dismiss approvals as stale when new commits change the diff, which reflects the same idea: an approval covers what the reviewer saw.
Sources
- GitHub says issue description edit history is available unless the author or a person with write access removes it. Source
- GitHub interprets closing keywords in a pull request description only when the pull request targets the default branch; otherwise no link is created. Source
- GitHub protected branches can dismiss approving reviews as stale when new commits change the diff the reviewer approved. Source
- GitHub requests reviews from code owners using the CODEOWNERS file on the base branch, the last matching pattern takes precedence, and code owner approval can be required before merging. Source
- Git documentation says a commit records the author name, email and date and, separately, the committer name, email and commit time. Source
- The MADR decision record template includes a status that can read superseded by a later record, a last-updated date and the decision-makers. Source
- SWE-bench task instances include the repository, base commit, problem statement, creation date, reference patch, test patch and fail-to-pass and pass-to-pass test lists. Source
See if your company qualifies
A short company assessment. No data uploads are needed.