What is the most precious commodity in software development? Time.

That’s why AI is being introduced into so many development workflows. However, what if those workflows aren’t fully prepared for it yet?

Picture this. You have several AI agents developing features in parallel, potentially faster than human developers could. They finish their work and push their changes to the repository. To make things even faster, code reviews may also be assisted by AI. Multiple pull requests are opened and validated concurrently, with their changes eventually converging in shared integration and release pipelines.

The bottleneck has simply moved.

We can scale up our runners. But where does it end? We buy ourselves some time, add more agents and before long, we need to scale again — and again.

There are other ways to improve CI/CD performance, including parallel execution, caching and selective task execution. But while these optimizations help us execute work more efficiently, they don’t necessarily address every problem.

Traditional task-centric pipelines organize validation around individual executions. A pipeline starts, runs its tasks, produces results and finishes. Some results may be cached or stored, but success alone doesn’t guarantee they’ll remain applicable when conditions change.

What if we retained and re-evaluated previous validation results, rerunning only the checks whose findings no longer apply, without scattering governance rules across multiple pipeline stages?

After all, a successful validation yesterday doesn’t necessarily mean we’re allowed to proceed today.

A Practical Scenario

Although AI may amplify the pressure, this problem isn’t exclusive to AI-driven development. Consider a familiar scenario.

Imagine you’ve spent an entire sprint developing a new feature. At the end, all your tests pass. Naturally, you prepare a release candidate and start the release procedure. But there’s one little catch.

The entire feature relies on a third-party library, which, for the purpose of this article, we’ll call ThatAwesomeLibrary. Your release candidate uses version 2.4.

Shortly after you prepare the release candidate, a security advisory reveals a vulnerability in that version.

What now? Everything was green yesterday, and suddenly, out of nowhere, green doesn’t necessarily mean ready to release.

You might miss that advisory and deploy anyway, potentially exposing your application to a security breach. Ideally, your release process should recognize such an event and prevent deployment until the issue has been addressed.

But let’s say you noticed the advisory. Fortunately, the maintainers of ThatAwesomeLibrary have already released version 2.5, which addresses the vulnerability.

Unfortunately, there’s another catch. Version 2.5 also introduces changes to the library’s public API. As a result, you need to modify parts of your code to accommodate the update.

Now, some validations clearly need to run again. But does changing part of the codebase automatically mean that every previous validation result is no longer useful?

Architecture

The scenario exposes an important distinction: Successful CI/CD pipeline execution and permission to release are not necessarily the same thing.

When a validation task finishes, its result tells us something about a particular state of our application at a particular point in time. It might confirm that our code compiled successfully, that our tests passed or that no known vulnerabilities were detected.

We can retain the existing task-centric pipeline and add a separate governance layer. Tasks still build, test and validate the application; governance evaluates their results beyond the execution that produced them.

Rather than treating a successful execution as just another green checkmark, we retain structured validation reports together with information about the inputs they were produced from, their provenance and their validity.

Whenever a candidate is reassessed, whether following a new submission, a relevant external event or an expiry deadline, the governance layer can examine previously retained reports before determining which known validation tasks, if any, need to run again.

But simply finding an existing report isn’t enough. We need to verify that it still applies to the current inputs, that it hasn’t expired and that no relevant event or policy change has made it insufficient.

Even if every required validator passed, a later veto, expiration or candidate change can make a previous admission decision stale.

For that reason, admission should be checked against the current state at the moment it is enforced, rather than relying indefinitely on an earlier successful decision.

Figure 1: Conceptual Architecture of a Governed Task-Centric Pipeline

Retaining and Reusing Validation Results

A green checkmark is useful, but on its own, it doesn’t tell us much about the circumstances behind it. Which version of the code was tested? Which dependencies were used? When did the validation take place? What exactly did it verify?

Of course, caching already solves part of this problem. Modern CI/CD systems can avoid repeating computations when their relevant inputs haven’t changed. There is no reason to rebuild an identical artifact if a verified cached result is available.

A cached build artifact tells us that a particular computation has already been performed. A retained validation report tells us what was observed during that execution, allowing the system to evaluate whether those findings are still applicable.

Each retained report should preserve the findings produced by the validator, information about the inputs and artifacts being examined and the provenance of the original execution. The system must also be able to verify the integrity of the stored report.

When a candidate is evaluated again, the governance layer can examine these reports and determine whether they still correspond to the current inputs and satisfy the applicable policy.

If they do, the system may reuse them without repeating the corresponding validation tasks. If they don’t, the existing task-centric execution mechanism can perform the required checks again.

