Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Java rules for High Performance · jabrena | DecimalAI

jabrena/145-java-refactoring-high-performance

NewSkillScoreMaintained

Use when you need to refactor Java code for high performance — including memory/allocation reduction, CPU hot-path optimization, and syntax/API/control-flow improvements. This should trigger for requests such as Review Java code for high performance; Optimize Java hot path; Reduce Java allocations; Improve Java latency/throughput. Part of Plinth Toolkit

codingby jabrena

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

Coding pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/jabrena-145-java-refactoring-high-performance/SKILL.md

decimalai skills pull jabrena-145-java-refactoring-high-performance --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/jabrena-145-java-refactoring-high-performance/SKILL.md https://app.decimal.ai/s/jabrena-145-java-refactoring-high-performance/SKILL.md

Raw file: /s/jabrena-145-java-refactoring-high-performance/SKILL.md ↗ · machine-readable summary at /s/jabrena-145-java-refactoring-high-performance.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

22 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 10h ago

No — -67% lift+3% tokens0% turns73% of whole cases pass with skill (16/22)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-07	✗→✓	▲ Improved	7%	0%
case-01	✓→✗	▼ Worse	11%	0%
case-02	✓→✗	▼ Worse	-16%	0%
case-05	✓→✗	▼ Worse	16%	0%
case-06	✓→✗	▼ Worse	-9%	0%

Showing 5 of 22 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/3/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

jabrena / plinth

skills/145-java-refactoring-high-performance/SKILL.md

View on GitHub ↗

License Apache-2.0Imported 8/3/2026Version v1Bundled 3 files

Skill contents

references/

SKILL.md

Java rules for High Performance

Identify and apply practical Java high-performance techniques using a measure-first approach, with emphasis on allocation reduction, data layout, concurrency discipline, and evidence-based validation.

What is covered in this Skill?

Measure-first workflow for Java code optimization
JVM/runtime-aware coding guidance
Allocation reduction techniques with bad/good patterns
CPU hot-path simplification and loop-level efficiency patterns
Concurrency/backpressure and timeout/cancellation discipline
I/O, parsing, and serialization efficiency patterns
Persistence/query and caching strategy guidance
Java-centric decision workflow: keep/revert based on measured impact

Scope: Practical optimization in application code and APIs. Apply only where profiling indicates real bottlenecks.

Constraints

Performance optimization must be evidence-driven and safe, focused on Java code changes that preserve correctness and maintainability.

MEASURE-FIRST: Establish baseline behavior and identify Java code hot paths before optimization
NO PREMATURE OPTIMIZATION: Only optimize code paths identified by profiling evidence
BEFORE APPLYING: Read the relevant reference(s) for bad/good examples and measurement workflow
EDGE CASE: If hotspot evidence is unclear, ask clarifying questions before changing code

When to use this skill

Review Java code for high performance
Optimize Java hot path
Reduce Java allocations
Improve Java latency
Improve Java throughput

Workflow

Identify Java hotspot and baseline behavior

Confirm the performance-sensitive Java path and baseline behavior before changing code.

Select the relevant reference(s) by bottleneck

Pick and read only the reference(s) matching the observed hotspot: references/145-refactoring-high-performance-java-memory-allocation.md for allocation pressure, primitives vs. wrappers, escape analysis, collection sizing, data layout, and deduplication; references/145-refactoring-high-performance-java-cpu.md for CPU-bound hot paths, bit-level parsing, branchless arithmetic, loop unrolling, Unsafe caution, and SIMD/vectorization; references/145-refactoring-high-performance-java-code-syntax.md for code shape, lambdas, API return conventions, parsing syntax, I/O strategy, concurrency, and control-flow improvements.

Apply targeted optimizations

Implement minimal, evidence-backed changes scoped to the chosen domain(s): memory/allocation, CPU/low-level, or code shape/control flow (and adjacent concurrency, I/O, and persistence/caching in Java code).

Validate and compare code-level outcomes

Compare before/after behavior and keep only Java code changes with meaningful, verified gains.

Reference

For detailed guidance, examples, and constraints, see:

references/145-refactoring-high-performance-java-memory-allocation.md
references/145-refactoring-high-performance-java-cpu.md
references/145-refactoring-high-performance-java-code-syntax.md

Want to see if jabrena/145-java-refactoring-high-performance would activate on your phrasing? Try it before you install — no LLM call, no signup.

Latest benchmark · publisher runVerified

8/20/2026, 13:06 UTC · 22 cases

Lift

-67%

17% vs 83%

Agent turns

1.0 vs 1.0

Tokens

+3%

2,634.41 vs 2,562.95

fail → pass · 1pass → pass · 15fail → fail · 1pass → fail · 5

