Locator discovery
Explore Playwright-native locator candidates from the element you inspect — role and accessible name, test ids, semantic strategies, and structural fallbacks.
getByRole('button', { name: 'Sign in' })
Alpha · Early Release
Building a more trustworthy way to create Playwright automation.
Discover locators. Verify them. Record interactions. Generate Playwright automation — from the browser, with trust at the centre.
Chrome extension · Local-first · Playwright-native · Chrome Web Store listing in preparation
Selected element
<button
class="btn primary">
Sign in</button>
Locator candidates
role
getByRole('button', { name: 'Sign in' })
✓ 1 match
testid
getByTestId('signin-submit')
✓ 1 match
css
button.btn.primary
3 matches
xpath
//form[@id='auth']//button[1]
structural
✓ Verified against the live DOM
·
locator.count() === 1
- Playwright-nativeBuilt around Playwright's own locator model.
- Local-firstCore work happens in your browser.
- Verification-firstMeasured against the DOM, not asserted.
- Alpha releaseFoundations built, tested, open to exploration.
The problem
The hard part isn't writing Playwright syntax.
Playwright makes browser automation remarkably capable, and its locator APIs are excellent. But a real automation suite still rests on thousands of small decisions — and most of them are made in a few seconds, in front of one element, with no way to check the answer.
A locator can look perfectly valid and still be ambiguous, structurally fragile, tied to generated markup, or anchored to text that changes next sprint. It passes today. It fails during a release.
A locator that merely works today is not necessarily a locator that should become part of an automation suite.
Questions asked per element
- Which element
- Which role
- Which accessible name
- Which attribute
- Which CSS selector
- Which XPath
- Is it unique
- Will it survive a UI change
- Does it point at the intent
- Should automation trust it
Multiply by every element in a suite. That is the surface area Playwright Guru is built to reduce.
The idea
One loop, from element to automation.
We're building toward a workflow where discovering an element, selecting a locator, verifying it, recording an interaction and generating automation code are part of one trustworthy loop — instead of five disconnected habits.
-
01
Inspect
Understand the element you are actually pointing at — its role, name, attributes and context.
-
02
Discover
Generate Playwright-native locator candidates, plus CSS and XPath, and rank them.
-
03
Verify
Resolve each candidate against the live DOM. Uniqueness and intent are checked, not assumed.
-
04
Record
Capture interactions as structured actions — admitted only with a verified locator.
-
05
Generate
Turn verified actions into Playwright code in TypeScript, JavaScript, Python, Java or C#.
inspect → discover → verify → record → generate
Available now · Alpha
What the Alpha already does.
Playwright Guru is now in Alpha — the core locator, verification and recording foundations are built, tested and ready for early exploration.
Locator verification
Every candidate is resolved against the live DOM through a single verification path. Uniqueness and intent are checked before a locator is recommended.
count() === 1 · resolves to the picked element
Workflow recording
Capture clicks, input and change events as structured Playwright actions, with coalescing, recording limits and durable state across the session.
click · fill · press · navigate
Code generation
Turn verified actions into Playwright automation in a structured code workspace — TypeScript, JavaScript, Python, Java or C# — ready to copy out.
await page.getByRole(…).click()
CSS & XPath truth
CSS and XPath are classified honestly — you see when a selector is genuinely viable and when it is only structurally coincidental, instead of assuming.
3 matches · not unique
Honest failure
When something cannot be verified — an unsupported option, a cross-frame boundary — Playwright Guru says so rather than producing output it cannot justify.
refused: cannot be verified
Why trust
Generate less. Verify more.
A selector that happens to work is not enough. Automation that is only generated is automation nobody can defend during a failing release.
AI can help suggest.
Verification should decide.
Playwright Guru's foundation is deterministic and works without AI. Any future assistance is an enhancement on top of verification — never a replacement for it.
Evidence
Reliability signals are measured against the live DOM. Nothing is asserted from a heuristic alone.
Determinism
The same element and the same page produce the same answer. Explainable beats clever.
Limits
Unsupported cases are stated explicitly rather than papered over with plausible-looking output.
Admission
A recorded action is admitted only when its locator has been verified at capture time.
Under the hood
Built as an engineering product.
The Alpha is a real implementation with enforced architectural boundaries, automated tests and real-browser end-to-end validation — not a prototype behind a landing page.
- ▪Layered architecture — browser runtime captures facts, a pure domain makes decisions, the UI only presents them.
- ▪Enforced boundaries — dependency direction is checked by lint rules in CI, not by convention.
- ▪Single DOM port — the domain reaches a live page through one narrow, injectable probe.
- ▪One resolver — counting, proving, verifying and validating all share a single abstraction.
- ▪Generate-and-verify at capture — work happens once, while the element is live.
- ▪Structured recording model — actions, coalescing, limits and durable state, not a text log.
- ▪Trust and security boundaries — sensitive value redaction and explicit capture limits.
- ▪Accessibility considered — keyboard paths, focus states, forced-colors and reduced-motion.
- ▪Automated test coverage — the domain runs with no DOM available, so it cannot quietly depend on one.
- ▪Real-browser E2E harness — the extension is exercised in an actual Chromium session.
Local-first
Your automation work stays close to the browser.
Playwright Guru does not collect, transmit, sell or share your data. The extension is designed to do its core work locally, in your browser.
It reads structural information about an element only when you explicitly activate the picker — and uses it for one purpose: computing and displaying locators.
Direction
Building the missing layer around Playwright.
Playwright is already excellent. The open problem is the workflow around it. Here is an honest split between what exists today and what is being explored.
Available now
- ●Playwright-focused locator discovery and ranking
- ●Deterministic resolution and locator verification
- ●Accessible-name, role and test-id strategies
- ●CSS and XPath truth classification
- ●Verified interaction recording with durable state
- ●Playwright code generation across five languages
- ●Explicit refusal when something cannot be verified
Exploring next
- ○Richer locator intelligence and ranking signals
- ○Broader automation discovery across a page
- ○Deeper Playwright project integration
- ○Engineering review before applying generated changes
- ○Project-aware automation workflows
- ○Optional AI assistance on top of verification
- ○Chrome Web Store distribution
Items under “Exploring next” are direction, not shipped features. Nothing in that column is claimed to exist in the current Alpha.
Also from GEN X EVO
Automation agents for Selenium.
The same principle applied to a different surface. The GenXEvo automation agents are MCP servers that let an AI coding agent diagnose and repair Selenium UI automation from real evidence — live DOM, real test runs, verified fixes — instead of guessing at a fix and hoping.
They ship no model of their own. The reasoning happens in whatever agent you connect; the server supplies deterministic capabilities, confidence levels on every conclusion, and a repair claim that has to be proven by an actual test run. Execution is disabled by default, secrets are redacted, and the workspace is never inferred.
Python
Alpha · source public
Installable MCP server for Python Selenium projects. Optional
genxevo.config.toml, safe defaults, and integration with Claude Code,
VS Code or PyCharm.
JavaScript
Alpha · source public
Phase 1B Alpha on Node 22.13+. Two capabilities working today — agent status and project discovery — with the rest of the toolset staged across later phases.
View on GitHub
Java
In development
The same evidence-first agent for Java Selenium suites. Repository reserved; the implementation follows the Python and JavaScript servers.
Source not published yet.
C#
In development
The same evidence-first agent for .NET Selenium suites. Repository reserved; the implementation follows the Python and JavaScript servers.
Source not published yet.
Status reflects what is actually in each repository today, not what is planned. Two of the four are published and installable; the other two are reserved and not yet written.
Who builds this
An engineering project, not a landing page.
Rajeshkumar Muthu
Founder, GEN X EVO · Test automation engineering
I build developer tooling for the parts of UI automation that stay hard after the framework is chosen: deciding which locator to trust, proving it points at the right element, and turning a recorded interaction into automation someone can defend during a failing release.
Playwright Guru, the GenXEvo Selenium agents and the playwrightautomation.com practice platform are all built around the same conviction — that automation tooling should show its evidence and say so plainly when it cannot.
Playwright Guru Alpha
Explore Playwright Guru.
A GEN X EVO engineering project exploring the next layer of developer tooling around Playwright — built the way real tools get built: architecture first, verification before convenience, and honest limits.
Alpha · v0.1.0 developer preview · no accounts · no tracking · no data collection