Now consider upgrading ThatAwesomeLibrary to version 2.5. This time, the application’s dependency inputs change. Any validation whose correctness depends on those inputs must be reassessed. Other reports may remain useful, provided their input bindings and validity conditions still hold.

The objective isn’t to skip as many tasks as possible. It’s to avoid unnecessary execution without sacrificing the reliability of the final decision.

After all, reusing a result should be a decision we can justify, not an assumption we make because it was successful yesterday.

Handling Changes Beyond the Source Code

One of the easiest assumptions to make about CI/CD is that validation needs to happen when something changes in the repository. While source code changes are an obvious reason to run our checks again, they aren’t the only reason.

That is what happens when the vulnerability in ThatAwesomeLibrary 2.4 becomes public: The code and dependency bytes haven’t changed, but the available security information has.

A governance layer can handle this situation through external events. In our example, an integration would need to deliver the security advisory as a relevant event, which the system could then evaluate against its configured rules.

Imagine a security scan started just before the advisory was received but finished afterward. Should we consider that result a fresh validation performed in response to the incident?

To enforce such a requirement, the system must distinguish when a validation actually started from when it completed. If the policy requires execution after a specific event, a scan that started before that event cannot satisfy the requirement merely because it finished later.

Consider validation results that are only acceptable for a limited period. A security assessment might be considered sufficiently recent today but too old tomorrow, even if the application hasn’t changed.

By retaining the original observation time and tracking expiration deadlines, the governance layer can recognize when previously accepted results are no longer sufficient and initiate reassessment without waiting for another source code change.

Suppose an organization introduces stricter acceptance criteria. If an existing validation report already contains all the necessary findings, the system may be able to evaluate those findings against the new policy without running the validator again.

If the required information is missing, additional validation may be necessary. If the existing findings demonstrate a violation of the new policy, the correct outcome may simply be to deny admission.

The important distinction is that changes in source code, external events, elapsed time and policy can all affect whether a previous validation remains sufficient. They don’t necessarily require the same response.

Human Decisions and Protected Admission

So far, we’ve focused mostly on results produced by automated validation tasks. But software releases aren’t governed by machines alone.

Imagine we’ve successfully upgraded ThatAwesomeLibrary to version 2.5. Our application builds, the relevant tests pass and the security scan no longer reports the original vulnerability.

But shortly before the release, a security reviewer identifies another potential risk and issues a veto. Does that mean our previous validations have suddenly failed?

This is why human decisions should be treated as part of the governance state rather than simply another task in the pipeline.

An approval should be associated with the specific materials that were reviewed. If our release candidate changes afterward, we cannot automatically assume that the previous approval still applies. Similarly, a successful validation shouldn’t silently override an existing veto.

Assume the candidate has already received a positive governance decision.

Before it is enforced, however, a veto is committed or a required report expires. The earlier decision can no longer be accepted without checking current state.

This is why an admission proposal must be separate from final enforcement.

At consumption, the system rechecks the candidate, applicable reports, policies and human decisions instead of trusting an earlier allowance indefinitely.

The final operation must also account for concurrent changes. If a veto is committed before admission, it must prevent the operation. If admission has already been committed, a later veto cannot retroactively undo it.

That requires durable state, authorization and transactional consistency. The added complexity prevents an old decision from being accepted after its supporting conditions have changed.

A green pipeline tells us what happened during execution. A protected admission decision determines whether we are still permitted to proceed.

A Possible Integration: GitHub Actions and a GitHub App

How might we apply this to an existing CI/CD environment? GitHub Actions provides a useful example, although the integration described here is a proposed design rather than a deployed B1 feature.

The first thing we need is a place where our validation results can live independently of individual workflow executions. This doesn’t necessarily mean building a new CI engine. Our existing workflows can continue building, testing and scanning the application.

Connecting the Pipeline

We can use a GitHub App as the integration point between our existing workflows and an external governance service.

The App can observe workflow activity and use GitHub’s API to retrieve validation artifacts. However, those artifacts must contain structured information that our governance service can interpret. A workflow’s success status alone isn’t sufficient.

For each validation, we need to identify the candidate being examined, the relevant inputs, the validator that produced the results and the findings themselves.

Persisting Validation Reports

The governance service needs persistent storage for validation reports and their associated metadata.

A relational database can maintain report identities, candidate bindings, execution information, policy versions and governance state. A separate artifact store can preserve the original report contents, allowing their integrity to be verified before reuse.

The important part isn’t the particular database technology. It’s establishing a reliable relationship between a validation result and the conditions under which it was produced.

Responding to External Events

Our application still uses version 2.4 when GitHub Dependabot reports a newly discovered vulnerability.

