JAIPilot — Ship better Java with your coding agent.

JAIPilot helps Codex and Claude Code research maintainer intent, clean, test, review, safely upgrade dependencies and JDKs, and optimize real Java repositories without drifting into unnecessary code or unproved changes.

By default, your agent runs Java builds, tests, analysis, profiling, and benchmarks on a ready remote Java machine whenever the task does not require laptop-only access or state.

JAIPilot does not replace your coding agent or add another AI. It gives your agent focused Java workflows, remote compute, and one rule: show evidence, not confidence.

Further reading: Preventing agent drift: A guide to shipping serious code via vibe-coding explains the engineering principles behind JAIPilot's bounded, evidence-first workflows.

Install and run

Codex

codex mcp add jaipilot --url https://api.jaipilot.com/functions/v1/jaipilot/mcp

Claude Code

/plugin marketplace add JAIPilot/jaipilot
/plugin install jaipilot@jaipilot

Example prompts

Open a Java repository and ask JAIPilot the same way you would ask a teammate. Each example shows the skills JAIPilot selects and why that workflow helps.

Check whether an issue is worth picking up

Prompt

Can you look into issue #184 and tell me whether I should work on it, or if someone is already
handling the same problem?

Skills and flow: jaipilot-maintainer-intent researches the issue, related work, contribution rules, and code history before recommending whether to proceed, join existing work, ask, wait, or stop.

Why it helps: You avoid duplicating another contributor's work or building a fix maintainers are unlikely to accept.

Get a branch ready to merge

Prompt

I've finished the changes on this branch. Can you make sure they're ready to merge?

Skills and flow: jaipilot-optimize-java coordinates bounded cleanup and improvement, jaipilot-generate-tests fills meaningful test gaps, and jaipilot-review-diff reviews the complete result. jaipilot-fast-execution and jaipilot-remote-java accelerate substantial verification when safe and useful.

Why it helps: You get a smaller, reviewed change with missing tests added and the repository's real checks run before handoff.

Upgrade a framework and its dependencies

Prompt

Can you upgrade this Spring Boot service and its outdated dependencies while keeping Java 17
support?

Skills and flow: jaipilot-maintainer-intent first checks repository history, active or prior upgrade work, maintainer direction, and established compatibility constraints. The supported upgrade then uses jaipilot-clean-java to inventory and modernize the requested dependency and build paths. jaipilot-openrewrite is selected only when a repeated type-aware migration justifies it, followed by jaipilot-generate-tests, jaipilot-review-diff, jaipilot-fast-execution, and jaipilot-remote-java as applicable.

Why it helps: The upgrade follows the repository's intended direction and avoids duplicating or conflicting with existing work. Accepted changes remain compatible, reversible, and verified instead of becoming a broad version bump with hidden runtime or transitive-dependency breakage.

Fix a failing dependency-bot update

Prompt

Dependabot's Jackson update is failing CI. Can you figure out why and fix it?

Skills and flow: jaipilot-maintainer-intent checks the bot PR, maintainer direction, related attempts, and the correct delivery path. The supported fix then uses jaipilot-clean-java or jaipilot-openrewrite, followed by jaipilot-generate-tests and jaipilot-review-diff. Substantial commands use jaipilot-fast-execution and jaipilot-remote-java when appropriate.

Why it helps: The agent fixes the actual compatibility problem on the right branch instead of merely forcing the bot's version change through CI.

Add tests for a service change

Prompt

Please add unit tests for my changes to OrderService, especially the validation and error cases.

Skills and flow: jaipilot-generate-tests maps the requested classes and useful cases, creates and executes safely independent test-class work in parallel, and reports fresh configured coverage or mutation evidence. jaipilot-fast-execution and jaipilot-remote-java accelerate the test and verification work when applicable.

Why it helps: You get behavior-focused tests across the complete requested scope, not hollow tests written only to inflate a coverage number.

Simplify a difficult module

Prompt

This payments module has become hard to follow. Can you remove dead code and simplify it without
changing its behavior?

Skills and flow: jaipilot-clean-java proves what can be removed or consolidated and keeps uncertain candidates. jaipilot-generate-tests covers concrete regression gaps, and jaipilot-review-diff checks the final patch. Verification routes through jaipilot-fast-execution and jaipilot-remote-java when useful.

