How QPilot Works

Open project settings (⌘,) and point QPilot at your project:

• Project path — Select your project directory, .xcodeproj, or .xcworkspace
• Framework — QPilot auto-detects your test framework (Xcode, Jest, pytest, Go, Flutter, Gradle) or you can set it manually
• Test scheme / destination — For Xcode projects, pick your scheme and simulator. Other frameworks run with their default configurations
• GitHub settings — Repository URL and access token for pushing results
• Slack webhook — Webhook URL for posting run summaries to a channel

QPilot supports multiple projects — switch between them from the sidebar. Configure once, QPilot remembers your settings between sessions.

Hit Run (⌘R) to start your test suite. QPilot launches the appropriate test runner for your framework — xcodebuild test, npx jest, pytest, go test, flutter test, or gradle test — and streams output in real-time.

The sidebar shows a live spinner while tests are running, and updates the pass/fail count as results come in.

When the run completes, QPilot shows a detailed breakdown:

• Summary header — Status icon, total pass/fail/skip counts, and run duration
• Test suites — Collapsible accordion per suite. Failed suites auto-expand so you see problems first
• Failure messages — Extracted from output and shown inline with each failed test. Monospaced, selectable text for easy copy-paste

Use the Run Again button to immediately re-run after making fixes.

When tests fail, QPilot uses Apple Intelligence to analyze the failures. Instead of reading raw stack traces, you get plain English explanations of what went wrong and what to check first.

• Inline explanations — AI analysis appears directly below each failed test with streaming output
• Source context — QPilot reads the failing file at the relevant line number and includes it in the prompt for accurate analysis
• On-demand — Click "Analyze" on any failure to get an explanation
• QA summaries — After a run, QPilot generates a 2-3 paragraph narrative summary of results and pushes it to your repo as qa-summary.md

All analysis runs on-device via Apple's Foundation Models framework — your code never leaves your machine. Requires macOS 26+ with Apple Intelligence enabled.

QPilot can generate tests from your source code using on-device AI:

• Source file selection — Pick any source file from your project via the file picker
• Framework-aware — Generates tests in the correct style for your framework (XCTest, pytest, Jest, Go, Flutter, Gradle)
• Coverage — Produces happy path, edge case, and error state tests
• Auto-save — Generated tests are saved to conventional test paths (__tests__/, test_*.py, *_test.go, etc.)

QPilot can also generate QPad manual checklists from feature specs or design docs — covering navigation, validation, empty states, accessibility, and edge cases — and push them directly to GitHub for QPad import.

Nightwatch is QPilot's file system watcher. Enable it and QPilot monitors your project directory for changes using macOS FSEvents — when you save a file, affected tests re-run automatically.

Nightwatch uses nautical-themed status indicators:

• All Clear — Tests are passing, watching for changes
• On Watch — File changes detected, debouncing before run
• Running — Test execution in progress
• Swab the Deck — New failures detected
• Sailing Blind — New code without test coverage

Framework-aware file filtering ensures only relevant changes trigger runs. DerivedData, build artifacts, and .git are automatically excluded.

QPilot tracks tests that pass and fail inconsistently across runs. After at least two completed runs, the Flakiness view shows:

• Flakiness rate — Failure count divided by total runs, sorted worst-first
• Per-test history — Pass/fail counts for each intermittently failing test

Identify unreliable tests before they become a problem in CI.

QPilot stores your last 50 test runs, newest first. Each run in the sidebar shows:

• Timestamp
• Pass/fail counts
• Status badge (passed, failed, error)

Click any previous run to review its full results, AI analysis, and raw output. Useful for tracking stability and comparing runs before and after changes.

Push test results directly to your GitHub repository after each run:

• Structured JSON results — Test results in qpilot/v1 schema with pass/fail/skip status per test case
• QA summary — AI-generated narrative summary pushed as qa-summary.md
• Run metadata — Date, duration, scheme, framework, and failure details
• CI-friendly — All commits tagged with [skip ci] to prevent loop triggers

QPilot also includes a GitHub Actions workflow you can add to your repo for CI/CD integration.

Results pushed to GitHub are automatically picked up by QPad, which fuzzy-matches failures to your checklist items.

Configure a Slack webhook URL in project settings and QPilot posts a run summary to your channel when tests complete. Your team sees pass/fail counts and failures without leaving Slack.

Click Export to QPad to generate a structured JSON checklist from any test run:

• Each test suite becomes a checklist section
• Each test case becomes a checklist item, pre-marked as Pass or Fail
• Failure messages are included as notes on failed items
• Run metadata (scheme name, timestamp) included in the checklist title

Import the JSON file into QPad for human review and sign-off. QPilot automates. QPad verifies.

QPilot monitors your GitHub repository for manual QA progress from QPad:

• Auto-polling — Checks for QPad progress JSON files every 2 minutes
• Change detection — SHA-based tracking to avoid redundant processing
• Combined summaries — When QPad progress is detected, QPilot generates a merged AI narrative combining automated test results with manual QA findings
• Auto-publish — Updated summary is pushed back to qa-summary.md in your repo

This closes the loop between automated and manual testing — QPilot runs the tests, QPad tracks the manual review, and QPilot synthesizes both into a single summary.

QPilot is actively in development. Here's what's next:

• Deep QPad Integration — Direct SwiftData sync between QPilot and QPad on the same Mac. Bi-directional — mark a QPad item as Fail and QPilot re-runs that test
• Parallel Test Execution — Run tests across multiple simulators simultaneously
• Team Features — Shared workspaces, role separation, and GitHub status check integration