Agentic Test Authoring

This concept unlocks the next stage of your journey: how AI coding assistants go from suggesting snippets of code to autonomously working on a whole repository. Once you see how an agent writes and maintains tests for an application, you'll understand the broader pattern of agentic systems — the same machinery that powers agents that plan, call tools, and make multi-file changes. You'll also be ready to study the topics your library lists as neighbours: Agent Instruction Files, Skill Design and Scoping, and Claude Skills, because each of those is a way of giving an agent the context and the boundaries it needs to do test authoring well. Without this concept, those topics would feel like abstract advice; with it, they become concrete tools you can reach for.

Imagine you've just built a small web app — a to-do list where users can add, tick off, and delete items. Before you show it to anyone, you want to be sure it works. You could click through it yourself, trying every button, entering every kind of input you can think of: a normal task, an empty task, a task with a thousand characters, a task with special symbols. That's manual testing — a human, exploring by hand. Now imagine you could hire a tireless assistant who does exactly that clicking and typing for you, but doesn't get bored, doesn't miss a case, and does it a hundred times faster. That assistant is an agent — a program powered by a large language model that can read your app's screens, click buttons, type into fields, and observe what happens. Agentic test authoring is the practice of pointing such an agent at your app and letting it generate, update, and fix the automated tests that verify your app's behaviour. The agent explores the app the way a curious tester would, but it writes down what it finds as test code that runs automatically from then on. The key phrase is 'driven from the application under test' — the agent doesn't imagine tests from a spec alone; it actually interacts with the running app and sees the real screens, the real error messages, the real behaviour. That's what makes it powerful and also what makes it need human oversight, because the agent can only test what it can see and can encode its own wrong assumptions into the tests.

Think of a new cook joining a restaurant kitchen. The head chef doesn't hand them a recipe book and say 'go cook'—they set them loose in the actual kitchen, with real ingredients, real pans, and a real stove, and say 'make me a dish that shows you understand how this kitchen works.' The cook explores: they open the fridge, see what's there, try a combination, taste it, adjust. Their first attempt might be okay but not great; they try again, changing the proportions, until they have something the head chef approves. Then they write down the recipe so it can be repeated. Agentic test authoring is like that: the agent is the cook, the application is the kitchen, and the test suite is the written recipe. The agent 'tastes' by running the app, trying actions, and checking what comes back. It writes down what it learns as automated tests. But here's where the analogy stops: a cook understands flavour and can improvise when an ingredient is missing, but the agent only knows what it has seen in the app. If the app has a button that's hidden unless you scroll, the agent might never find it, so it won't test that path. And the recipe the agent writes — the tests — encodes its interpretation of the kitchen. If the agent saw a field labelled 'name' and assumed it required text, it will write a test that expects that, and if the real requirement was that empty names are allowed, the test is wrong. So the head chef (you) must review the recipe before it goes into the binder. The agent is a fast, thorough explorer, but you are the one who knows what the dish is supposed to taste like.

Agentic test authoring is the practice of using AI agents — programs that can independently interact with an application, observe its behaviour, and modify code — to automatically generate, maintain, and repair the automated test suite for that application, with the agent's decisions being driven by what it actually encounters in the running app.

You've noted in your library that this sits under AI Coding Assistants. The parent concept's key idea is that we're moving from chat-based assistance (you ask, the model replies) to agentic execution — where the assistant acts on a real repository. Agentic test authoring is one concrete form of that execution. It builds directly on Large Language Models (the agent's brain) and AI Agents (the loop of plan-act-observe). You've also noted neighbouring topics: Agent Instruction Files and Skill Design and Scoping are exactly the tools you'd use to shape how a test-authoring agent behaves — they give the agent standing context about the codebase and define its boundaries. Claude Skills, another neighbour, are how you'd package a reusable test-authoring workflow so you can invoke it any time you start a new project.