Evidence standards for AI-generated code

By Elliot Gardiner, Founder, Code Telemetry

An enterprise can approve the use of AI coding assistants, train its developers, and establish a pull-request review policy, yet struggle to answer a release question: what evidence supports the decision to ship this particular change? The diff describes proposed software, and conventional CI records what happened when a predefined pipeline ran. Neither necessarily tells a reviewer what tools the agent consulted, what failures it investigated, or what it knew about the system while producing the change. For a business adopting agentic development, that missing account of the work is a governance problem, not simply another dashboard to buy.

Reliability when nobody can read everything
When I moved into site reliability engineering, the size of the systems and the number of contributors had already outgrown my ability to inspect each change personally. I could no longer read all of the code (or even all the new code). The shift was necessary: reliability had to come from observable systems and practices designed for people to make mistakes, not from expecting every individual engineer to be vigilant all the time. The process of writing code is as important as the outcome. AI coding agents increase the importance of that distinction because their intermediate decisions may be invisible by the time a human receives the PR.

Executives do not need raw transcripts of every tool invocation, and code owners cannot realistically read them at scale. They need a concise answer to what the agent was expected to investigate, what it actually did, and what remains unverified. That answer should be specific to the change, grounded in observable events, and narrow enough not to imply certainty that the evidence cannot support.

Start with the consequence of a wrong change
A text correction and a change to payment authorization logic do not deserve identical approval requirements. For an illustrative payment-service change, a team might require evidence that the agent inspected idempotency constraints, consulted the relevant API contract, ran integration tests against realistic dependencies, and checked failure behavior. A build succeeding does not show that duplicate charges have been ruled out; a unit test succeeding does not show that the appropriate unit test was written. Before deciding what tools to require, the engineering and product owners should agree on the business behavior that must survive the change.

This suggests a layered evidence policy rather than one universal score. At the organizational level, teams may expect an agent to consult the assigned issue and shared context system. At the repository level, they may expect it to follow AGENTS.md guidance, project skills, and the documented test or environment workflow. At the task level, a frontend change may require browser checks, whereas a database migration calls for schema inspection and migration-specific verification. The policy should distinguish what a tool is capable of providing, whether it was available, whether the agent invoked it, and what outcome was actually observed.

Verification evidence is not a substitute for CI
The point of grading isn’t to replace deterministic testing in CI/CD. I want grading to confirm that the agent used the context and tools necessary to understand the change, including but not limited to tests. CI remains an independent check of a particular source revision against known requirements. Agent-session evidence answers a separate question: what investigative and verification work preceded that revision? A team may choose to shift selected checks earlier in a trunk-based development workflow, but that is a deliberate risk decision, not a blanket argument for replacing controlled CI.

The distinction is measurable in a public HotROD demonstration. Two AI coding-agent PRs—#5 and #9—contain the same change to the “locations” endpoint, adding Cache-Control: no-store. Both received a passing ordinary build-and-unit-test CI result. Only one had qualifying recorded validation before the push: the agent completed build, unit, lint, browser, and integration checks, including tests using a Signadot sandbox with the changed services. At a demonstration threshold of 70, the validation gate scored the documented run 70 and the unvalidated run 0. The patches were identical, so this result demonstrates differences in verification evidence, not differences in the software’s correctness.

The validated run is revealing for a second reason. Initially, testing commands piped their output into tail, leaving the true test exit status ambiguous; the evaluator awarded no credit for that evidence. The checks were rerun without the pipe, and the subsequent validation passed. That is a practical example of why merely detecting a testing command is not the same as establishing that the test completed successfully. For enterprise approval, the evidence must be attributable to the relevant execution and the right version of the code.

A release record should name its uncertainties
A useful validation record distinguishes at least four states: a required check passed, it failed, it was skipped, or there is insufficient evidence to determine an outcome. An unobserved check should not quietly become green. Similarly, a successful test against an earlier source version may be accurate history while no longer supporting the candidate under review. Later edits, configuration changes, and environment differences can all make evidence inapplicable. Teams should state which observations are authoritative for their release process and how those observations are tied to the candidate.

Sometimes a release must proceed without the expected evidence. Imagine an urgent remediation while an integration environment is unavailable. The governance question then is not whether a score can be adjusted to green, but who has the authority to accept the gap. An exception should record what is missing, why the organization is proceeding, the person accountable, and when the exception expires. Where risk warrants it, the record should also name exposure limits, additional production monitoring, and a rollback trigger. A temporary exception that cannot be revisited can become a permanent reduction in scrutiny.

Govern the evidence system itself
Development telemetry can carry source snippets, command output, environment details, and sometimes secrets. A company should decide what to collect, who can see it, what to retain, and which collection failures it will treat as unknown. It should also distinguish agent-authored summaries from independently observed execution: those sources have different trust properties. An evidence service can support a release decision, but it should not be presented as proof of compliance or a replacement for the organization’s secure-development controls. NIST’s Secure Software Development Framework offers a vocabulary for those wider practices; it does not turn a validation score into a security guarantee.

Measure whether the new control helps
I would start an enterprise rollout with one service and a few consequential change types, not a blanket policy applied to every repository. Measure how often release reviewers encounter missing or stale evidence, how frequently they must request additional investigation, and how long it takes to resolve a justified exception. Compare that operational cost with ordinary delivery and production-quality measures. If the new system produces more gates but no clearer decisions, it has not improved reliability. The goal is to move important investigative and validation work earlier. A PR shouldn’t be the first place anyone discovers that the agent lacked the context to do the job.

Repository owners face a genuine trade-off between growing review load, slower delivery, and accepting more uncertainty. No single metric will remove that tension. But a release record that connects expected work to observed evidence can make the uncertainty explicit, assign responsibility, and give reviewers a better basis for saying “yes” or “not yet”.

About the author
Elliot Gardiner is the founder of Code Telemetry, an observability platform for AI coding workflows. He brings ~15 years of software engineering experience, including principal engineering roles at Mastercard, JPMC and Kustomer. He now applies production observability practices to AI-assisted development, investigating how coding agents use tools, recover from failures, and validate changes. His focus is making the work between a prompt and a pull request observable, so teams can improve their development environments, catch missing validation earlier, and evaluate whether changes to their AI coding workflows actually help.

AISoftware Coding
Comments (0)
Add Comment