Development with AI agents (ADLC): where GUI Test Studio fits

What the agentic development life cycle (ADLC) is

For decades software was built along the software development life cycle, the SDLC: a team plans, a developer codes, a tester tests, someone fixes, someone ships, and the cycle starts again.AI coding agents have not replaced that cycle.They have taken over its inner loop.

In an agentic development life cycle, the ADLC, an agent such as Claude Code, Codex, Claude Desktop or Copilot in agent mode reads the task, plans the change, writes the code, runs what tests it can, fixes what fails and opens a pull request, often several times an hour.People set the goal, review what comes out and decide what ships.The loop turns much faster than before, and the quality of what ships depends on the quality of what the agent can check by itself.

Agents are good at the checks that live in code: unit tests, type checks, linters.They are blind to the one thing a user sees: the application running, on a real screen, through its real interface.That is where end-to-end testing fits, and where most agent loops still have a hole.

Where end-to-end testing fits

An end-to-end test drives the application the way a user does: it opens it, clicks and types through a whole workflow, and verifies what the screen shows.For an agent it is the ground truth the code cannot give: did the button survive the restyle, does the form still submit, is the total still right.

Three things have kept end-to-end tests out of agent loops.They were slow to write, so nobody wrote one for a change made in ten minutes.They were code themselves, so they broke with every renamed element.And their results were a wall of logs an agent had to guess from.

GUI Test Studio removes all three.A test is recorded or described, never coded.It finds elements with the GTS Engine + AI, through what the application says about them, its accessibility information, and by sight when it says nothing, so a changed class name breaks nothing.And every run ends in a Confidence Report written in plain words, which an agent reads as easily as a person.The rest of this article follows the loop, stage by stage.

Create: an end-to-end test from a prompt

Install GUI Test Studio and connect your assistant once: in GUI Test Runner-Recorder, Create Test From Prompt shows Claude Desktop, Claude Code and VS Code, each with a Connect button.Any other assistant that speaks the connector's protocol is one command away.

Then describe the test.The agent records it the way a tester would: it opens the application or the web page, clicks the real buttons, types into the real fields and verifies what it sees as it goes, through the connector.Every check is evaluated on the spot, on the real screen, and refused when it would not pass right now, so the agent never saves a check that is wrong on day one.

What comes out is an ordinary GUI Test Studio test, with the same recording, steps and checks a person would have made, saved where you choose.Along the way the agent can pause to think, undo a step that went wrong, group steps into Scenarios, add a Wait or a note, and run the test at the end to prove that it passes.

With GUI Test Studio, create an end-to-end test of the shop at http://localhost:8080:
sign in as [email protected], add the "Desk lamp" to the cart, open the cart,
and verify that the total reads "$49.00" and that the "Checkout" button is shown.

The agent tests what you point it at: the whole screen, one application, an area of it, a web page in the browser of your choice, or a phone plugged in.It explores nothing unasked.How to connect each assistant and what to ask is in Create a test from a prompt.

Edit: change a test by prompt, or like a video

Tests age with the application.When the agent renames a button or adds a field, it should update the test too, not record a new one.

Through the connector the agent lists a test's steps by number and changes them in place: rename a step, change the text a check expects, give a check more time, remove a step or ignore it, add a Wait, say what happens if a check fails.Nothing is written before the agent shows the changes and you confirm them, and the test keeps everything else exactly as it was.

A person does the same in GUI Test Studio, on a timeline: steps are blocks you move, trim, rename and group, with undo for everything, and the frame of the recording under each one.The agent's test and the tester's test are the same file, as Update a test shows.

Run: headless, in parallel, in any CI/CD pipeline

gtr-cli runs any GUI Test Studio test without a window, from a script or a pipeline, and answers the way a pipeline expects: an exit code, a JUnit file for the CI tool, a JSON file for a script, a Markdown summary for the pull request.

gtr-cli run tests --countdown 0 --format github --junit results\junit.xml ^
  --json results\run.json --summary results\summary.md --artifacts results\artifacts ^
  --jira on-failure

A web test recorded once can be generated for other browsers and devices: Chrome, Edge and Firefox, phones, tablets and screen sizes, another language, a slow network, a zoom level.The browsers and devices that need no window run side by side, each in a process of its own, and a desktop test runs in its window after them.See Browsers and devices.

The log speaks each tool's own protocol: --format teamcity, azure, github or plain text.The same command works in TeamCity, Jenkins, GitHub Actions, GitLab, Azure DevOps or a script of your own, as Run your end-to-end tests on every build shows step by step.

Read: a verdict an agent and a person both understand

Every run ends in a Confidence Report.For each check it says, in plain words, whether the element was found, whether what was found matches the recording, and how much room there was: a check that passed narrowly is a warning before it becomes a failure.

AI Smart Verification, the AI side of the GTS Engine + AI, looks at a check that failed on pixels and tells a real regression from noise: a changed word, a missing badge or another colour is a regression; a shade or a shift of one pixel is not.Its answer is the final verdict, and it comes with a sentence an agent can act on: what changed, where, and by how much.

An agent reads the JSON file and the Markdown summary the run writes; a person opens the report, with the pictures side by side, the video of the run and the history of the test.Both say the same thing.The report is described in Read the Confidence Report.

Fix: a Jira bug the agent can pick up

With --jira on-failure, a failed test becomes a Jira issue by itself: a title, the numbered steps to reproduce, the picture the test expected, the picture it found and that picture again with every change outlined, plus a PDF and the evidence.The same defect seen again, on another build, browser or device, adds a comment to its open issue, never a duplicate.

That issue is written for a developer, and it turns out to be exactly what a coding agent needs: a reproducible path, a precise expectation and a picture of the difference.Point the agent at the issue and it has everything to propose a fix.How Jira is connected, from the Confidence Report or from a pipeline, is in every failed end-to-end test becomes a Jira bug.

The loop, closed: a demo shop

We built a small demo to watch the whole loop turn: an online shop, its end-to-end test, a TeamCity server, a Jira project, and an AI coding agent.Jean is the developer, Pierre wrote the test, James looks after the backlog, John runs TeamCity.

1. 1

   A change breaks the checkout

   Jean pushes a restyle of the checkout buttons.TeamCity runs the shop's end-to-end test with gtr-cli, headless, on every browser and device the test was generated for.

2. 2

   The run says what broke, and where

   The Confidence Report finds the checkout button, but not as recorded.AI Smart Verification confirms a real regression: the button lost its label. gtr-cli files a Jira issue with the steps, the expected and found pictures and the change outlined, and TeamCity's build log names the issue.

3. 3

   The agent fixes it

   The agent picks up the issue, reads the steps and the pictures, finds the style rule that hid the label, and proposes a fix on a branch of its own.

4. 4

   The test proves the fix

   TeamCity runs the same test on the branch.It passes.The passing run is added to the Jira issue, and James closes it once a person has reviewed and merged the change.Nobody wrote a test, a bug report or a reproduction by hand.

The human side

An ADLC is not agents alone.The people who steer it need to trust what the agents check, and to check it themselves when it matters.GUI Test Studio was built for that: the same test serves the agent and the person.

On-premise or in the cloud is your choice, check by check.An agent that creates tests, a tester who reads them and a pipeline that runs them are looking at the same file, in the same words.

Where to start