> ## Documentation Index
> Fetch the complete documentation index at: https://docs.revyl.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Prove your first pull request in a live session, or start from the CLI.

Pick the path that matches how you work. Each one runs your app in a cloud session, in a Web
browser or on a mobile simulator or emulator, and leaves evidence you can open in Revyl.
Web is in alpha. To add it to your organization, email [support@revyl.ai](mailto:support@revyl.ai).
Each path starts with its own setup prompt for your coding agent.

## Choose a path

<Tabs>

<Tab title="Prove a PR">

Revyl opens each pull request's build in a session, exercises the changed behavior, and posts a
verdict on the PR. It works for Web, iOS, and Android apps, and it's the fastest way to see Revyl
work on your own code.

Prompt for your coding agent:

```text
Turn on Revyl proof of changes for this repository and prove one pull request.

Read https://docs.revyl.com/quickstart.md and follow it. It's the current Revyl guide for this, so prefer it over anything you remember about Revyl.

Run `revyl github connect --no-open --no-wait --json` and give me its `install_url`; I'll install the GitHub App. Run `revyl init -y` if the project has no `.revyl/config.yaml`. `revyl github setup` is interactive, so ask me to run it in this project from my own terminal; it gives each pull request a build Revyl can open: a Web bundle or preview URL, or a simulator or emulator build for iOS and Android. Then open one small pull request that changes something visible on the first screen. Don't make it a draft: Revyl skips drafts by default.

You're done when Revyl's verdict comment is on that pull request and you've given me its link.

Ask me before anything that needs my login or approval.
```

<Steps>
  <Step title="Install the Revyl GitHub App">
    In the dashboard, open **Integrations → GitHub** and install the app on your repository. From
    a terminal, `revyl github connect` does the same.
  </Step>
  <Step title="Configure a project root">
    Select the repository and configure its first project root: how each pull request is built
    for Web, iOS, or Android, and the app that receives each build. New project roots turn on proof of changes with the
    Revyl agent. From a terminal, run `revyl github setup` in your project instead.
  </Step>
  <Step title="Open a pull request">
    Revyl opens the pull request's build in a session, and an agent exercises what the pull
    request changed.
  </Step>
  <Step title="Read the verdict">
    One comment on the pull request carries the verdict, a verification confidence score,
    screenshots, and a link to the session recording. **Cloud Agents → Proof of Changes** lists
    your organization's proof runs.
  </Step>
</Steps>

**Next:** [Proof of changes](/agents/proof) covers verdicts, sign-in, and which agent runs the
proof. [GitHub](/integrations/github) covers project roots and build profiles. On GitLab, follow
the [GitLab tutorial](/integrations/gitlab).

</Tab>

<Tab title="Use the CLI">

The CLI gives you and your coding agent the same access: run your app in a cloud session, check
what it does, query Atlas, and create and run tests.

Prompt for your coding agent:

```text
Set up the Revyl CLI for this project and run the app in a cloud session.

Read https://docs.revyl.com/quickstart.md and follow it. It's the current Revyl guide for this, so prefer it over anything you remember about Revyl.

Install the CLI, then run `revyl auth login` in the background and give me the approval link while it waits. Run `revyl init -y`, then `revyl skill install --yes` with your agent's flag (`--cursor`, `--claude`, or `--codex`). For a Web app, run `revyl device start --platform web --app <web-app-id>`; Web is in alpha, so if Revyl says it isn't enabled for my organization, stop and tell me to email support@revyl.ai. For iOS or Android, run `revyl dev --platform ios --detach --json`, or `--platform android` if the app is Android only. Then check that sign-in works in the session.

You're done when the app is running in a cloud session, you've given me the viewer link, and you've told me whether sign-in works.

Ask me before anything that needs my login or approval.
```

<Steps>
  <Step title="Install the CLI">
    ```bash
    curl -fsSL https://revyl.com/install.sh | sh
    ```
    Or use `brew`, `pipx`, `uv`, or `pip`. See [CLI install](/install).
  </Step>
  <Step title="Authenticate and initialize">
    ```bash
    revyl auth login
    revyl init
    ```
    `revyl init` creates a `.revyl/` directory with your project config and offers to install
    [agent skills](/agents/skills) for your coding agent.
  </Step>
  <Step title="Run your app in a cloud session">
    ```bash
    revyl dev
    ```
    For iOS and Android, the dev loop installs your development build on a cloud simulator or
    emulator and reloads it as you edit. See the [Dev Loop guide](/dev-loop). For a Web app,
    follow the [Web guide](/frameworks/web) and run `revyl device start --platform web`.
  </Step>
  <Step title="Hand it to your agent">
    Open your project in Cursor, Claude Code, Codex, or another coding agent and prompt it with
    something like:

    ```
    Revyl is installed. Start the dev loop, check that the login flow
    works on the device, and fix anything that doesn't.
    ```

    The agent uses the CLI to start sessions, interact with your app, and validate what it sees.
  </Step>