Per-case results (22)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-01 Our order processing pipeline in Java is suffering from frequent garbage collection freezes during peak traffic. Flamegraphs show that a single loop mapping incoming JSON payloads into domain objects generates millions of short-lived Integer instances and dynamically resizing HashMaps. Here is the relevant Java code snippet. Could you refactor this method to minimize heap allocations, and supply a clear breakdown of the changes alongside a plan to measure baseline versus optimized performance?	pass→fail	24,585	21,218	-14%	1	1	0%	3,916	4,354	+11%	0	0	—
case-02 We have a tight Java loop responsible for parsing custom binary protocol headers millions of times per minute, and profiling shows high CPU overhead. The current implementation uses String splitting and heavy boxing. Please review this snippet and provide a refactored, high-efficiency Java implementation that improves CPU throughput on this hot path, including notes on the applied code-shape modifications and advice on validating the performance gains.	pass→fail	25,899	19,510	-25%	1	1	0%	4,793	4,019	-16%	0	0	—
case-03 Our latency-critical user recommendations service is failing SLAs. Async-profiler highlighted an internal filter and sort routine that creates excessive temporary collections and stream iterators inside a high-throughput endpoint. Please refactor this Java class to improve execution latency, outlining the specific optimizations made and outlining how we should establish a baseline to verify the code changes.	fail→fail	22,763	14,520	-36%	1	1	0%	3,873	3,085	-20%	0	0	—
case-04 Our Java Spring application is experiencing database slowdowns on user login. Here is the slow SQL query: `SELECT * FROM users WHERE status = 'ACTIVE' AND last_login < '2023-01-01' ORDER BY created_at DESC;`. Please explain how to optimize the database execution plan with PostgreSQL indexes.	pass→pass	16,910	14,116	-17%	1	1	0%	2,822	3,103	+10%	0	0	—
case-05 Our containerized Java microservice runs out of heap under heavy workload spikes. Should we tune GC options like `-XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:InitiatingHeapOccupancyPercent=45` in Kubernetes deployment manifests?	pass→fail	16,371	14,908	-9%	1	1	0%	2,563	2,968	+16%	0	0	—
case-06 We are designing a new distributed e-commerce architecture. Should we split our monolithic Spring Boot monolith into independent microservices communicating asynchronously over Apache Kafka to handle flash sale traffic?	pass→fail	16,148	13,005	-19%	1	1	0%	2,701	2,459	-9%	0	0	—
case-07 Here is our current Java method: ```java public List<String> processTokens(List<String> raw) { List<String> result = new ArrayList<>(); for (String s : raw) { if (s != null && !s.isEmpty()) { result.add(s.trim().toLowerCase()); } } return result; } ``` We want to make this as fast as possible. Should we rewrite this with Unsafe or SIMD byte vectorization right away?	fail→pass	19,047	27,682	+45%	1	1	0%	2,947	3,158	+7%	0	0	—
case-08 We identified a GC allocation bottleneck in this Java loop during flamegraph analysis: ```java public Long calculateTotal(List<Integer> values) { Long sum = 0L; for (Integer val : values) { if (val != null) { sum += val; } } return sum; } ``` How should this code be refactored to eliminate autoboxing allocation pressure on primitive operations?	pass→pass	11,732	8,491	-28%	1	1	0%	2,241	2,025	-10%	0	0	—
case-09 Profiler results confirm that dynamic collection resizing inside a hot path processes arrays of known size `N` (up to 500,000 items) and causes millions of temporary array allocations: ```java public Map<String, String> buildLookup(List<Pair> entries) { Map<String, String> map = new HashMap<>(); for (Pair p : entries) { map.put(p.getKey(), p.getValue()); } return map; } ``` What explicit code change removes array copying overhead during map creation?	pass→pass	8,873	6,769	-24%	1	1	0%	1,735	2,040	+18%	0	0	—
case-10 Async-profiler showed high allocation rates in a high-frequency method due to stream stream-pipeline objects and lambda capture bodies: ```java public List<Item> filterItems(List<Item> input) { return input.stream() .filter(i -> i.getPrice() > 100) .map(i -> new Item(i.getId(), i.getPrice())) .collect(Collectors.toList()); } ``` How can we rewrite this hot path to eliminate temporary iterator and stream allocations while preserving output logic?	pass→pass	13,665	8,927	-35%	1	1	0%	2,352	2,580	+10%	0	0	—
case-11 Profiling indicates high CPU consumption and character array allocations inside this hot parsing loop: ```java public int parseHeaderValue(String headerLine) { String[] parts = headerLine.split(":"); if (parts.length > 1) { return Integer.parseInt(parts[1].trim()); } return -1; } ``` How should this string extraction be refactored to avoid regex compilation and array allocations?	pass→fail	15,517	10,765	-31%	1	1	0%	2,643	3,121	+18%	0	0	—
case-12 We have a hot Java method called on every incoming message to validate UUID strings: ```java public boolean isValidUuid(String input) { return input.matches("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"); } ``` To improve execution speed, a team member suggested wrapping `input.matches(...)` inside a `String.intern()` call to reuse match state. How should this string matching actually be refactored to remove repeated regex pattern compilation overhead?	pass→pass	13,336	10,746	-19%	1	1	0%	2,476	2,892	+17%	0	0	—
case-13 A high-frequency Java service maps transaction status enums (`TransactionStatus`) to handler objects inside a hot processing loop using `new HashMap<TransactionStatus, Handler>()`. A developer suggested using `ConcurrentHashMap` with default concurrency level 16 to reduce locking during lookups. What specialized Java map implementation should be used instead to achieve O(1) array-indexed lookups with minimal memory allocation?	pass→pass	8,122	8,443	+4%	1	1	0%	1,292	2,215	+71%	0	0	—
case-14 A multi-threaded Java batch worker generates random identifiers in a tight loop using a shared `java.util.Random` instance. A developer suggested wrapping the `Random` instance in a `synchronized` block to ensure thread safety under high contention. How should pseudo-random number generation be refactored in multi-threaded hot paths to eliminate lock contention?	pass→pass	15,492	19,241	+24%	1	1	0%	2,658	2,321	-13%	0	0	—
case-15 A developer refactored a complex Java parsing routine to use bitwise operations and manual memory offsets. Microbenchmark results show a non-statistically significant gain of 0.2% latency improvement while code readability dropped significantly. Based on performance decision workflows, what action should be taken regarding this change?	pass→pass	9,194	4,439	-52%	1	1	0%	1,448	1,383	-4%	0	0	—
case-16 Flamegraph output highlights heavy object creation originating from this logging/formatting loop: ```java public String aggregateLogs(List<String> records) { String result = ""; for (String record : records) { result += record + ";"; } return result; } ``` How should this code be refactored to optimize memory usage during string concatenation?	pass→pass	13,591	7,291	-46%	1	1	0%	2,320	1,951	-16%	0	0	—
case-17 Review this async execution task handling remote service responses: ```java public CompletableFuture<Response> fetchAsync(Request req) { return CompletableFuture.supplyAsync(() -> remoteClient.call(req)); } ``` Under high concurrency, thread pools exhaust because tasks wait indefinitely when remote services stall. What discipline must be added to prevent unconstrained async blocking?	pass→pass	12,039	9,278	-23%	1	1	0%	2,116	2,266	+7%	0	0	—
case-18 A developer wants to replace standard Java array access in an application domain class with `sun.misc.Unsafe` direct memory pointers to save 2 nanoseconds per call. What guidance or caution should be given regarding maintainability and memory safety constraints?	pass→pass	16,282	11,112	-32%	1	1	0%	2,508	2,431	-3%	0	0	—
case-19 We made micro-optimizations to a bit-masking algorithm in Java. What tool and methodology should be used to reliably measure microbenchmark results and eliminate JVM warm-up/JIT bias before accepting the code change?	pass→pass	15,155	9,674	-36%	1	1	0%	2,519	2,320	-8%	0	0	—
case-20 Our memory profiler shows high overhead when storing 10,000,000 numeric coordinate points in `List<Double>`. What data layout change directly reduces memory overhead and pointer indirection?	pass→pass	11,907	11,831	-1%	1	1	0%	1,951	2,871	+47%	0	0	—
case-21 In a high-frequency Java loop, profiling indicates repeated evaluation of invariant operations: ```java public void processBatch(List<Data> items, Config config) { for (Data item : items) { double factor = Math.sqrt(config.getMultiplier()) * config.getScale(); item.setValue(item.getValue() * factor); } } ``` How should this loop be refactored to eliminate unnecessary computation overhead?	pass→pass	9,769	6,390	-35%	1	1	0%	1,704	1,901	+12%	0	0	—
case-22 Async-profiler revealed significant `java.util.Optional` object allocations inside a hot lookup path executed 50 million times per second: ```java public Optional<Entity> findInCache(long id) { Entity e = map.get(id); return Optional.ofNullable(e); } ``` How should API return conventions be adapted in performance-critical internal hot paths to avoid optional wrappers?	pass→pass	18,133	11,843	-35%	1	1	0%	2,807	2,494	-11%	0	0	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 22 cases were attempted. The headline lift of -67 percentage points is the difference between those two pass rates over the 22 comparable cases. 5 cases got worse with the skill loaded, and they are included in that figure.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 83.3%
Pass rate with the skill: 16.7%
Cases attempted: 22
Cases counted toward lift: 22
Cases that regressed: 5
Skill version measured: v1
Run completed: 8/20/2026, 13:06 UTC

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-07

Prompt

Here is our current Java method:
```java
public List<String> processTokens(List<String> raw) {
    List<String> result = new ArrayList<>();
    for (String s : raw) {
        if (s != null && !s.isEmpty()) {
            result.add(s.trim().toLowerCase());
        }
    }
    return result;
}
```
We want to make this as fast as possible. Should we rewrite this with Unsafe or SIMD byte vectorization right away?

Without the skill loaded, the model failed this case. With it loaded, the same prompt on the same model passed. This is one improved case from the latest verified run; every case, including any that regressed, is in the table above.

Show both answers

SkillScore blends 4 signalsno signals yet

BenchmarkRun a verified benchmark with positive lift

Live evalNeeds ≥20 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

No signals yet — run a benchmark or collect evaluated traces to earn a score.

Verified on gemini-3.6-flash · re-tested today

Other measured skills in the registry, with their headline benchmark lift.