5× faster than testing with a regular coding agent.
Enterprise grade quality unit tests. A 90% line coverage target.
Generate tests · Improve coverage · Fix failing tests
Stabilize flaky tests · Test current changes · Lock existing behavior
Download CLI · Get started · JAIPilot.com
One command. Two Kafka classes. 34.3% → 97.1% line coverage in 1 minute 53 seconds. The run added 13 tests covering behavior, equality, lock handling, and exception paths. All 949 tests in the server-common module passed; production code was unchanged.
Recorded directly from macOS Terminal with JAIPilot CLI. The GIF shortens idle waits.
Run the same workflow
After installing and signing in, run inside an Apache Kafka checkout:
jaipilot run improve_coverage \
--class org.apache.kafka.server.util.Deadline \
--class org.apache.kafka.server.util.LockUtilsThis recording used a development build, Kafka commit adf8c4c, JDK 25, and a warm Gradle dependency cache. Coverage measures the two selected classes (12/35 → 34/35 lines). A fresh module test run, JaCoCo report, Checkstyle, and Spotless independently confirmed the result. Runtime and coverage vary by project.
JAIPilot is a fast, high coverage testing agent for Java, optimized for the testing outcome you choose. Choose an outcome. Select your code. Get verified tests. Each outcome guides how JAIPilot plans, writes, repairs, and verifies your tests using your project's existing build and test framework.
Long waits. Repeated prompts. More test code to maintain, while important scenarios still slip through. If that is your experience asking a general coding agent to write tests, JAIPilot gives Java testing a clear finish line.
- Focus on the scenarios that matter. Generate tests for behavior, boundaries, and failure paths with meaningful assertions. Aim for focused, maintainable tests that protect your code.
- Let the agent carry the task through. JAIPilot plans, writes, repairs, and verifies the tests. Focused checks and a final regression suite provide evidence for the outcome.
- 5× faster than testing with a regular coding agent. Run one command to generate tests, verify them locally, and measure coverage.
- See the coverage you gained. JAIPilot targets at least 90% line coverage in your selected production scope when coverage tooling is configured. It reports fresh measurements and concrete blockers.
Use the whole repository, a list of classes, paths, or selected lines. Builds, tests, and coverage reporting run on your computer. Sign in with your existing JAIPilot account and use the same subscription and credits.
Requirements: Git, a JDK, and your project's Maven, Gradle, or other Java build tools.
On macOS or Linux, install with one command:
curl -fsSL https://raw.githubusercontent.com/JAIPilot/jaipilot/main/install.sh | shThe installer detects your OS and CPU, verifies the release's SHA-256 checksum, and installs
jaipilot into ~/.local/bin. If that directory is not on your PATH, add this to your shell profile:
export PATH="$HOME/.local/bin:$PATH"On Windows, download the Windows executable,
rename it to jaipilot.exe, and put it in a directory on your PATH.
Sign in and run inside your Java repository:
jaipilot auth login
jaipilot run improve_coverage --class com.acme.OrderServiceSign-in opens jaipilot.com and uses the same JAIPilot account, subscription, and credits as the IntelliJ distribution.
Before run and workflows, the CLI checks for a newer stable GitHub release. When one is available,
it downloads the matching binary, verifies its checksum and version, installs it, and restarts with
your original arguments. Failed checks or downloads leave the current installation usable and the
requested command continues. Help, version, and account commands do not check for updates.
jaipilot update # Install the latest stable release now
jaipilot update --check # Check without installing
JAIPILOT_NO_UPDATE=1 jaipilot run improve_coverage --class com.acme.OrderServiceThe installer can also upgrade or repair an existing installation. To choose a directory or pin a release:
curl -fsSL https://raw.githubusercontent.com/JAIPilot/jaipilot/main/install.sh | \
JAIPILOT_INSTALL_DIR="$HOME/bin" JAIPILOT_VERSION=v1.0.0 shUpdates leave your Java repositories untouched. Downloads require internet access and write access to the CLI's installation directory.
jaipilot workflows
jaipilot run improve_coverage --all
jaipilot run generate_tests --class com.acme.OrderService --class com.acme.InvoiceService
jaipilot run stabilize_flaky_tests --path src/test/java/com/acme/OrderServiceTest.java
jaipilot run improve_coverage --selection src/main/java/com/acme/OrderService.java:42-88Run these commands inside a Git repository, or add --repo /path/to/repository. You can repeat --path, --class, or --selection to supply a list. Use exactly one scope type per run:
| Scope | Example | Meaning |
|---|---|---|
| Entire repository | --all |
Discover the Java source and tests across the repository. |
| Paths | --path module/src/main/java |
One or more files or directories. |
| Classes | --class com.acme.OrderService |
One or more Java classes; simple names work when unambiguous. |
| Selections | --selection path/File.java:42-88 |
One or more line ranges, verified in their containing classes. |
| Outcome | Workflow |
|---|---|
| Create focused tests and verify them | generate_tests |
| Measure coverage and close meaningful gaps | improve_coverage |
| Repair failing tests and rerun the suite | fix_tests |
| Reproduce and stabilize flaky tests | stabilize_flaky_tests |
| Test behavior changed in your current Git diff | test_current_changes |
| Capture existing behavior before refactoring | lock_behavior |
The agent uses your existing build and test framework. It is instructed to preserve production code and unrelated edits, runs focused tests and the final suite, and reports fresh coverage when configured. If coverage tooling is absent, it reports that plainly.
Use --json for structured results in scripts:
jaipilot run improve_coverage --class com.acme.OrderService --jsonExit codes are 0 for a completed workflow, 2 for a concrete blocker, and 1 for a CLI or service error. Review the result and git diff before accepting changes. Repository-wide work may consume more credits than a focused class run.
| Selected classes | Time | Line / branch coverage | Full suite |
|---|---|---|---|
| 1 | 62 seconds | 100% / 100% | 83 passing tests |
| 2 | 67 seconds | 100% / 100% | 85 passing tests |
| 5 | 126 seconds | 100% / 100% | 95 passing tests |
Each run began from the same clean Petclinic commit using Java 17 and a warm Maven dependency cache. Fresh clean builds independently confirmed the results. Only test files changed. Runtime and coverage vary by project; quantifying a 5× speedup requires a controlled sequential comparison.
Your refreshable sign-in is stored locally with user-only file permissions. Workflow requests send selected paths, project metadata, and local command output to JAIPilot's managed service and model provider. Parallel class work can also upload selected source and related test/build context to a private job tied to your account.
Commands, builds, and tests run locally with your user permissions. Review the result and git diff before accepting changes. Keep credentials, private source, and unredacted logs out of public issues.
Ask a question · Report an issue · Report a vulnerability privately
For issues, include your CLI version, OS, JDK, build tool, workflow, and sanitized output.