Butch's Take

Amazon’s Kiro team published a Frontier Engineering guide, and they claim: AI agents now code, test, hit failures and fix them, iterating without human input. Your engineering time goes into architecting the system that allows that to happen. One person who says it’s working is @poteto, who shipped 2,500 PRs in a month through her system, pstack. Between that and all the dark factory talk, lots of teams are thinking through this work, me included. For the past 2 weeks at Triad we’ve been standing up our AI Factory: you tag a ticket and out comes a pull request. So far we've used it to build the factory itself, and implement some small changes with our internal MCP server. It’s early, but the better the models get, the easier it’ll be for a setup like this to take off.

One principle worth checking out is “Trust the boundaries, not the agent.” The article says the choice between letting an agent run wild on your laptop and clicking “accept” on every tool call is a false one. The part that matters most for QA is layering in deterministic checks that catch problems with the agent’s implementation. This means more than having an agent verify the implementation. It means maintaining a suite of deterministic tests that don’t rely on an LLM to run. Leveraging AI agents to write these tests can be a big timesaver, but it’s important to read the tests and confirm they have the right assertions.

This ties back to two other principles. “You’re the architect, not the typist” is going to be a big mindset shift for a lot of engineers and QA folks, because the job becomes thinking at a systems level about what has to be in place to get the outputs you want. “Agents for everything, not just code” is already playing out for us: we use playwright-cli and other browser tools so the agent can check its own work. That self-check is useful, but it’s still the agent grading its own homework. Deterministic checks don’t care how confident the agent sounds, and the article puts it well: “Every guardrail you automate is one less reason to stay in the loop.”

Headlines & Launches

My 25-Year Career Was a Lie?
John Gluck (Medium)
A 25-year veteran (5 tester, 10 SDET, 10 test-infra builder) argues QA built its own replacement: every systematized piece of testing became automatable, and AI is good at all of it. What remains is judgment: deciding which questions matter and saying don't ship. And it is a much smaller job, possibly not a tester's.

Agent Testing Is Obsessed With Breaking the Model
Tatyana Kazakova (LinkedIn)
Kazakova argues agent testing is obsessed with breaking the model, jailbreaks and injection, while deterministic product behavior still fails. Her example: an agent with schedule_appointment but no reschedule or cancel books a second slot, calls it moved, and leaves the old one. Not a reasoning failure; the workflow's tools were missing. Red teaming is needed, but classic testing is too, because agent PMs still miss requirements.

Cloudflare Issues: Detect and Send Production Issues Straight to Your Agent
Thomas Ankcorn, Maksym Makuch, Nevi Shah (Cloudflare Blog)
Cloudflare Workers gets built-in error monitoring (open beta): Issues groups repeated exceptions, 5xx responses and error logs, then sends the failure summary, stack trace, logs, traces and version straight to Claude Code, Cursor, Devin or any webhook when a threshold trips. One line of config, no SDK, OpenTelemetry spans for user/account context, human reviews the PR before it ships. Dogfooded: found two Workflows bugs in one day.

WebdriverIO v10: Verification Loops for Coding Agents, on Every Platform
WebdriverIO Team (webdriver.io)
The 15-year-old framework rebuilds itself around agent verification: wdio session keeps a live session across short shell commands and exports what worked as a plain test; browser.act() writes a step as intent, runs the model once, replays as code with zero tokens; and a healed step only counts if it produces the same network effects. Ships an open Online-Mind2Web benchmark, MCP server, DevTools traces, and llms.txt docs.

Tools & Frameworks

Hurl: Run and Test HTTP Requests in Plain Text
Orange Open Source (hurl.dev)
CLI tool that runs HTTP requests defined in a simple plain-text format: chain requests, capture values (CSRF tokens, session IDs), and assert on status, headers, JSONPath, XPath, cookies, SSL certificates, response duration and even SHA-256 body hashes. Single Rust binary on libcurl, REST/SOAP/GraphQL, JUnit/TAP/HTML reports for CI. Current major version 8.0 (April 2026). Fully deterministic, zero AI.

CUAWright: Microsoft's Terminal-First Browser and Desktop Agent Framework
Microsoft (GitHub)
Microsoft open-source framework (ex-Webwright) that turns coding models into browser and desktop agents by giving them a terminal: the agent writes and debugs Playwright scripts itself, browser sessions are disposable, and the persistent artifact is code and logs in the workspace. Same-model comparisons beat GUI-step agents across OSWorld-V2 (63.2% with GPT-5.5, +15.7 over the official agent), Online-Mind2Web 88.1%, Odysseys 77.5% vs 33.5%. Skill Factory distills every solve into verified, parameterized scripts that rerun with no model; reuse lifts held-out WebArena accuracy 55% to 70%. Plugins ship for Claude Code, Codex, and Hermes.

Foundations

A QE Perspective on Gen AI: Understanding AI Well Enough to Trust It Correctly
Mike Peterson (mikepeterson-git.github.io)
A working-level guide for quality engineers on what models actually do, how they fail, and how much confidence output deserves. Covers next-token prediction without reality checks, a seven-type agent memory taxonomy where each type fails differently, failure modes (hallucination, non-determinism, context loss, trained-in bias), and the two roles of AI in QE (subject under test vs tool in process). Core mindset: AI output is a claim, not a fact, until something independent of the model has checked it. Includes an adoption checklist; flags AI as sole test oracle as the highest-risk use.

Techniques & Tutorials