Why it helps: The module becomes easier to maintain without speculative deletion, silent API breakage, or a cleanup that only looks smaller.

Review work before opening a pull request

Prompt

Can you review my current diff before I open a pull request?

Skills and flow: jaipilot-review-diff reads the complete Java and build change, checks behavior, compatibility, unnecessary code, and missing proof, then runs the applicable repository checks via jaipilot-fast-execution and jaipilot-remote-java when appropriate.

Why it helps: You get ranked, evidence-backed findings across the whole change rather than a shallow review of the most obvious file.

Speed up a slow endpoint

Prompt

The /orders endpoint gets slow for large accounts. Can you find the bottleneck and improve it?

Skills and flow: jaipilot-optimize-java bounds the change, jaipilot-clean-java profiles and tests measured hypotheses, jaipilot-generate-tests protects behavior, and jaipilot-review-diff checks the candidate. jaipilot-fast-execution and jaipilot-remote-java provide controlled execution and comparable measurements.

Why it helps: The retained optimization is tied to a real bottleneck and repeatable evidence, not a plausible-looking micro-optimization or one noisy timing.

Run a slow build faster

Prompt

Our full Gradle build takes about 20 minutes. Can you run it faster and tell me where the time goes?

Skills and flow: jaipilot-fast-execution sizes safe batching and native build parallelism for the available resources. jaipilot-remote-java offloads the work when the repository does not need laptop-only services or state.

Why it helps: You reduce wall time without skipping tests, weakening gates, or creating misleading results through unsafe concurrency.

Codex signs in through JAIPilot's OAuth consent and connects to one MCP URL. The server publishes all eight Java skills through skills/list, skills/get, digest-verified resources/read, and standard mcp/skill resources. Codex builds that promote remote skills can load only the selected files and refresh them when their SHA-256 digests change. Other builds use the same server's read-only skill_get fallback, which returns those exact versioned files instead of an older cloud copy. Signing in creates no upload, workspace, or compute, and there is no Codex plugin or local skill-copy installation. Claude Code retains its plugin path.

When remote execution is useful, your agent asks before uploading the current tracked and unignored Git files. Approve the upload; if authentication is not already active, sign in when prompted. The agent handles packaging, integrity checking, upload, execution, logs, and workspace deletion. You do not create an archive, configure a VM, provide an API key, or copy files manually. .git, ignored files, and remote edits are never transferred back automatically.

If packaging or upload cannot be verified, JAIPilot does not create the workspace. Your agent must show the failing step instead of silently uploading a different source tree.

12.2–80.3% faster	61.3–62.5% faster	87.5–92.4% faster	8 → 2 SQL statements
OTel lookup medians	Micrometer merges	Calcite JMH medians	N+1 removed

JAIPilot vs no JAIPilot

The original Petclinic PR already had a green build. JAIPilot reviewed that exact head and produced this companion change:

Metric	Without JAIPilot	With JAIPilot	Outcome
Tests	75	85	+10 tests (+13.3%)
Changed-method line coverage	0/12 (0%)	11/11 (100%)	+100 percentage points
Changed-method branch coverage	0/8 (0%)	8/8 (100%)	+100 percentage points
Owner class line coverage	22/53 (41.5%)	33/51 (64.7%)	+23.2 points with less code
Production change	Unused helper remained	+2/-9 lines	7 net lines removed
Owner methods	16	15	1 unused method removed
Owner complexity	25	24	4% lower
Clean Maven verification	75/75 passed	85/85 passed	Both stayed green

The important result is not simply “more tests.” Without JAIPilot, the build passed while the new behavior had zero coverage and unused code remained. With JAIPilot, the same behavior stayed green, the edge cases became executable tests, and production code became smaller.

The comparison uses the original PR head and JAIPilot's direct child commit, clean worktrees, the same ./mvnw -q clean verify command, and fresh JaCoCo 0.8.14 reports.

Measured performance: Apache Calcite

On skrcode/calcite at exact commit d3a5d8d, JAIPilot profiled Calcite's existing DefaultDirectedGraphBenchmark.removeAllVertices{10,50,90}Benchmark. The 50% workload attributed 31.1% of runnable samples to Collection.removeIf: the implementation scanned the complete global edge set once for every removed vertex.

