Docket built an AI teammate that tests your app the way a human actually would.

Every engineer knows the tax. You ship a small feature on a Tuesday, and by Wednesday three tests are red - not because anything is broken, but because a button slid four pixels to the left and the test was looking for it by name. Docket, a two-person company out of Y Combinator's Spring 2025 batch, decided that tax was optional.

The idea is almost stubbornly simple. You describe what you want tested in plain English - "log in, add an item to the cart, check out" - and Docket's AI agents carry it out by looking at the screen, the way a person does. When the interface changes, the test follows it instead of falling over. No CSS selectors to memorize. No brittle scripts to babysit.

That framing comes straight from the founders, who describe the product without much varnish: tests in plain English, and "no bullshit, no flaky selectors, no stale scripts." It is a narrow promise, and a specific one, and it lands because every developer has felt the exact pain it names.

Section 01 / The problemWhy test suites quietly stop being trusted

Automated testing was supposed to be the safety net. In practice, a lot of teams end up maintaining the net more than they trust it. Traditional end-to-end tools - the Seleniums and Cypresses of the world - identify elements by code: a button is a specific ID or a chain of CSS selectors. That works right up until a designer renames a class or a component library ships an update. Then the selector points at nothing, the test fails, and someone spends an afternoon figuring out that nothing was actually wrong.

The result is a slow erosion of trust. Flaky tests get muted. Suites get skipped "just for this release." The safety net develops holes, and the bug that finally slips through is the one a customer finds first. Docket's whole reason for existing is to move that discovery earlier - back to the moment before you ship.

There is a second, quieter cost. Because writing and fixing tests takes real engineering time, testing tends to get rationed. It goes to the critical login path and the checkout flow, and the long tail of smaller features ships with a shrug and a manual click-through. That is exactly where regressions hide. A tool that makes tests cheap to write and cheap to keep does not just speed up the work; it changes what gets tested at all.

Section 02 / How it worksLook at the screen, not the code

Docket's core bet is that vision beats selectors. Rather than reading your HTML, it looks at the rendered page and records pixel-perfect (X,Y) coordinates for each click. That sounds like a small implementation detail, but it changes what is testable. Canvas elements, iframes, pop-ups, and custom widgets - the things selector-based tools quietly skip - are all fair game when the test is driven by what is actually on screen.

The four-beat loop Docket runs on. The interesting beat is the third one.

The self-healing piece is where the maintenance tax disappears. When an element moves, Docket adjusts rather than fails. And because it can learn from real user session data, the tests drift toward how people actually use the product instead of how the team imagined they would. That feedback loop, more than any single feature, is the product.

The platform wraps that engine in the operational plumbing teams expect. There is record-and-replay for building tests by clicking through a flow, CI/CD integration so tests run on every push, scheduled runs for overnight regression sweeps, Slack notifications when something breaks, a dedicated mailbox for verification emails, and support for two-factor authentication - the small, unglamorous details that decide whether a testing tool survives contact with a real release pipeline.

Section 03 / The proofWhat customers report

Docket publishes results from early customers, and the numbers point in a consistent direction - less time spent maintaining tests, faster releases. eXp Realty reported cutting test validation time by 60% by letting Docket check the UI against Jira acceptance criteria. Centerpoint Connect said regression tests that once needed constant upkeep now finish in under 30 minutes. Nest Genomics, working with complicated clinical forms, reported an 80% drop in the time it takes to create a test.

Those are self-reported figures, and early ones - the customer list, from eXp Realty to Nest Genomics, Paradigm, Airea, and BrainHi, spans real estate, genomics, and software. The through-line is teams that ship often enough that testing had become the thing slowing them down.

Section 04 / The foundersA complaint that turned into a company

Docket's founders, Nishant Hooda and Boris Skurikhin, met at AWS and kept circling the same question: why is testing still this painful? Hooda, now CEO, had watched it up close at Stripe and Brex, where velocity was the whole game and QA was the thing that kept getting in its way. Skurikhin came from a different corner of high-stakes engineering - a quant developer role at Citadel, then growth engineering at Patreon.

Between the two of them the resume reads like a tour of companies where reliability is not optional: Stripe, Brex, Citadel, Patreon, AWS. They left, joined Y Combinator's Spring 2025 batch, raised a small seed, and turned the recurring hallway complaint into a product.

There is something telling about who builds a testing company. It is rarely the people who find QA glamorous. It is usually the ones who spent years watching good releases get held up by fragile test suites, and who got tired enough of it to do something. Hooda and Skurikhin fit that mold - they are not selling testing as exciting, they are selling it as something that should get out of your way. The blunt, jargon-free product copy is not an accident; it is the same voice engineers use when they are done pretending a problem is fine.

Section 05 / The marketWhere Docket fits

Testing is a crowded neighborhood. On one side sit the incumbents - Selenium, Cypress, Playwright - powerful, code-first, and demanding of the exact selector maintenance Docket is trying to erase. On the other side is a fast-growing pack of AI-native testing startups, from QA Wolf to Reflect to Momentic, all chasing the same intuition that large models can take the grind out of test authoring.

Docket's wedge is the combination of two choices: plain-English authoring on the front end, and a vision-first, coordinate-based engine underneath. The first lowers who on a team can write a test. The second widens what can be tested and makes the tests durable. Run across web, iOS, Android, and desktop from one platform, and the pitch to a growth-stage team is straightforward - one place to test everything, and less time spent keeping the tests alive.

The plain-English part matters more than it first appears. When authoring a test requires knowing the code, testing stays trapped inside engineering. When it only requires describing a flow, a product manager or a QA specialist can write one too - and the acceptance criteria that live in a Jira ticket can become an executable test almost directly. That is the workflow eXp Realty described: Docket checking the built UI against the criteria someone already wrote down. The tooling stops being a separate discipline and starts being an extension of the spec.

Who is this for, concretely? Teams that ship often and have outgrown manual QA but not yet built a dedicated automation team. A ten-engineer startup pushing daily. A growth-stage company whose test suite has quietly become a liability. A team with a heavy, visual, or non-standard interface that selector tools handle badly. For all of them, the value is the same shape: coverage that arrives faster and costs less to keep than it did before.

The business model tracks the ambition. There is a free tier to get a first test suite running, paid plans as coverage grows, and enterprise demos for larger teams. At launch, Docket offered to build complete test suites free for its first ten customers - a founder's way of buying reference stories while the product is young.

None of this guarantees the outcome. Docket is small, early, and playing in a category where well-funded competitors are pushing in the same direction. But the framing is clear, the early customer numbers point the right way, and the underlying idea - test what is on the screen, not what is in the code - is the kind of simple reframe that tends to age well.

If Docket is right about anything, it is that the last decade of testing tools optimized the wrong variable. They made tests more precise and, in doing so, more fragile. Docket is betting the opposite trade is better: a little less precision about the exact element, a lot more resilience when the page inevitably changes. For teams drowning in red builds that mean nothing, that is a trade worth watching.