Using AI Browser Agents for E2E: Run With the Agent, or Have It Write Playwright Tests?
u/kennytabletennis (Reddit)
A solo founder runs E2E by handing user paths to a browser agent each run, but hits the wall: slow, costly, not repeatable, can't tell app breakage from agent error. Replies converge on the Cerebras split: agent writes the Playwright tests, CI runs them deterministically, browser agents stay exploratory.

Meet Terry Tester: AI Does the Grunt Work, Humans Keep the Judgement
Dan Sayer (LinkedIn)
Sayer describes the QA pipeline he built at Deskpro: Claude Code skills that generate grounded test plans, execute cases at the right layer, and report into Linear as a named bot. A deterministic script gate sets the ticket state, and any test it writes must fail against deliberately broken code before it counts.

Agentic E2E Testing: Actions, Assertions and Cost
Sławek Radzyminski (awesome-testing.com)
Radzyminski migrates a 302-test Playwright suite to the new e2e framework and measures everything: AI assertions average 0.7 cents, AI actions 1.9 cents, full-AI runs cost $1.99 and run 9.5x slower. Replay caching halves cost but assertions always call the model. Mutation-style error injection caught 31/38 faulty screens; after tightening two assertion wordings, 38/38. Hard limit: the model only judges what it can see, so an API-level data change passes an on-screen assertion.

Red, Green, Remove: Outside-In Tests for Coding Agents
Ian Maurer (imaurer.com)
Names the agent-testing failure mode test sediment: TDD works for agents, but every step leaves a small test behind that slows builds, breaks refactors and locks in wrong behavior. His loop: write behavior as outside-in tests, treat unit tests as scaffolding, then keep only four kinds before landing (real-entry-point behavior tests, edge-case tables, contract checks, regression tests) and delete the rest.

Reliable Visual Regression Testing for Humans and Coding Agents
OpenTeams + Quansight (openteams.com)
JupyterLab rebuilt its Playwright/Galata visual regression suite so humans and coding agents can trust it: suite time 55 min to 14-16 min, flaky tests 17 to 2.4 per run. Local runs produce CI-identical pixels via pinned fonts and normalized text rendering. A false failure makes an agent edit working code, so reliability enables 30 iteration rounds per day instead of 8; agents follow lint rules more reliably than prose docs.

Hot Takes 🔥

Coding Is NOT Solved
Alex Ewerlöf (Alex Ewerlöf Notes)
Ewerlof's rebuttal of the 'coding is solved' narrative: creation got cheap, but maintenance, NFRs, and accountability are the real cost, and AI 'cannot be held accountable.' Includes the Toby Lutke slop-grenades arc, a live DHH feud, and four future engineer roles, one being the AI quality engineer who tames stochastic systems.

The QA Role Has Everything Working Against Itself
u/Due_Present_1358 (Reddit (r/QualityAssurance))
A Reddit regular argues the standalone QA role is collapsing in the US: a cost center, easy to outsource, absorbed into dev work that AI makes simpler. Testing is not disappearing, the role is. Replies push back that when QA is cut, devs expected to test simply do not, because output targets never drop.

QA Engineer Works as Developer on AI-Assisted Greenfield Build
Scott Dyer (LinkedIn)
A QA/QE-background engineer describes serving as plain developer on a greenfield project, using AI heavily to ship production code in a low-latency architecture. Small team shared dev, DevOps and BA duties. His takeaway: AI does not replace the experience behind the roles, knowing what to build and whether the output is right still matters, but rigid role lines matter less. Comments trend toward one-person, many-hats teams.

Nate Berkopec Bans Agents From Writing Unit Tests
Nate Berkopec (X)
Rails performance author adopts two hard rules for AI coding agents, as a diff to his agent instructions: never write a new unit or integration test unless explicitly instructed (e2e and system tests allowed), and never add new code comments. A blunt upstream countermeasure to test sediment: agents generate reflexive low-value tests and comments that rot, so block them at the policy level instead of pruning after the fact.

Two-Slice Teams: Pirates and Architects in the AI Era
Dan Shipper (via Lenny Rachitsky) (X)
Sixty-seven-second clip from Lenny Rachitsky podcast: Dan Shipper replaces Bezos two-pizza teams (8-10 people) with two-slice teams of one or two, since AI lets a pair get so far so fast that extra people add coordination overhead and conflicting visions. His composition: pair a pirate (self-described slop cannon obsessed with finding value, building lots, throwing most away) with an architect (someone who takes the messy output and shapes it into something valuable, beautiful, extensible). 175K views in a day.

Break-UI: An Agent Skill That Attacks Your Interface With Awkward Data
Emil Kowalski (X)
The Linear designer added /break-ui to his skills repo: an agent skill that tries to break your UI by feeding it long names, unusual emails, and long lists, then fixes what breaks. Plus /mobile-native for touch-native polish. The awkward-input checklist, packaged as a steal-able agent skill.

Maintaining Quality in the Age of Agentic Engineering
u/Defiant_Corner2169 (Reddit r/ExperiencedDevs)
A mid-level engineer's confession: 6 months agent-first, best work still comes from hand-building mental models. Autonomous runs yield cool demos, then quiet misaligned decisions that spiral into AI-slop; a TDD harness only delays the spiral. Top reply: coding was our thinking time, not our production time.


If something in this issue made you think differently about how your team approaches AI in testing, pass it along. The best conversations about AI and QA are happening in Slack channels and stand-ups, not just newsletters.

Have something worth featuring? Reply and send it my way, I read every link.

Thanks for reading,
Butch Mayhew