The candidate changed two files (+28/-5), removed the repeated scans, and added behavior tests for the majority-removal and self-loop paths. Lower JMH scores are better:

Removed vertices	Baseline median (µs/op)	JAIPilot median (µs/op)	Improvement	Baseline p95 (µs/op)	JAIPilot p95 (µs/op)	Improvement
10%	26.710	2.029	92.4%	27.142	2.439	91.0%
50%	74.619	9.140	87.8%	87.245	14.993	82.8%
90%	77.423	9.677	87.5%	89.514	10.052	88.8%

Baseline and candidate ran on the same 4 CPU/8 GiB remote workspace with the same Temurin JDK 17, built JMH jar, command, and workload. Each row contains 21 measured observations: seven forks with three measured iterations per fork after warm-up. The identical focused command passed 15/15 tests before and after the production edit. A fresh exact-SHA :core:clean :core:check then completed 16,644 tests with 0 failures and 155 skips, and the tested remote diff matched the local candidate digest.

This is a controlled result for Calcite's existing graph-removal workloads, not a claim that every Java workload becomes faster.

Measured performance: OpenTelemetry Java

On skrcode/opentelemetry-java at exact commit 35636ae, JAIPilot found that immutable attribute sets were sorted by key name during construction but still used a full linear scan for every lookup. This matters at the default span limit of 128 attributes.

The three-file draft change preserves the small-set and first-four-entry fast path, then uses binary search for the rest. It also adds a large-set behavior test and a repository-native JMH benchmark. Lower values are better:

Lookup	Baseline median (ns/op)	JAIPilot median (ns/op)	Improvement	Baseline p95	JAIPilot p95	Improvement
First	2.483	2.179	12.2%	2.637	2.272	13.8%
Middle	169.124	85.905	49.2%	178.250	88.537	50.3%
Last	346.195	87.323	74.8%	358.321	90.084	74.9%
Missing	141.560	69.552	50.9%	150.321	74.261	50.6%
Last as Value	368.629	72.684	80.3%	387.467	78.087	79.8%

Baseline and candidate ran in the same 4 CPU/8 GiB remote workspace with Temurin JDK 21, the same JMH jar, command, warm-up, and workload. Each row has 21 observations. The new focused behavior test passed before and after the production edit; a clean :api:all:check passed all 147 tasks including Animal Sniffer, Checkstyle, Spotless, tests, and japicmp. The tested remote Git delta matched the local candidate digest. The Value workload still allocates about 16 B/op; JAIPilot reports the lookup-time win without claiming that allocation disappeared.

Measured performance: Micrometer

On skrcode/micrometer at exact commit 22207bf, JAIPilot found that adding or replacing one Tag or KeyValue went through temporary varargs and iterable merge machinery even though the backing arrays were already sorted.

The six-file draft change adds a bounded binary-search merge for the single-value overloads, behavior tests, and four workloads in Micrometer's existing JMH module:

Replacement workload	Baseline median (ns/op)	JAIPilot median (ns/op)	Improvement	Baseline p95	JAIPilot p95	Improvement	Allocation
KeyValues.and	57.941	22.449	61.3%	63.554	23.487	63.0%	136 → 104 B/op
Tags.and	58.968	22.101	62.5%	63.388	24.425	61.5%	136 → 104 B/op

Single-value insertion reduced median allocation by 17.6% and p95 allocation by 46.2%. Its median latency improved by only 6.7–8.9%, below JAIPilot's 10% shared-hardware threshold, so it is not presented as a speed win. The same-workspace experiment used 21 observations per workload; 92 focused tests and the final clean scoped build passed, with 1,132 tests, zero failures, and the remote production diff matching the local digest.

Measured database work: Petclinic

On the current Petclinic JDBC vet listing, JAIPilot found a real N+1 query path: six vets required eight SQL statements (2 + N). It kept the ordered vet query and replaced the per-vet specialty lookups with one joined association query.

Evidence	Baseline	JAIPilot candidate
SQL statements, six vets	8	2
Growth with vet count	2 + N	constant 2
Focused JDBC tests	11/11	15/15
Clean repository build	75/75	79/79

