Automated testing has long been the practical way to keep business software nearly bug-free at a fraction of the cost of formal specifications and proofs. The most effective form of it — writing tests first, one failing test at a time, and making it pass — is test-driven development. When AI agents arrived, the hope was that, since they generate tests unprompted, the same level of correctness would follow. In practice, that has not happened: multiple reports published in early 2026 document a decline in the quality of code that organizations deploy. A plausible contributing cause is a drop in the quality of automated functional tests.
Why test quality degrades under autopilot
An interview study in early 2026 with 26 developers at an organization heavily invested in AI coding agents put the question directly: do you trust our tests? The answers were consistently negative. Developers said that even when they review generated tests at the start, later features cause the AI to refactor both production code and test code, so confidence that the tests still verify the right behaviour erodes.
The refactoring itself is often legitimate. When a function signature changes as the code evolves, the agent has to update the tests — that is normal development, not error. The real difficulty is review cost: reading AI-generated test code is even more tedious than reading AI-generated production code, so re-reading every changed test at every step is not realistic.
There is a second, deeper failure mode related to coupling. Asked to cover a module with unit tests, an agent will produce many tests, frequently relying on mocks and stubs. Tests exist to fail when the code returns a wrong result or produces a wrong side effect. Heavily mocked tests instead fail whenever the implementation of the mocked code changes, including harmless refactorings that preserve correctness, generating false positives. Worse, they may not protect us at all: instead of asserting that input X yields output Y, they assert that calling function A calls function B — which proves nothing about results. And when asked to cover something with tests, the agent most often writes tests that confirm the current implementation, bugs included.
In short, AI-generated tests tend to be numerous, hard to read, coupled to the implementation, and potentially not even proof of correctness. Mandating that humans write all tests would negate most of the economic benefit of coding agents and is not realistic given where the field is heading.
Written specifications are not a substitute
Much AI-assisted development uses some form of spec-driven development, which vendors recommend and whose frameworks enjoy real popularity. Aligning with the AI before development is clearly useful — for example, having it ask clarifying questions. But prose specifications in Markdown documents bring their own problems.
- Volume and fatigue: generated prose overwhelms developers until they skim and accept AI plans after little more than a cursory glance — what has been called cognitive surrender.
- Maintenance: after a feature ships, what happens to the spec? Some frameworks support durable specs, but over time the volume risks exceeding what the team can maintain.
- Partial compliance: large language models do not honour every detail; an agent may quietly abandon parts of the spec in order to declare “done” sooner.
- Ambiguity: English cannot achieve the precision of a programming language. Prose specs cannot be executed; tests can.
Three claims, and the properties we want
I claim three things: (1) when AI writes the code, developers become its customers; (2) therefore customer tests, not developer tests, become the primary contract between humans and AI; (3) moving that contract into test data rather than test code makes it easier to protect from unexpected modifications by coding agents.
The target for such tests is three properties:
- They predict success in production: when they all pass, we gain confidence the functionality works as expected in production.
- They are resistant to refactoring.
- They are as easy to read as possible.
Four techniques get us there:
- Customer tests: write in the language of the customer.
- Black box: test the system or its components from the outside, without naming implementation details of the production code.
- Tests-as-data: capture just the facts — the input, the expected output or side effects, and the test setup — without implementation details in test code.
- Test DSL: find the most straightforward way to represent input, output and system state in text a domain expert can read, such that a failing test produces a clean diff.
The economics that once blocked this approach have changed. In the past, DSL parsers and custom test runners were expensive to write and maintain; now AI makes them cheap. The same AI writes a relatively small runner that interprets our data files, which leaves the contract itself, stored as data, easier to shield from unexpected manipulation by coding agents. The ideas are not new: this builds on customer-oriented acceptance tests from Extreme Programming, the test DSLs of Fit and specification by example, tabular tests as in Go, and readable textual representations of application state from approval testing.
Where this leaves TDD
Humans benefit enormously from TDD in their own coding loop. Can we expect AI to do better if we ask or force it to follow TDD internally? Getting an agent to follow canon TDD is not easy, because it usually generates lots of code before writing tests. Conversely, agents appear to perform better when we tell them what we want and how to validate the result; adding instructions on how to achieve it seems to make them perform worse. The techniques above supply precisely that “how to validate the result”. In a way, this is test-first with larger steps: smaller steps are generally safer, but the goal here is to make larger steps safe.
What the tests should assert
Unit tests grew out of Extreme Programming’s “developer tests”: checks written by developers to confirm that their own code behaves as intended. XP also defined customer tests, or acceptance tests — tests phrased in the customer’s language that describe expected behaviour from the users’ perspective. Because a customer can follow what such a test proves, the tests keep customer and developer aligned.
That alignment property gains new weight once machines produce most of the code. Humans increasingly act as the customers of the code, so we specify behaviour in terms as free of implementation detail as possible and hand the details to the AI. Hence customer tests should be the primary kind of test for AI-generated production code. Unit tests remain useful, but they are not the primary source of truth for specifying behaviour.
Customer tests carry four benefits:
- They define the functional content of a user story, so a passing test means the story is functionally complete.
- They guard against regressions: once a customer test passes, it must keep passing until the underlying business rule changes.
- They enable refactoring, since they test behaviour rather than implementation.
- They make alignment concrete — customers can read a test and say whether it tests the right thing.
The cost is that customer tests can be awkward to work with. Implemented as end-to-end tests in particular, they tend to be slow and flaky.
Keeping test intent visible
A common source of unreadable tests is boilerplate obscuring intent.
@Test
void defaultGreeting() throws IOException, InterruptedException {
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/hello"))
.GET()
.build();
HttpResponse<String> response =
client.send(request, HttpResponse.BodyHandlers.ofString());
assertEquals(200, response.statusCode());
assertEquals("Hello, world!", response.body());
}
@Test
void personalisedGreeting() throws IOException, InterruptedException {
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/hello?name=Joe"))
.GET()
.build();
HttpResponse<String> response =
client.send(request, HttpResponse.BodyHandlers.ofString());
assertEquals(200, response.statusCode());
assertEquals("Hello, Joe!", response.body());
}
The relevant pieces here are the test name, the input and the expected output; everything else is scaffolding that hides what is being proven.
@Test
void defaultGreeting() throws IOException, InterruptedException {
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/hello"))
.GET()
.build();
HttpResponse<String> response =
client.send(request, HttpResponse.BodyHandlers.ofString());
assertEquals(200, response.statusCode());
assertEquals("Hello, world!", response.body());
}
@Test
void personalisedGreeting() throws IOException, InterruptedException {
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/hello?name=Joe"))
.GET()
.build();
HttpResponse<String> response =
client.send(request, HttpResponse.BodyHandlers.ofString());
assertEquals(200, response.statusCode());
assertEquals("Hello, Joe!", response.body());
}
Read that way, the tests state plainly that the default greeting is “Hello, world!” and that supplying a name yields “Hello, <name>!”. So why not write only those three elements?
suite: greetings
tests:
- name: "default greeting"
request:
resource: "/hello"
name: null
greeting: "Hello, world!"
- name: "personalised greeting"
request:
resource: "/hello"
name: "Joe"
greeting: "Hello, Joe!"
A YAML file like this can feed a parameterized test that AI can write with little effort. The usual workflow: draft a sample of the domain-specific language you want, have the AI write a runner for it, then let humans and AI together add further cases.
- name: "name must not be entirely whitespace"
request:
resource: "/hello"
name: " "
error: "Name must not be entirely whitespace"
A table extracted to CSV is more concise still:
test_name, resource, name, greeting, error default greeting, /hello, null, "Hello, world!", personalised greeting, /hello, Joe, "Hello, Joe!", not whitespace, /hello, " ", null, Name must not be entirely whitespace
Tables earn their place because the coverage — and the gaps — are visible at a glance, and new cases are easy to append.
This is tests-as-data. It addresses distrust of tests in three ways: the cases focus on what matters to developer-customers, they survive refactoring, and living in text files makes any AI edit to them easy to spot.
Tables fit when input, setup state and expected output are each a single scalar. Structured data needs the scenario form below.
Scenarios when tables fall short
Non-scalar inputs call for structured scenarios. Ron Jeffries’ Extreme Programming Adventures in C# (2004) opens with a customer test for an XML-markup article editor:
---- before ----
<p>Fo|o</p>
<p>Bar</p>
----------------
* press enter
---- after ----
<p>Foo</p>
<p>|</p>
<p>Bar</p>
----------------
The test shows what happens when the user presses enter with the cursor (shown as “|”) mid-paragraph. Jeffries goes on to build a simple runner for it, and the test lives in a text file from the start.
The same approach suits language interpreters and compilers, where building feature by feature from the simplest meaningful program (usually “Hello, world!”) beats designing the grammar first. With coding agents this makes even complex interpreters and compilers safe to develop; this BASIC interpreter example is one instance.
tests:
- name: "LEN function basic tests"
program: |
10 PRINT LEN("HELLO WORLD")
20 PRINT LEN("")
30 PRINT LEN("A")
40 END
expected:
- "11\n"
- "0\n"
- "1\n"
- name: "LEFT$ function basic tests"
program: |
10 PRINT LEFT$("HELLO WORLD", 5)
20 PRINT LEFT$("HI", 10)
30 PRINT LEFT$("TEST", 0)
40 PRINT LEFT$("HELLO", 3)
50 END
expected:
- "HELLO\n"
- "HI\n"
- "\n"
- "HEL\n"
For a web application, a todo-list test might look like this:
## Unchecking a completed todo reactivates it
GIVEN model:
[x] buy milk
[ ] walk the dog
WHEN user:
click toggle of "buy milk"
THEN page:
> ""
[ ] buy milk
[ ] walk the dog
-- **2** items left
THEN model:
[ ] buy milk
[ ] walk the dog
The rendered display is reduced from HTML to a simplified textual form:
> "" [ ] buy milk [ ] walk the dog -- **2** items left
That representation embeds cleanly in tests, produces readable diffs on failure, and tolerates visual changes to the UI. The function producing it from HTML or the DOM is a printer, or projection. A second printer exposes the application’s internal state; here it appears in the THEN model section and uses syntax close to the UI printer’s, because an operation that changes state — unchecking a todo item — should be verified in persistent state, not only in the UI.
Two parsers complete the picture: one in the GIVEN model section sets up the starting state, and one in WHEN user interprets the command sent to the application from a vocabulary of operations. State printers and parsers reach the application through a side channel. A coding agent can readily generate the runner that ties these mechanisms together.
The practice of treating tests as data predates the current wave of coding agents, and three separate traditions feed into it. Each one has something to teach about how a machine-readable specification should look.
Fit and Specification by Example
Ward Cunningham developed Fit around 2002 after growing tired of copying test data out of his customers' Excel documents and into test code. Fit read the test data directly from Excel and ran the tests automatically, which let customers extend and refine the specification while Cunningham verified that his programs matched it. Implementations exist for a range of programming languages.
Martin Fowler's 2004 article on Specification by Example set out the core idea: complicated requirements become clearer when developers and business people agree on examples of what should happen. Gojko Adzic published a book of the same title in 2011, by which point similar approaches were spreading, most visibly Cucumber and its Gherkin language.
This tradition popularized customer tests, but it carried costs. Extracting tables from documents automatically can be slow and fragile, and Cucumber requires an interpretation layer that can itself become a source of bugs and misunderstandings.
James Shore, an early Fit adopter who maintained many of its implementations, later became disillusioned with the approach. The tool's primary purpose was to improve communication with customers, yet most customers did not want to write the test tables; Shore ended up having the conversations and writing the Fit tests himself. Usage of Fit and Gherkin was later commonly delegated to QA teams for after-the-fact testing, which defeats the original purpose. His conclusion: if customers won't write the tests, the maintenance overhead of the runners isn't worth the value, and tests are better written in code.
The claim that customers don't want to write customer tests is often raised against the practice. Two features of the current situation change that calculus:
- When AI writes most production code, human developers occupy the customer's position: we describe what we want and give feedback on what we get.
- Building and maintaining the machinery that runs customer tests is something coding agents can do quickly and cheaply.
Specification by example also addresses the spec-driven development problems described earlier, because clarifying acceptance criteria with examples lets their description be much shorter. Making the tests an integral part of the specification renders it executable and impossible for coding agents to bypass, and the specs cannot go stale because they run in CI.
Go's tabular and file-based conventions
The Go language has its own related tradition: most tests are tabular. The fmt package, for instance, is tested with a table of structs holding the format under test, the input string and the expected output.
var fmtTests = []struct {
fmt string
val any
out string
}{
{"%d", 12345, "12345"},
{"%v", 12345, "12345"},
{"%t", true, "true"},
// basic string
{"%s", "abc", "abc"},
{"%q", "abc", `"abc"`},
{"%x", "abc", "616263"},
{"%x", "\xff\xf0\x0f\xff", "fff00fff"},
{"%X", "\xff\xf0\x0f\xff", "FFF00FFF"},
{"%x", "", ""},
{"% x", "", ""},
{"%#x", "", ""},
{"%# x", "", ""},
{"%x", "xyz", "78797a"},
{"%X", "xyz", "78797A"},
{"% x", "xyz", "78 79 7a"},
{"% X", "xyz", "78 79 7A"},
{"%#x", "xyz", "0x78797a"},
{"%#X", "xyz", "0X78797A"},
{"%# x", "xyz", "0x78 0x79 0x7a"},
{"%# X", "xyz", "0X78 0X79 0X7A"},
//[...]
A short runner executes every row against the fmt function; much of the standard library is tested the same way.
Go also has an established practice of writing scenarios in text files, particularly where tests depend on files existing or check that files are created. The go command line tool is tested this way:
env GO111MODULE=off
# hello world
go run hello.go
stderr 'hello world'
-- hello.go --
package main
func main() { println("hello world") }
The test exercises the go run subcommand through a custom DSL built for testing the central Go utility. The DSL lets the test writer define an environment variable, set up a file, execute a command and check the resulting output on the standard error channel.
Approval testing
A third tradition is Approval Tests, popularized by Llewellyn Falco. A system generates a file representing a sequence of computations, the state of the UI at a moment, or a readable rendering of internal state; the representation must be understandable by humans, who approve it. Thereafter the file can be regenerated on each run, and any difference from the approved version signals changed behaviour. The runner may come from an approval testing library or be generated ad hoc by a coding agent. The approach matters here because it stresses that what humans look at is not test code but test data. A key idea to borrow is making application state and output readable and "diffable", so a failure yields a clean textual diff between expected and actual. Falco and Lada Kesseler give a practical explanation of approval testing in a video.
Approved Scenarios, Approved Logs and constrained tests
Ivett Ördög has promoted these techniques for some time. Her Approved Scenarios and Approved Logs patterns both use a domain-specific language to express customer tests. The first specifies behaviour upfront; the second has the running system produce a textual rendering of its state that can be adjusted and turned into new tests, which suits existing systems or the writing of a failing test as the first step of a bug fix. Her video covers the techniques in more detail.
Such a DSL typically has three parts: setup of system state, the action or actions, and a representation of the resulting state. A typical starting process:
- Decide on a DSL format, likely with the AI, and write a first test.
- Have a coding agent generate the DSL parser and test runner.
- Check the runner against production code.
- Have the coding agent add scenarios using the first test as a template.
My reading is that Approved Scenarios fits a system already structured enough to make a meaningful first test possible, akin to the Spike and Stabilize pattern from Dan Terhorst-North. When starting from scratch, the first test could instead generate a Walking Skeleton.
Both patterns are instances of what Ördög calls Constrained Tests, in which a coding agent cannot easily cheat by writing tests weaker than expected. They make cheating less likely by requiring the assertion as a mandatory part of the DSL syntax, which in turn requires the DSL to be implemented with a parser, i.e. an external DSL. With an internal testing DSL — simply a collection of functions in the host language — an agent could write tests with no assertions or weak assertions, faking high coverage while not testing the system as intended.
One purpose of Constrained Tests is thus to keep test coverage a reliable indication of what is actually tested, which is what makes the overhead and indirection of an external DSL worthwhile.
Customer tests are frequently written as end-to-end tests that drive the UI. That works, but it is not the only option. Pushing every customer test through the UI makes the suite slower and more fragile. A common remedy is to run most tests below the UI, invoking the service layer — the set of classes or functions that the UI and other entry points call to execute business operations. This pays off in domains where the logic is far more intricate than the presentation, finance being the obvious case. In one insurance project, the rules for matching a claim to a lawyer were complex enough that writing the customer tests was itself how the team confirmed what the customer actually wanted; the tests were implemented at the service level.
Distance is the other difficulty: when the test's entry point sits many function calls away from the logic under test, the test must persuade an intervening component to configure the next one, which in turn configures the target. The result feels like building a ship in a bottle. A better approach is to write customer tests directly against the important component. What matters most about a customer test is that it aligns customers and developers, not where it enters the system. One example: a component that checks whether the user's IP address matches an allowlist. The allowlist logic was complicated enough that end-to-end coverage alone did not inspire confidence, so it got a focused customer test, implemented as a unit test with its own custom test DSL.
tests:
- name: "is_ip_allowed respects enabled flag"
allowlist:
- { id: 1, ip_or_cidr: "10.0.0.1/32", is_enabled: true }
- { id: 2, ip_or_cidr: "10.0.0.2/32", is_enabled: false }
is_ip_allowed:
- { ip: "10.0.0.1", expected: true }
- { ip: "10.0.0.2", expected: false }
- name: "is_ip_allowed fails closed on empty allowlist"
allowlist: []
is_ip_allowed:
- { ip: "10.0.0.1", expected: false }
# --- IPv4 MATCHING ---
- name: "is_ip_allowed matches /32 range"
allowlist:
- { id: 1, ip_or_cidr: "192.168.1.100/32", is_enabled: true }
is_ip_allowed:
- { ip: "192.168.1.100", expected: true }
- { ip: "192.168.1.101", expected: false }
- { ip: "192.168.1.99", expected: false }
With AI able to build test runners cheaply, giving each important behaviour its own DSL is now inexpensive.
UI, external dependencies and dual runners
UI testing is notoriously hard, yet UIs carry logic worth testing. Selenium-based suites are slow and flaky; Playwright reduces flakiness by automating the wait for components to render, and browser-based component testing recently reached Trial on the Thoughtworks Technology Radar. Tests can also avoid the browser entirely: JSDOM lets test runners mount UI components in a simulated DOM and interact with them as a user would, and popular frontend frameworks use it for in-process component tests. Aslak Hellesøy offers further guidance on sub-millisecond end-to-end tests.
External services — payment gateways, mail servers, inventory systems — complicate matters further. Tests wired to live services face unavailability, latency, unreliable behaviour, absent test versions, and other inconveniences. One team working against a test payment gateway had to periodically ask the provider to top up the test credit card's limit by a few million Euros, since constant test runs drained it to zero; a stock exchange test API that honours real market hours is another example, as are rate limiters. Since fast, reliable feedback is a success criterion for agentic coding, tests — end-to-end ones included — must run locally without external connections.
Local databases and mail servers are straightforward; custom third-party services are the hard part. WireMock or Mountebank with hand-written behaviour specifications is the traditional answer, but specifying that behaviour is laborious. A newer approach has coding agents generate local simulators of the external service from its published API. Justin McCarthy popularised the term Digital Twins for these; Clare Liguori calls them mock services in her account of how teams achieve step-change productivity gains with coding agents.
Here tests-as-data earns its keep: the same test can run as an in-process test for rapid feedback and as an out-of-process integration test with more realistic dependencies, just by having AI generate two runners. Uberto Barbini described a similar technique with tests-as-code, which is harder to adopt.
Black-box testing with external dependencies is a deep topic, skimmed here; Martin Fowler's and Ham Vocke's articles on the test pyramid cover it in detail.
Guarding the tests against the agent
Coding agents sometimes cheat: eager to declare a task complete, they may weaken or disable tests. That is one reason developers lose confidence that their tests still protect them once refactoring or new features force changes. Keeping the important parts of tests in text files helps, because the files can be made read-only while no spec change is expected, or at least checked in source control for unexpected edits. Missed changes become less likely, and any change that does occur can be inspected in the data with less fatigue than reading a code diff.
| When | Expect production code changes? | Expect test data changes? | Expect test runner changes? |
|---|---|---|---|
| Implementing new functionality | Yes | Yes | No |
| Refactoring production code | Yes | No | No |
| Improving test coverage | No | Yes | No |
| Improving test DSL | No | Yes | Yes |
Depending on the task type, files the AI is not expected to touch can be protected by read-only permissions the agent cannot bypass, or by a CI check that verifies which files changed for that task. Hooks in coding harnesses can feed the model fast feedback when it attempts a forbidden change, though they are not bullet-proof. Some risk remains: the test runner is code and can itself be modified, and the DSL implementation is another place for AI-induced confusion. The next section covers techniques for shoring up confidence further.
Validating the tests and the product
When AI writes some or most of the tests, review remains a problem. The techniques above make review cheaper by making tests more expressive and concise, but the volume is still large, so cognitive fatigue and cognitive surrender loom. Two strategies help: validate the tests, and find additional ways to validate the product.
Mutation testing is the first move — inject deliberate faults into production code and see whether a test fails, then check that the failure message is correct and informative. The simplest form is manual: flip a + to -, or comment out one branch of an if, and watch for breakage. Next, ask AI to run mutation testing itself. Finally, adopt a mutation testing library to automate it in CI.
Mutation testing shows the tests detect faults, but not that they assert the right behaviour. That calls for validating the expected outputs, which requires an oracle — someone or something that knows the correct output for a given input. Sometimes only a domain expert can serve; often other oracles exist, such as official regulations, internal compliance documents, technical handbooks, and API docs. When building a COBOL interpreter, for instance, the official IBM manuals in PDF and text gave the agents an authoritative source for the dialect running on IBM i. An alternative implementation can also act as oracle: a simple brute-force algorithm checked against a complex, efficient one. In the same COBOL interpreter, every customer test had to pass identically on a real IBM i system and on the developer's laptop, which validated that the largely AI-generated tests specified IBM's behaviour.
Another advantage of tests-as-data: the same test can run in more than one environment once AI writes another runner. During a rewrite, characterization tests can run against both the old and new systems.
Property-based testing and other confidence builders
Example-based tests, which check specific behaviours, have a complementary alternative: property-based testing (PBT). PBT exercises the system with a large, randomised variety of inputs and checks that no sequence drives it into an unwanted state. At minimum, check that no input crashes the system; more sophisticated PBT checks invariants that must always hold, such as customer balance must never be negative, or compares results against an oracle.
Beyond that, the application's nature suggests creative checks. A game can have the AI play hundreds of games against itself. A compiler can have the AI implement a complex program in the language and observe how well it runs. A web application can have the AI simulate users and attempt workflows through a browser tool like agent-browser. And asking the coding agent may surface further ideas.
When the approach does not apply
The methods described here target production systems. Early-stage work is different: generating a prototype and exploring what a coding agent produces is a fast way to learn, and tests matter less when learning speed outweighs the ability to evolve the system safely. Once the goal is clearer, the prototype can be discarded and rebuilt with tests, or stabilized and given coverage after the fact.
An external DSL carries real cost. The indirection requires work to make sure the DSL expresses what we want to say, and that the runner, printers and parsers are correct. That investment pays off only if someone reviews the tests — at least a sample — to confirm they express the intended behavior. Letting the model write tests however it chooses can be faster and cheaper, particularly when other means exist to validate the system.
The large steps these techniques enable also make it harder for people to retain an accurate understanding of how the system works. Internal architecture remains important, and other techniques are needed to build and maintain that understanding.
Nor do these approaches by themselves give assurance that the system is correct. Other automated testing techniques apply as discussed, and human exploratory testing is always recommended.
Summary
The starting problem: developers who grant AI high autonomy do not trust the resulting test coverage, largely because AI-generated tests are hard to read and tend to change whenever production code changes, even under refactoring.
The proposed solution combines:
- Customer tests in the customer's language (which now includes the developers)
- Black box tests at the system or component level
- Tabular parameterized tests where they fit
- Ad hoc test DSLs where tables do not
- Test data — tables or scenarios — in text files that are easy to distinguish from test code
- An AI-generated runner that executes test data files
Trust improves because tests become more expressive, free of irrelevant detail, robust to refactoring and easier to protect from unexpected changes by coding agents. It also supports specs that rely on more than Markdown prose to show the desired behavior is implemented correctly.
These techniques bring clarity to the functional specification, but they are one part of an engineering harness. They should be paired with mutation testing, property-based tests, lints and scanners, and manual exploratory testing by humans. The relevance is immediate: most code going forward will be written by machines, test code included, and it needs a shape that keeps people in control. A practical start is to cast tests in the language of the customer and follow the process outlined for Constrained Tests.
Disclaimer
This article reflects one practitioner's point of view and not necessarily the views of the author's employer. Situations and experience differ: take what you find useful and pay attention to what happens and what your system is trying to tell you.
Acknowledgments
Ben O'Mahony, Birgitta Böckeler, David Farley, David Lucas, Gabriele Lana, Ivett Ördög, James Shore, Joshua Kerievsky, Martin Fowler, Max Kanat-Alexander, Paolo Perrotta, Premanand Chandrasekaran, Valentina Servile and Wei Zhang commented on drafts of this article.
AI was used for brainstorming, research, criticism and proof-reading; all of the prose is the author's own.
Significant Revisions
11 November 2026: published



