AI
Scout
Playwright Setup Specialist
Boots a clean, correctly-configured Playwright project in any workspace, so every later agent has solid ground to build on.
Dino turns one click into tested software. Point it at a URL or a Gherkin feature file and the agent writes scenarios, builds Page Object Models, generates Playwright specs, and heals broken tests, streamed live, on your machine.
Every prompt runs a complete agent session: it plans, calls tools (bash, read, write), and streams each step into the output panel. Fill in a URL or a path, hit ▶ Run, watch it work.
Stand up a vanilla Playwright project in your workspace: config, folders, and a passing smoke test in a single run.
Point it at any URL. Dino explores the flows and writes reviewable Gherkin feature files before a line of code exists.
Drives playwright-cli against your live app and generates typed POMs (locators, actions, waits), ready to reuse in specs.
Takes your existing feature files and generates runnable Playwright specs with step definitions wired to your page objects.
Reads the failed run, diagnoses stale selectors and timing issues, rewrites the tests, and re-verifies them automatically.
Streamed output, live tool-call logs, token usage, and one-click Stop. Interrupt any agent mid-run and take the wheel.
Not just the built-ins. Dino surfaces every prompt your Dino server exposes. Custom workflows show up in the sidebar the moment you add them.
Each prompt is a specialist. Chain them into a pipeline (scenario → page objects → specs → heal), or run them standalone wherever your testing hurts.
Boots a clean, correctly-configured Playwright project in any workspace, so every later agent has solid ground to build on.
Explores your live app end to end and drafts business-readable Gherkin scenarios your team can review before any code is written.
Drives the browser via playwright-cli, maps every screen, and writes maintainable Page Object Models with resilient locators.
Converts Gherkin features into executable Playwright specs: step definitions, fixtures, and assertions wired to your POMs.
Triage for your red builds: reads failures, pinpoints brittle selectors and race conditions, rewrites the tests, verifies the fix.
Every agent works through real tools (bash, read, write), with each call logged live in the tool panel. Nothing happens hidden.
Keyboard traps, focus order, ARIA labels, contrast: flows are probed the way a screen-reader or keyboard-only user actually experiences them.
Attacks your flows from the outside in (broken auth, injection points, privilege escalation) and turns every gap into an explicit, testable scenario.
Walks each feature against its acceptance criteria, covering the golden path and the edge cases nobody wrote down.
Asserts budgets on load time, render jank, and response latency, so slow regressions fail loudly instead of shipping quietly.
Journeys through the app as a first-time user, flagging confusing flows, dead ends, and friction before your users find them.
Verifies behavior across browsers, viewports, and OS combos, so one engine's quirk never reaches production untested.
Exercises endpoints and integrations end to end (status codes, schemas, payloads), catching contract drift between systems.
Checks what survives the round-trip (creates, updates, deletes, migrations), so records stay consistent from UI to database.
Runs scenarios per locale (translated strings, dates, numbers, currencies, RTL layouts), so no hardcoded copy escapes.
Replays the suite after every change, guarding old behavior while new code lands. A red build means something actually broke.
Pick a provider, paste your API key, hit ↻ Load Models, and choose the model for every run. Credentials live in your local Electron settings, forwarded per request, never written to the server.
Runs against your Dino API server (default localhost:4003). Tests, POMs, and features are written straight into your project workspace.
Dino generates idiomatic, reviewable code, not a proprietary format. Everything lands in your repo, ready for your pipeline.
Runnable specs with fixtures, locators, and assertions that follow current Playwright conventions out of the box.
Scenarios map one-to-one to executable steps, so product, QA, and engineering finally review the same artifact.
Structured page objects with resilient selectors: no flattened helpers, no copy-pasted locators drifting between specs.
Output is plain files in your repo. Run it in GitHub Actions, Jenkins, or wherever your build already lives.
The industry runs on one promise: AI-first, with a human in the loop to catch what it misses. We look at that landscape differently. At AssertRx, we believe software is made by people, so the human leads and the AI amplifies. You set the direction and make the judgment calls; Dino's agents do the tireless work beside you, drafting scenarios, running tests, and healing what breaks. Not AI-first with a human standing by. Human-first, with AI in the loop.
bash, read, write), and streams results live,
from scaffolding Playwright projects to generating Gherkin scenarios, Page Object Models, executable
specs, and healing failed tests.
↻ Load Models, and pick a model. Your choice is sent with every run. If you skip the key,
the server uses whatever credentials it already has configured.
/generate-spec-from-feature takes the feature files you already have and turns them into
Playwright specs wired to your page objects. No migration, no re-authoring.
/heal-playwright-failures after a red build. The agent reads the failure output, identifies
stale selectors, missing waits, and broken flows, rewrites the affected tests, and re-runs them to verify
the fix, all streamed so you can review every change it makes.