The new tests lock vet ordering, specialty ordering, vets without specialties, duplicate links, shared specialty identity, empty data, and the exact two-statement ceiling. The final clean Maven build and JaCoCo report passed on a 4 CPU/8 GiB remote workspace, and the local and remote binary diff digests matched. This is deterministic query-count evidence; JAIPilot does not turn it into an invented latency claim.

Why teams use JAIPilot

• Less agent drift — changes stay bounded, lean, and aligned with the repository.
• Better Java code — remove proven waste, reduce complexity, improve tests, review risky diffs, and optimize measured bottlenecks.
• Verified modernization — upgrade the JDK, Maven or Gradle wrapper, build plugins, frameworks, BOMs, and direct dependencies to stable compatible versions in isolated, reversible batches.
• Real verification — use the repository's Maven or Gradle build, tests, coverage, architecture rules, and performance measurements.
• Remote-first execution — use disposable hardware with JDK 17, 21, and 25, Maven, and Gradle ready unless private networks, local services, secrets, hardware, or state require the laptop.
• Remote performance lab — profile and compare a bounded optimization on one 4 CPU/8 GiB workspace, with matching patch identity, raw observations, median, p95, and correctness evidence.
• Works on your current change — staged, unstaged, and untracked files can be tested without committing or pushing first.
• Your agent stays in control — Codex or Claude Code chooses every edit and command and reports exactly what JAIPilot achieved.

More proven results

Additional acceptance runs used repository-native verification:

Use case	Result
Optimize Apache Calcite graph removal	Existing JMH workload medians improved by 87.5–92.4% across 10%, 50%, and 90% removal cases; matching behavior tests and a 16,644-test clean check passed.
Optimize OpenTelemetry attribute lookup	Five 128-attribute lookup workloads improved by 12.2–80.3% at median and 13.8–79.8% at p95; clean API compatibility and verification passed.
Optimize Micrometer single-value merges	Replacement merges improved by 61.3–62.5% at median and allocated 23.5% less; sub-threshold insertion latency was not marketed as a speed win.
Cover previously untested behavior	7 focused tests added with no production or dependency change; target coverage moved from 0% to 100% for lines and branches; 82/82 tests passed independently on Java 17 and 21.
Run the current change remotely	An uncommitted file reached the workspace; ./mvnw clean test passed 75/75 tests in 44.6 seconds; job recovery, cancellation, and workspace deletion were verified.
Remove a JDBC N+1 query	Vet listing SQL statements fell from 8 to 2 on the six-vet fixture; 15/15 focused and 79/79 clean-build tests passed, with identical local/remote diff digests.

These are reproducible acceptance results, not claims that every repository will see the same coverage, code reduction, or speed.

MCP Registry

Clients that consume the official MCP Registry can discover io.github.JAIPilot/jaipilot. The one hosted endpoint serves the eight Java engineering skills directly and forwards only tools/list/tools/call to the existing bounded OAuth remote-execution service. Skill discovery and reads do not contact remote execution; tool calls retain its authorization and safety boundary.

Both skill catalogs are paginated five skills and then three so direct clients can load all eight. JAIPilot uses the direct Codex MCP connection above rather than a Codex plugin marketplace.

Included skills

Skill	Outcome
jaipilot-maintainer-intent	Read repository history and choose the right next action.
jaipilot-optimize-java	Make one bounded Java change leaner, safer, and faster.
jaipilot-generate-tests	Add meaningful tests and fresh coverage evidence.
jaipilot-clean-java	Remove waste, enforce architecture, and simplify code.
jaipilot-openrewrite	Apply clean, bounded, verified Java migrations.
jaipilot-review-diff	Find regressions, unnecessary code, and missing proof.
jaipilot-fast-execution	Run substantial Java verification efficiently.
jaipilot-remote-java	Default applicable Java execution to remote hardware.

JAIPilot can work with repository-configured tools such as JaCoCo, PIT, ArchUnit, OpenRewrite, Checkstyle, PMD, SpotBugs, SonarQube, JMH, and JFR. It never weakens a quality gate merely to get a green result.

Remote build beta

The beta permits one active remote workspace. Remote work is disposable and never commits, pushes, or publishes code. JAIPilot defaults applicable Java execution to remote hardware; it stays local when a corporate VPN, private artifact service, internal database, unavailable secret, machine-specific state, or another laptop-only resource is required.

See Security, Privacy, Support, Terms, and the Changelog.

Licensed under the MIT License.