CoatiPress

Tag: flaky tests

  • When AI Writes the Tests: How to Keep Agentic Development Fast Without Letting Flaky Checks Slow You Down

    When AI Writes the Tests: How to Keep Agentic Development Fast Without Letting Flaky Checks Slow You Down

    The New Bottleneck: Trusting the Tests

    Picture a small product team preparing a release. An AI coding agent has implemented a feature, updated a few files, and helpfully generated new tests. The pull request looks impressive: coverage is higher, the suite passes, and the change appears ready before lunch. Then the same tests fail on the next run with no code changes. Or worse, they keep passing while a real bug slips into production.

    That is the tension of agentic development. AI tools can speed up more than application code. They now write tests, update mocks, propose CI configuration, add fixtures, revise release scripts, and summarize changes for reviewers. The question is no longer whether AI can help create tests. It is whether those tests are trustworthy enough to protect the product.

    Flaky Tests and Quality Gates, in Plain Language

    A flaky test is a test that sometimes passes and sometimes fails without a meaningful change in the software being tested. Flakiness can come from timing assumptions, random data, shared state, external network calls, file-system differences, time zones, race conditions, or tests that depend on being run in a particular order.

    A quality gate is a rule in the delivery pipeline that decides whether a change is allowed to move forward. Common quality gates include passing unit tests, minimum coverage thresholds, static analysis checks, security scans, required code review, and deployment approvals. In healthy CI/CD, quality gates are not bureaucracy. They are the automated and human checkpoints that help fast teams avoid preventable problems.

    When AI agents generate tests, the quality gate itself needs scrutiny. A test suite that passes is useful only if it checks the right behavior in a repeatable way.

    Why AI Agents Are Touching More Than Application Code

    Modern coding agents are increasingly used as end-to-end development assistants. A developer may ask an agent to fix a bug, and the agent may respond by editing source code, adding a regression test, updating snapshots, modifying CI commands, and summarizing the change. That is useful because real software work is rarely limited to one file.

    Industry research points toward broader adoption of coding agents across development workflows. Anthropic’s 2026 Agentic Coding Trends Report describes software development as shifting toward orchestrating agents that write code and highlights ongoing tradeoffs around productivity, oversight, quality, and security. Gartner also reported in May 2026 that the enterprise AI coding agent market was entering a phase of expansion and competitive realignment.

    The benefit is obvious: AI can produce first-draft tests faster than most teams can write them by hand. The risk is quieter: agents are often optimized to satisfy the visible request. If the prompt says, “add tests and make CI pass,” an agent may write tests that are technically valid but weak, over-mocked, too tightly coupled to implementation details, or blind to the behavior users actually depend on.

    A Good Test Is More Than a Test That Exists

    A good test protects an important behavior. It should fail when that behavior breaks and pass when the behavior works. That sounds simple, but it is exactly where many AI-generated tests need human review.

    A weak test might verify that a function was called instead of verifying the result users care about. A brittle test might assert the exact wording of an internal error message that was never part of the product contract. An over-mocked test might replace every dependency with fake objects, proving only that the mocks behave as expected. A snapshot test might lock in a large block of output without making clear which part matters.

    Good tests tend to be specific, deterministic, readable, and connected to real risk. They explain the system’s expected behavior in a way another developer can understand six months later. AI can help draft them, but engineering judgment decides whether they are meaningful.

    Common Failure Modes in Agent-Generated Tests

    • Brittle assertions: The test checks incidental details, such as private method calls, object ordering that is not guaranteed, or exact formatting that users never see.
    • Excessive mocking: The test replaces so much of the system that the meaningful integration path is never exercised.
    • False confidence: Coverage increases, but the new tests do not check edge cases, failure handling, permissions, data integrity, or user-visible outcomes.
    • Nondeterministic behavior: The test depends on real time, random values, network availability, file-system state, local configuration, or test execution order.
    • Fixture sprawl: The agent creates large test fixtures that are hard to understand, hard to maintain, and easy to accidentally misuse.
    • Snapshot overload: The test approves a large generated output without explaining which fields are important and which are incidental.
    • Happy-path bias: The test confirms the ideal case but ignores invalid input, empty states, rate limits, authentication boundaries, and recovery from failed dependencies.
    • CI mismatch: The test passes locally but fails in CI because the agent assumed a different runtime, database state, environment variable, locale, or dependency version.

    Recent research into agent-generated tests reinforces the point. A July 2026 arXiv paper analyzing 204,673 test artifacts from the AIDev dataset reported that agent-generated tests showed stronger edge-case variety than human-authored tests in the studied sample, but also a higher candidate rate for flakiness, largely tied to file I/O and nondeterministic logic. In other words, AI-written tests can be useful and still require review for robustness.

    A Lightweight Review Checklist Before Merging

    Teams do not need a heavyweight process for every AI-generated test. They do need a consistent review habit. Before merging a pull request that contains agent-written or agent-modified tests, ask these questions:

    • What behavior is this test protecting? If the answer is not clear, rename or rewrite the test.
    • Would this test fail if the real bug came back? Regression tests should prove the fix, not just execute nearby code.
    • Is the test deterministic? Remove dependence on real time, random data, network calls, shared files, or execution order unless those are deliberately controlled.
    • Are the mocks hiding the risk? Mock external systems where necessary, but keep enough real behavior to validate the integration that matters.
    • Is the assertion about an outcome or an implementation detail? Prefer user-visible results, persisted state, emitted events, API responses, or documented contracts.
    • Is the fixture small and intentional? Test data should be readable and relevant, not a large blob created just to satisfy setup requirements.
    • Does the test cover failure paths? AI often writes happy-path tests first; reviewers should look for permissions, invalid input, empty data, retries, and error handling.
    • Will this test be understandable later? If a future maintainer cannot tell why it exists, it is not finished.

    CI/CD Guardrails That Keep Speed From Becoming Chaos

    Quality gates work best when they make the desired behavior easy and risky behavior visible. For AI-generated tests, the goal is not to slow teams down. The goal is to prevent a fast feedback loop from becoming a noisy feedback loop.

    • Use deterministic fixtures: Keep test data stable, minimal, and isolated. Seed databases predictably and avoid depending on production-like randomness.
    • Isolate test data: Each test should create and clean up its own data or run inside a disposable environment. Shared state is a common source of flakiness.
    • Block real network calls by default: Unit tests and most integration tests should not depend on live third-party services. Use recorded responses, contract tests, or controlled test doubles.
    • Control time and randomness: Freeze clocks, seed random generators, and avoid tests that change behavior based on the current date or local time zone.
    • Set coverage thresholds carefully: Coverage can prevent backsliding, but it should not reward meaningless tests. Use it as one signal, not the only signal.
    • Consider mutation testing where appropriate: Mutation testing can reveal whether tests actually detect changed behavior, though it may be too slow or costly for every pipeline.
    • Require human review for high-risk paths: Authentication, payments, data deletion, privacy-sensitive workflows, migrations, and permission logic deserve explicit human approval.
    • Add flaky-test quarantine policies: If a test is flaky, track it, quarantine it temporarily if needed, assign ownership, and fix or delete it. Do not let random failures become normal.
    • Measure test health over time: Track retry rates, duration changes, failure frequency, and which tests are most often quarantined. Observability applies to the test suite too.

    A practical pipeline might run fast deterministic tests on every pull request, deeper integration tests before merge, and slower end-to-end or mutation checks on a schedule. Not every repository needs the same gates. A small plugin team and a large enterprise platform will make different tradeoffs, but both need confidence that passing CI means something.

    CI/CD itself is also becoming part of the agentic surface area. A 2026 arXiv study of 8,031 agentic pull requests across 1,605 GitHub repositories found that CI/CD configuration files accounted for 3.25% of agent changes, with most of those changes targeting GitHub Actions. That makes pipeline review part of the same quality conversation as test review.

    What This Means for WordPress and AI Plugin Teams

    WordPress teams building AI-enabled products face a particularly interesting version of this problem. Plugins often interact with databases, scheduled jobs, user roles, REST APIs, admin screens, external AI services, and third-party themes or plugins. That creates many places where an AI-generated test can look convincing while missing the real integration risk.

    For example, a team building an AI pipeline plugin for scheduled publishing, a chat assistant that escalates to a human, or a CRM plugin that enriches lead records should care about regression checks around permissions, rate limits, data persistence, cron behavior, and failure recovery. In a context like CoatiPress, reliable tests would not just confirm that an AI call was mocked successfully.

    Sources and Fact Check References

    • Anthropic – Anthropic’s 2026 Agentic Coding Trends Report describes software development as shifting toward orchestrating agents and discusses productivity, oversight, quality, and security tradeoffs.
    • Gartner – Gartner reported in May 2026 that the enterprise AI coding agent market was entering a phase of expansion and competitive realignment.
    • arXiv – A July 2026 arXiv paper analyzed 204,673 test artifacts from the AIDev dataset and reported higher candidate flakiness in agent-generated tests, largely tied to file I/O and nondeterministic logic.
    • arXiv – A 2026 arXiv study of 8,031 agentic pull requests across 1,605 GitHub repositories found that CI/CD configuration files accounted for 3.25% of agent changes, with most targeting GitHub Actions.