TryCase gives AI agents a disposable test lab — and a reason to say 'done'

The hardest problem in AI-assisted software development is not writing code. It is knowing whether the code works.

TryCase, a new devtool that launched on Product Hunt on July 5 and reached #4 on the daily leaderboard with 184 upvotes, directly targets that gap. It gives each coding agent a disposable Linux desktop in the cloud. The agent runs the app, tests the change end to end, and returns screenshots, video recordings, and logs as proof. The environment is destroyed afterward. The loop is explicit in the API: launch, upload, exec, browse, record, iterate until the flow passes.

The product was built by Ben Chomsang, who describes the origin in his launch comment. He was running multiple agents across different worktrees, each testing changes, spinning up apps, taking screenshots. His laptop became the bottleneck. Ports collided. Browser sessions overlapped. He was still doing the final verification himself. TryCase is the abstraction that separates each agent’s runtime from the host machine and from every other agent.

The technical pattern is straightforward. The SDK shows a trycase.launch({ os: "linux" }) call, then env.upload(repo), env.exec("bun install && bun dev"), and browser control via env.browser.open(appUrl). The agent clicks through the UI, fills forms, and calls env.record({ video: true }). The output is a structured proof packet. The agent can then fix failures and retest in the same environment.

What matters here is not the infrastructure. Cloud VMs for CI are not new. What matters is the shift in what an agent is expected to return.

Most coding agents today return code. The human is the verifier. The human runs the app, clicks through the flow, checks for regressions. That handoff is where trust breaks. TryCase inverts the contract. The agent returns proof. The human reviews the proof. The agent, not the human, did the testing.

This is a small product change with a large cultural implication for how teams use AI coding tools. The prompt templates on the TryCase site make the expectation explicit. “Fix issue X, then verify end to end that it is fixed in TryCase. Iterate until it works. Show me proof with a video recording and screenshots.” “Before we ship, use TryCase to test login, the main user flow, mobile layout, and error states. Return only the issues found and proof for the passing flow.”

The agent is not done when the code compiles. The agent is done when the recording shows the checkout button working.

This matters because the economics of agentic coding are shifting from capability to reliability. The frontier labs — OpenAI with Codex, Anthropic with Claude Code, the Cursor team — are all shipping agents that can write large blocks of code quickly. The speed of code generation has outpaced the speed of verification. A developer can ask an agent to build a feature in 30 seconds. It takes that same developer five minutes to test it manually. The ratio is getting worse as agents get faster.

TryCase is a bet that verification infrastructure will be the next layer of the AI devtool stack, not a nice-to-have but a gating function. The product fits into a category that includes CI/CD tools like GitHub Actions and testing frameworks like Playwright, but with a different assumption: the agent is the test author and the test executor. The human is the auditor.

The Product Hunt performance — 184 upvotes, 26 comments, #4 on the day — suggests the problem resonates. The comments section on the launch is likely full of developers describing their own verification workflow. The product is early, as Chomsang notes. The documentation at trycase.dev is live. The install path goes through npx skills add bencsn/trycase-skills for Claude, Codex, Cursor, or any agent that supports the skills protocol.

The open question is whether the verification loop can itself be trusted. A disposable environment prevents state pollution between runs, but it does not prevent an agent from producing a recording that looks correct while the underlying code has subtle bugs. The proof is a record of behavior, not a guarantee of correctness. TryCase solves the runtime isolation problem. It does not solve the specification problem — the human still has to know what “correct” looks like.

That said, the product points in a productive direction. The most dangerous thing about current AI coding tools is the false confidence they generate. A developer sees a diff that looks right and ships it. The bug surfaces in production. TryCase replaces that blind trust with a recorded trace. The human still has to watch the video, but watching a video is faster than running the app manually on every branch.

The long-term implication is that agent infrastructure will bifurcate. One stack will optimize for speed of code generation. Another stack will optimize for speed of verification. TryCase is an early entry in the second stack. The bet is that as agents get faster at writing code, the bottleneck will move from generation to testing, and the tools that make testing cheap will define the next generation of developer workflows.

For now, the product is a CLI command and a cloud VM. The idea is that agents should only say done once they have run and verified the work. That is a small rule with large consequences for how teams build software with AI.