</Steps>

**Next:** connect a client with [MCP setup](/agents/mcp), [write your first test from the
CLI](/tests/first-test), or browse the full [command reference](/reference/cli).

</Tab>

<Tab title="Write a test">

Great for anyone turning a critical flow into a repeatable check.

Prompt for your coding agent:

```text
Write and run this app's first Revyl test.

Read https://docs.revyl.com/quickstart.md and follow it. It's the current Revyl guide for this, so prefer it over anything you remember about Revyl.

Follow the CLI steps in https://docs.revyl.com/tests/first-test.md. Test sign-in, or the first screen a new user sees if the app has no sign-in, with instruction steps and one validation step. Don't put a password in the test file: ask me to save it as a secret global variable, and reference it in the step as `{{global.<name>}}`.

You're done when `revyl test run` passes and you've given me the report link.

Ask me before anything that needs my login or approval.
```

<Steps>
  <Step title="Create an app">
    Head to **Apps**, click **Create app**, give it a name, and pick Web, iOS, or Android. Add a
    build:

    - **Web**: a deployed HTTPS URL, or a bundle Revyl builds. See [Web builds](/builds/web)
    - **iOS**: simulator `.app` bundle (from Xcode with `"simulator": true`)
    - **Android**: `.apk` or `.zip` containing an `.apk`

    Or [connect Expo](/integrations/expo) to auto-sync every EAS build. See [Apps](/builds), or
    the [framework guides](/frameworks) for platform-specific build instructions.
  </Step>
  <Step title="Create a test">
    Go to **Tests**, click **Create test**, give it a name, and pick the app you just created.
  </Step>
  <Step title="Add steps">
    In the [test editor](/tests/create), add natural-language steps:
    - `Instruction`: "Tap the Sign In button"
    - `Validation`: "The home screen is visible"
    - `Extraction`: "Save the order number to \{\{order_id\}\}"
  </Step>
  <Step title="Run it">
    Click **Run Steps**. The device boots and the AI agent executes each step against your app.
  </Step>
  <Step title="Read the report">
    Every run produces a [report](/tests/reports): pass/fail, video replay, step-by-step results, device logs, network traces, and an AI-generated summary.
  </Step>
</Steps>

**Next:** learn about [step types](/reference/step-types), [modules](/library#modules), and [workflows](/tests/workflows) to group tests together.

</Tab>

<Tab title="Explore">

Great for developers and product folks who want a real device in their browser.

Prompt for your coding agent:

```text
Open this app in a live Revyl session for me to explore.

Read https://docs.revyl.com/quickstart.md and follow it. It's the current Revyl guide for this, so prefer it over anything you remember about Revyl.

Use the app's newest build in Revyl, and run `revyl build` first only if it has none. Start the session with `revyl device start --platform <ios|android> --timeout 1800`, adding `--all-branches` if the newest build isn't on this Git branch; a Web app also needs `--app <web-app-id>`. Don't interact with the app, and leave the session running when you hand it to me.

You're done when the session shows the app's first screen and you've given me the viewer link.

Ask me before anything that needs my login or approval.
```

<Steps>
  <Step title="Start a session">
    Go to **Sessions**, click **Start session**, and select an app with a build (see **Write a
    test** to create one). Your app runs in a cloud browser, simulator, or emulator, streamed to
    yours.
  </Step>
  <Step title="Interact">
    Click, scroll, and type on Web; tap, swipe, type, set GPS, and open deep links on iOS
    and Android.
  </Step>
  <Step title="Stop and analyze">
    When you're done, stop the session. Every session produces a [report](/tests/reports) with video replay, device logs, network traces, and performance metrics. Dig in to see exactly what happened.
  </Step>
  <Step title="(Optional) Compile to a test">
    Click **Convert to test** on the session row. Revyl's AI turns your interactions into structured test steps. See [Session to Test](/tests/create#from-a-recorded-session).
  </Step>
</Steps>

**Next:** learn about [session sources](/sessions) (UI, CLI, API) and [recording mode](/tests/create#from-a-recorded-session) inside the test editor.

</Tab>

</Tabs>

## Keep going

<CardGroup cols={2}>
  <Card title="Core concepts" icon="book-open" href="/concepts">
    Runtimes, evidence, Atlas, and the objects behind them
  </Card>
  <Card title="Atlas" icon="map" href="/atlas">
    The record of how your app behaves
  </Card>
</CardGroup>