Techvify Forge QA · AI-Powered Test Automation
Forge production-ready tests from a sentence.
Describe what matters. Let AI handle the rest. From web applications to mobile experiences, the platform understands user journeys, validates critical functionality, and continuously adapts as your product evolves.
- 12
- AI specialists
- 11
- Commands
- 4
- Kinds of screen
Watch the workflow walkthrough
The recorded end-to-end run — spec, to a generated suite, to a passing report — is open to Techvify users and invited guests.
What's inside
A team of specialists, eleven commands.
A team of 12 AI specialists
Each agent has one job — read the app, draft the tests, run them, fix broken ones, and review the result. They work in parallel and hand off cleanly, so nothing waits.
11 commands cover the full workflow
Setup, login capture, requirement pull, test creation, healing, status, reporting — one command for each. The same commands work for web and mobile, so your team learns it once.
Web AND mobile, side by side
Real browsers for websites. Real devices and simulators for mobile apps — native screens, embedded web content, or a mix of both. The platform picks the right path automatically.
Tests that fix themselves
When the app's screen changes, tests adapt and retry on the fly. You ship features faster; the test suite catches up on its own — no one rewrites locators by hand.
Reads requirements from where they live
Connects to your docs tool and your work tracker to pull acceptance criteria — no copy-paste. Drafts test scenarios in plain English before any code is written.
A senior reviewer in the loop
Every run ends with a clear visual report ready for human sign-off. AI handles the work; your senior QA keeps the final quality gate.
Supported targets
One framework. Four kinds of screen.
Web on browser automation. Mobile on device automation. WebView and hybrid pick up the right driver and the right context automatically — you only ever type one command.
Web app
Any URL. The agent opens a real browser, snapshots the DOM, and writes the tests.
Browser automation + BDD
Native mobile
Pure native Android / iOS. The agent inspects the live UI hierarchy on a real device.
Device automation
WebView mobile
A mobile app that wraps a single web view. Agent attaches the WebView context.
Device automation · WebView context
Hybrid mobile
Mixed native + WebView screens. Agent switches contexts as the flow demands.
Device automation · native + WebView
The pipeline
Six phases, end to end.
Each phase has a clear input, a clear output, and a named owner. One phase fails to converge after three cycles — the framework stops on its own and asks a human.
Input & setup
Probe optional tools, read the last 20 run-log rows, acquire a per-module lock, load any pre-baked app knowledge, and decide platform / coverage / mode (dom-driven vs spec-driven).
- Planner
Generate test artifacts · parallel
In parallel: write the Gherkin feature file from the live UI, scan the live DOM (or device UI hierarchy) and write Page Object classes plus locator files.
- FeatureGenerator
- PomGenerator
- MobilePomGenerator
Bind Gherkin to page objects
Write the step-definition file that connects each Gherkin step to a Page Object method. Compile errors here trigger a regeneration of the page objects.
- StepsGenerator
Execute + auto-heal
Run the suite. Classify each failure — broken selector, compile error, or timeout. A broken selector goes to the healer (one retry); compile errors regenerate the step definitions; three stuck cycles escalate to a human.
- TestRunner
- MobileTestRunner
- SelectorHealer
- MobileSelectorHealer
Review & commit
A named QA lead produces a numbered review menu — Fix all Critical+High / Fix specific findings / Approve / Reject. The human reply gates the GitCommitter, which never pushes — only commits locally.
- a named QA lead
- GitCommitter
Cleanup
Release the per-module lock, append the run history to the module spec, return control.
- Planner
Auto-heal loop
What happens when a test breaks.
Most flakes come from selectors going stale after a refactor. The framework classifies every failure first, then routes it.
selector_issue
The element used to be there; the locator no longer matches.
→ SelectorHealer re-inspects the DOM and rewrites the locators. Max one retry, then escalate.
compile_error
A Page Object method changed shape; the step definition no longer compiles.
→ StepsGenerator regenerates from the current Page Objects. Max one regen, then escalate.
timeout / unknown
A test hangs or fails for a reason the classifier can't recognise.
→ A named QA lead opens it in failure-diagnosis mode. The human decides next.
Stuck three cycles in a row? The pipeline pauses on its own, posts the diagnostic context, and waits for a human. No silent infinite loops, no silent skipped scenarios.
Human checkpoints
The agents propose. The human disposes.
Nothing ships from a green run without an explicit review, and nothing reaches version control without an explicit yes.
a named QA leadMandatory
- 1. Fix all Critical + High findings
- 2. Fix specific findings (e.g. "2 F1 F3")
- 3. Approve as-is
- 4. Reject and abandon
Reply:
GitCommitterOnly after yes
- Single squash-friendly commit per run
- Includes feature, page objects, locators, steps, spec
- Append-only run history in the run log
- Never pushes to a remote — that is your call
The roster
One orchestrator. Eleven specialists.
Every agent is a markdown prompt with explicit tool access.
- PlannerOrchestrator
- The orchestrator. Drives the entire pipeline, manages the retry loop, enforces module scope, holds the lock.
- Analyzerdom-driven
- Opens the page and infers acceptance criteria when no spec exists. Skipped when a spec is provided.
- FeatureGenerator
- Writes the Gherkin feature file. Opens the browser to verify exact label wording so scenarios match what users actually see.
- PomGenerator
- Scans the live DOM, writes Page Object classes plus locator files. Output is type-safe and test-only.
- MobilePomGenerator
- Same role for mobile — inspects the XML UI hierarchy on a real device and produces mobile Page Objects.
- StepsGenerator
- Binds each Gherkin step to a Page Object method. The glue layer — keeps scenarios readable and tests executable.
- TestRunner
- Executes the suite. Classifies every failure and appends a row to the run log.
- MobileTestRunner
- Same role for mobile — runs the device suite. Same failure-classification model.
- SelectorHealer
- Re-inspects the DOM around a broken selector and rewrites the locator. One retry max — beyond that, escalate.
- MobileSelectorHealer
- Same for mobile — on-device UI inspection and locator rewriting.
- a named QA lead
- The only mandatory human checkpoint. Post-test review menu, or failure diagnosis when stuck.
- GitCommitter
- Creates the local git commit only after the human approves. Never pushes — the human owns the push.
Every command, what it does.
One command per job — start a run against a web page or a device, author the spec first, heal flaky locators, check what is covered, and publish the report. The full reference lives in the guidebook.
Open the command referenceSetup steps live in the guidebook.
The guidebook carries the current install and configuration steps for every kit, kept in one place so they stay accurate. Open to Techvify users and invited guests.
Open the guidebookStart
Gate your next release.
Bring one application and its next release. On a scoping call we agree what each dimension checks, what fails the run and who signs, before any work starts.