User guide

From your docs to executable tests

ShiftTest AI reads your product documentation, asks the questions a senior QA architect would, and generates complete API, UI and E2E test cases — which you export, run locally with Playwright, and track back in the cloud. This guide walks the whole flow.

1. Create your account

Head to the app and sign up with an email and a password (min 8 characters). No credit card is required on the Free plan. You can sign back in anytime — every project, knowledge base, chat and generation run is saved to your account.

2. Create a project

A project is one application (or integration) under test. Click + New project, give it a name, and add a one-line description of what the app does — for example, “A B2B invoicing SaaS with a REST API and a React dashboard.” That description helps the AI frame everything that follows.

3. Add your documentation

Open the Documents tab. You can paste text or upload files (.md .txt .json .yaml .csv .html). Good inputs include:

• API specs (endpoints, request/response fields, error codes, rate limits)
• PRDs and feature docs
• Auth guides (login/OTP flows, token lifetimes, roles)
• UI workflow / user-journey docs
• Data contracts and field mappings

4. Analyze → build the knowledge base

Click Analyze → build KB. ShiftTest chunks and reads every document, then synthesizes a structured Integration Knowledge Base: an overview, an API endpoint inventory, data contracts, an authentication matrix, UI workflows, rate limits, iframe-heavy areas — and a list of Open Questions (every gap a tester would need answered). Large doc sets take a couple of minutes; the page refreshes itself when the KB is ready.

5. Close the gaps in chat

Open the AI Assistant tab. It answers questions grounded strictly in your knowledge base, and — when something is missing or ambiguous — asks you one focused question at a time (drawn from the Open Questions). Answer with the real details: staging credentials, exact status codes, rate limits, business rules. Every answer is saved and folded into the test cases you generate next.

6. Generate test cases

On the Test Cases & History tab, choose the scope — any of API, UI, E2E, and whether to include negative paths — then click ⚡ Generate test cases. ShiftTest discovers the feature modules by risk, then writes self-contained cases for each. Every case has:

• A stable ID (TC-MODULE-001), type, priority (P1–P3) and an AI_EXECUTABLE / MANUAL tag
• Atomic, tagged steps — [NAVIGATE][FILL][API][ASSERT] — so each line maps to one action
• Objective, preconditions, expected result and test data (with {ENV.BASE_URL}-style placeholders)

Every run is versioned and kept forever, so you can regenerate as your docs evolve and compare.

7. Export

From any completed run, export in the format you need:

• Markdown — for review and sharing
• CSV — to import into a test-management tool (one row per case)
• Playwright .spec.ts — a deterministic skeleton with a test() per case and every step scaffolded, ready for you to fill in real selectors

8. Run locally, track in the cloud

Tests run in your environment; results sync back to your dashboard. Create a token under API & CLI, then:

curl -sO https://shift.aiskillhub.info/shifttest-cli.mjs
export SHIFTTEST_TOKEN=stk_...
node shifttest-cli.mjs pull --project <id>        # spec + md + csv into your repo
npx playwright test --reporter=json > report.json || true
node shifttest-cli.mjs report --project <id> --run <id> --file report.json

Edit the Playwright code as much as you like before running. After report, the run’s Local execution results panel shows pass/fail stats and per-test detail with errors — a full execution history per run.

Plans & limits

	Free	Pro — $19/mo
Projects	2	25
Documents / project	8 (≤400 KB)	40 (≤2 MB)
AI operations / day	30	300
Modules / generation	5	15

Tips for great test cases

• Feed specifics. Endpoint paths, field names, status codes and rate limits turn into concrete assertions.
• Answer the Open Questions. Each answered gap removes a MANUAL tag and sharpens coverage.
• Split huge docs into focused files (auth, API, workflows) — cleaner modules, better prioritization.
• Regenerate after your docs change; runs are versioned so you never lose earlier work.
• Start with API scope for the fastest, most deterministic wins, then layer in UI and E2E.