A GitHub App with the appropriate permissions can receive Dependabot alert events. The governance service must then determine whether the reported vulnerability affects the dependencies of the release candidate being evaluated.

A relevant event can make the old security report insufficient and, under configured rules, require a validation that starts after that event.

The system shouldn’t automatically discard unrelated test results. Instead, it should evaluate the affected validation tasks and retain any reports whose relevant conditions still hold.

When the application is updated to ThatAwesomeLibrary version 2.5, the existing dependency and task mappings determine which build and test operations need to run again.

Protecting the Release

Collecting reports and detecting changes would be useful, but it wouldn’t prevent an unsafe release on its own.

GitHub offers custom deployment protection rules implemented through GitHub Apps. When a workflow reaches a protected environment, GitHub requests an approval decision from the App.

The governance service can use this opportunity to evaluate the current candidate against its retained reports, policies, security events and applicable human decisions.

It should approve only when all required conditions are satisfied; missing, expired or invalidated validation must prevent approval.

The integration also needs to handle failed webhooks, unavailable services, repeated deliveries and changes that occur while a decision is being processed.

A positive evaluation cannot become permanent permission. The design must explicitly address currentness at decision time and the remaining timing boundaries between GitHub and its external backend.

This approach keeps GitHub Actions responsible for executing validation tasks while moving long-lived result evaluation and release governance into a dedicated service.

Evaluating the Architecture

An architecture diagram can make a solution look convincing. But how do we know that the system actually behaves as expected when things start changing?

To answer that question, we evaluated the approach using a controlled qualification workload designed to exercise both normal validation and more challenging governance scenarios.

The tests covered the complete life cycle of a release candidate, including initial execution, reuse of previously retained reports, source and dependency changes, policy updates, external events, evidence expiration, human decisions and infrastructure recovery.

Rather than relying solely on successful task execution, we also verified whether the resulting decisions were correct. This included checking report bindings, validation findings, policy outcomes and whether an earlier admission decision remained applicable when conditions changed.

Two complete qualification passes were performed using frozen inputs and isolated execution state. Each pass exercised the same defined scenarios, allowing us to check whether the behavior was repeatable.

The qualification confirmed that five selected governance scenarios — warm reuse, positive and adverse policy reevaluation, veto and veto withdrawal — completed without executing additional physical validators in either pass.

The governance layer still needed to retrieve and evaluate retained information, process the relevant controls and produce a valid decision or admission receipt.

The tests also exercised adverse conditions. Previously acceptable decisions had to be rejected when relevant policy, expiration, veto or integrity conditions changed before final enforcement.

The qualification used a bounded, controlled workload rather than a production-scale deployment environment. Two successful passes establish observed behavior under those conditions, not statistical proof of reliability or universal performance improvements.

It was to verify something more fundamental: That previously produced validation results could be reused when appropriate, while changes that made them insufficient continued to produce the correct governance response.

Figure 2: Observed Decision/Receipt Times for Five Zero-Validator Governance Scenarios, Shown Separately for two Frozen Passes 

Synthetic human waiting time is excluded, and negative cases end when a denial decision becomes available.

Conclusion

We began with the pressure that faster development places on software delivery. Scaling runners and optimizing execution help, but speed isn’t the whole problem.

Our example with ThatAwesomeLibrary demonstrated that a successful validation doesn’t necessarily remain sufficient forever. Dependencies change, vulnerabilities are discovered, policies evolve and human decisions can affect whether a release candidate should be permitted to proceed.

Retained, input-bound reports and a separate governance layer let existing task-centric pipelines reassess those results against current conditions.

This adds storage, coordination and enforcement complexity, and it doesn’t guarantee faster execution. The design is useful where that cost is justified by the need for trustworthy decisions.

After all, the goal isn’t simply to run fewer tasks. It’s to make better use of the results we’ve already produced, without mistaking yesterday’s success for today’s permission to proceed.

Frequently Asked Questions

1. Why are traditional CI/CD pipelines struggling with AI-generated code?
AI agents can produce changes faster than conventional pipelines can validate them. Scaling runners helps, but task-centric pipelines may repeatedly execute checks without fully considering whether previous results remain valid and reusable.
2. How can DevOps teams avoid rerunning unnecessary tests without compromising security?
By retaining structured validation reports tied to specific inputs, artifacts and execution history. A separate governance layer can determine which results remain trustworthy and which checks must run again when code, dependencies, security advisories or policies change.
3. Can a successful CI/CD pipeline still produce an unsafe release?
Yes. Passing tests doesn't guarantee a release remains authorized. A newly disclosed vulnerability, expired security assessment or human veto can make an earlier approval obsolete. Protected admission controls must evaluate the latest evidence and policies before deployment.