This article recaps and expands on an in‑depth conversation with Jason Huggins (creator of Selenium) hosted by UltimateQA. In that discussion Jason lays out a bold vision for Vibium AI: a system that learns how your application is actually used, builds a map of workflows, and then generates and runs tests intelligently—more like a self‑driving car with a steering wheel than an autopilot that obliterates human control.
Table of Contents
- Is Selenium obsolete?
- Beyond Selenium: The vision of Vibium AI
- How Vibium AI works: App maps and model‑based testing
- Concrete demo: TestTrack and the 3D chess example
- Developer experience: extension, include, and the dev loop
- Handling flakiness: green, orange, red
- Where Vibium AI fits among browser automation killer apps
- User interface ideas: zoomable maps and live cams
- Jobs and the future of QA with Vibium AI
- FAQ
- Legacy: what Jason hopes Vibium AI will leave behind
- Final thoughts and next steps
If you’re interested in more JavaScript testing tips, click here to subscribe to our newsletter
Is Selenium obsolete?
Short answer from Jason: no. Selenium is very much alive under the hood—it’s the foundation for browser automation that many newer tools still rely on. That said, Selenium has two problems: perception and marketing. It’s been around for two decades, and people often use age as a shorthand for “replace it.” Jason warns that perception can overshadow substance: projects with corporate backing can flood the market with shiny marketing materials, and open source projects like Selenium—without a deep marketing war chest—get unfairly labeled “old.”
Technically, Selenium continues to evolve. The WebDriver BiDirectional protocol (WebDriver Bidi) adopted lessons from tools like Puppeteer and Playwright; it’s baked into modern tooling and modern browsers. Jason points out that some of what people think of as “new” is actually lessons harvested from Selenium’s long history—so yes, Selenium is still “inside” many stacks in visible and invisible ways.
“Selenium is not obsolete because I’m literally depending on it as the base layer for the stuff that I’m working on.”
Beyond Selenium: The vision of Vibium AI
Jason frames Vibium AI using a persisting metaphor: a self‑driving car that still includes a steering wheel. That line captures the product’s core philosophy—automation that doesn’t remove human agency, just reduces repetitive, error‑prone work.
At a low level you could still write traditional tests in libraries—vibm.py, vibe.ts, vbm.js—if you want. At a high level, the platform aspires to do the heavy lifting for you: build the tests, run them, triage failures, and bootstrap more coverage from real usage.
Jason describes three developer archetypes in this emerging age:
- Traditional coders who write code manually.
- Vibe coders who prompt LLMs to write code with minimal direct interaction (the “robot takes the wheel” extreme).
- AI‑assisted engineers who keep one foot in both worlds—using AI to do most work while reviewing and shaping outputs.
Vibium AI targets the middle ground and the extremes: it aims to help the AI‑assisted workflow and make fully automated workflows safer and more testable.
How Vibium AI works: App maps and model‑based testing
The heart of Vibium AI is the idea of an application map: record real user interactions (or dev loop interactions), convert those telemetry events into a model of the app, then use that model to generate intelligent tests and prioritize execution.
Here’s the practical flow Jason describes:
- Instrument the app so important user actions emit events (page visits, button clicks, form submissions, zooms in a 3D view, etc.).
- Aggregate those events (telemetry, analytics, or custom logs) to build a graph representation of the application’s pages and states.
- Feed that graph into an LLM (the “LLM washing machine”) which can reason about workflows like “can a user buy a product?” and synthesize end‑to‑end tests using the recorded paths.
- Run the generated tests and surface results with richer triage that understands when the system had to route around unexpected UI changes.
This is model‑based testing revisited with modern tools. Historically, building the model was expensive and tedious; with LLMs, that barrier drops dramatically. The model lets you move from guesswork (have an LLM poke your site repeatedly trying to “figure out” how to buy something) to reasoned, reproducible execution that leverages real workflows and telemetry.
“By recording all these events, you’re effectively creating a model of your application. Once you have a model, you get automated tests for free.”
Concrete demo: TestTrack and the 3D chess example
Jason created a demo site—testtrack.org—to explore tricky UI scenarios. One module was a 3D chess simulation rendered with three.js. Three.js content and other complex interactive UIs are intentionally hard to test with classical DOM‑centric approaches, so they make a perfect stress test for the Vibium AI approach.
That 3D chess module forced Jason to think about what “testability” means: zooming, clicking, moving pieces, and firing events for every important action. For Vibium AI to interpret interactions, the app must produce structured telemetry about user actions—like “user zoomed to location X” or “piece moved from A3 to B4”. Those semantic events are what let the LLM build workflows from chaotic UI interactions.
The approach is agnostic to whether the UI is a traditional form or a WebGL canvas: as long as the app emits the right events, Vibium AI can map the flow and reason about it.
Developer experience: extension, include, and the dev loop
Jason envisions multiple routes to instrument apps and capture events for the map:
- Browser extension—fast to adopt for developers and QA because it can instrument an app without code changes.
- JavaScript include—a small library embedded in your app that emits events (page, click, type) to Vibium AI. This is more complete but may require approvals and shipping the include as part of the app.
Once instrumentation is in place, Vibium AI can integrate into the dev loop. Imagine your AI co‑pilot (Lovable, Claude Code, or similar) making a change; Vibium AI then:
- Determines the small subset of the app’s map that the change might affect.
- Runs targeted end‑to‑end tests for that neighborhood instead of the entire suite.
- Runs background regression checks on less likely affected areas.
This reduces test runtime and gives developers feedback that’s both fast and relevant—crucial when embracing vibe‑coding style workflows where rapid iteration is the norm.
Handling flakiness: green, orange, red
One of the most recognizable sections of the conversation is Jason’s argument for a three‑color triage system: green, orange, and red. He advocates moving beyond the binary pass/fail mentality and treating flaky, worked‑around test runs as a distinct “orange” state that warrants human attention.
Examples of orange situations include:
- Extra cookie/consent popups that needed to be dismissed programmatically.
- Designer changed a button color or label; the test clicked an alternate control to get through the flow.
- Transient network issues that required retries or alternate routing to reach the expected page.
By recognizing and surfacing these “near misses,” Vibium AI avoids the false optimism of green and the panic of red—Instead it offers a nuanced triage that helps engineering teams decide whether to accept, fix, or investigate.
Where Vibium AI fits among browser automation killer apps
Jason points out three killer apps for browser automation:
- Process automation (RPA style workflows such as approving invoices).
- Data scraping (collecting information from websites).
- Test automation (QA and reliability engineering).
Many big vendors shape generic browser automation capabilities to serve all three needs. Vibium AI focuses tightly on the third: test automation. By concentrating on the unique requirements of tests—modeling application flows, minimizing flakiness, and integrating tightly into dev loops—Vibium AI seeks to outcompete general‑purpose drivers for QA‑specific scenarios.
User interface ideas: zoomable maps and live cams
Jason imagines a slick visual interface where your app’s map becomes something you can zoom, pan, and inspect—much like Google Maps for your application. The UI could overlay production telemetry, show popular user paths, and reveal which workflows have automated test coverage.
He also suggests a split‑screen mode: map view on one side and a live “cam” showing automated browser runs on the other. That visual coupling would make it easy to explain to managers and stakeholders what the automated agents are doing and why certain tests passed, failed, or wound up in orange.
Jobs and the future of QA with Vibium AI
Will Vibium AI kill manual QA jobs in five years? Jason’s answer is a nuanced “no”—jobs will change. The pattern is shifting from manual execution to supervision, orchestration, and higher‑level QA work.
Think of testers becoming conductors or managers of automated agents. They’ll:
- Define expectations and acceptance criteria.
- Interpret orange results and tune models or instrumentation.
- Design experiments and edge‑case tests that agents struggle with.
New roles may emerge too: vibe‑coding cleanup specialists, model engineers for test maps, telemetry engineers who make apps testable, and people who operate the global test networks Vibium AI envisions.
Practical advice: play with vibe‑coding tools today
Jason gives a piece of practical advice for developers: try the tools yourself. Don’t just read about vibe coding—build an app with an LLM‑driven workflow (Cloud Code, Lovable, Claude Code, or similar) and see how long you can go without manually editing code.
His point isn’t to push everyone to the fully autonomous extreme. Rather, the fastest way to develop a grounded opinion—and to see the real risks and benefits—is first‑hand experimentation. Try a few small projects, iterate, then form an informed view about where Vibium AI or similar tools fit in your team’s workflow.
FAQ
Is Selenium dead?
No. Selenium remains a foundational layer for browser automation. Vibium AI builds on modern browser protocols (including WebDriver BiDirectional) and often leaves Selenium “under the hood.”
Will Vibium AI replace QA engineers?
Not entirely. Roles will evolve. Many manual QA tasks will automate, but humans will supervise, triage, and extend the system. Vibium AI aims to shift QA work up the stack, toward modeling, instrumentation, and orchestration.
How does Vibium AI reduce test flakiness?
By building a model of the app and using graph routing, Vibium AI can choose resilient paths and recognize when it needed to use a workaround (the “orange” state). That awareness improves triage and reduces wasted investigation time.
Do I have to add telemetry to my app?
Either instrument the app with a small JS include or use a browser extension to capture events. The more semantic events your app emits, the better the generated models and tests will be.
How does Vibium AI choose which tests to run?
Using the map and graph theory, Vibium AI can compute a neighborhood of impacted nodes for any code change and only run the tests that matter first—saving time while maintaining confidence.
Where can I get involved?
Jason recommends following updates on the project’s site (vibe.ai) and following him on social channels like LinkedIn. Public repos and contribution paths are planned for when the first release is ready.
Legacy: what Jason hopes Vibium AI will leave behind
Jason hopes Vibium AI becomes a practical platform that preserves tester expertise while embracing AI automation. His aspiration isn’t to erase careers built on Selenium and Appium; it’s to give those practitioners modern tools and roles where their knowledge is still valuable—shifted to higher‑impact tasks.
Whether Vibium AI ends up being a brand (like Selenium once was) or a set of practices and tools that get absorbed into the testing ecosystem, Jason wants there to be an economy of work for people who know how to test—and to help them transition into supervising, tuning, and building for the AI era.
Final thoughts and next steps
Vibium AI is an ambitious attempt to reframe testing from brittle scripts to a living map of how applications are used. The central ideas are clear and pragmatic:
- Make your app emit semantic events when important things happen.
- Aggregate those events to build a graph/model of your app’s flows.
- Use large language models to translate that model into targeted, resilient tests.
- Integrate testing into the developer AI loop so that vibe coding and human review are both safe and efficient.
If you want to get involved: follow Jason on LinkedIn, keep an eye on vibe.ai, and be ready to experiment. Vibium AI will need people to test the recorder, validate generated tests, file pull requests, and help shape the visual map experience.
Automation ecosystems don’t change overnight, but Vibium AI points to a future where automated agents and human expertise collaborate in richer, more explainable ways. Whether you’re a traditional test engineer, a vibe coder, or somewhere in between, this approach offers concrete tools and metaphors to navigate the era of AI‑assisted engineering.
Thanks to UltimateQA and the Tech Heartbeat podcast for the conversation that inspired this write‑up. If you found these ideas useful, try a small experiment today: add an event hook to a page and record a user flow—then ask an LLM to generate a test from that trace. It’s a small step toward a map that may change how your team tests forever.
Thank you!