More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Kafka Spring Production Reviewer: Lost & Duplicate Messages

    1

    The listener hands work to a thread pool and returns, so the offset commits before the database write.

    $12

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Kafka Spring Production Reviewer: Lost & Duplicate Messages

    Example session with this skill installed

    We go live with this payments consumer next week. Spring Boot 3.3, Java 21, Kafka 3.7, PostgreSQL. Review it for production problems before we ship.

    PaymentEventsListener.java

    @Service
    public class PaymentEventsListener {
    
        private static final Logger log = LoggerFactory.getLogger(PaymentEventsListener.class);
    
        private final PaymentRepository payments;
        private final LedgerClient ledger;
        private final KafkaTemplate<String, PaymentSettled> kafka;
        private final ExecutorService workers = Executors.newVirtualThreadPerTaskExecutor();
    
        public PaymentEventsListener(PaymentRepository payments, LedgerClient ledger,
                                     KafkaTemplate<String, PaymentSettled> kafka) {
            this.payments = payments;
            this.ledger = ledger;
            this.kafka = kafka;
        }
    
        @KafkaListener(topics = "payments", groupId = "ledger-sync", concurrency = "6")
        public void onPayment(PaymentEvent event) {
            workers.submit(() -> handle(event));   // virtual threads, so this scales
        }
    
        @Transactional
        void handle(PaymentEvent event) {
            try {
                Payment payment = payments.save(Payment.from(event));
                ledger.post(payment);
                kafka.send("payments-settled", payment.getId().toString(), PaymentSettled.of(payment));
            } catch (Exception e) {
                log.error("payment {} failed", event.getPaymentId(), e);
            }
        }
    }
    

    LedgerClient.java

    @Component
    public class LedgerClient {
    
        private final RestClient http;
        private String accessToken;
        private Instant expiresAt = Instant.EPOCH;
    
        public LedgerClient(RestClient.Builder builder) {
            this.http = builder.baseUrl("https://ledger.internal").build();
        }
    
        public void post(Payment payment) {
            http.post().uri("/entries")
                .header("Authorization", "Bearer " + currentToken())
                .body(LedgerEntry.of(payment))
                .retrieve()
                .toBodilessEntity();
        }
    
        private synchronized String currentToken() {
            if (Instant.now().isAfter(expiresAt)) {
                TokenResponse t = http.post().uri("/oauth/token").retrieve().body(TokenResponse.class);
                accessToken = t.value();
                expiresAt = Instant.now().plusSeconds(t.expiresIn() - 30);
            }
            return accessToken;
        }
    }
    

    application.yml

    spring:
      threads:
        virtual:
          enabled: true
      kafka:
        bootstrap-servers: kafka-1:9092,kafka-2:9092,kafka-3:9092
        consumer:
          enable-auto-commit: true
          auto-offset-reset: latest
          key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
          value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
          properties:
            spring.json.trusted.packages: "*"
        producer:
          acks: 1
          value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
    
    • Read your context and instructions
    • Compiled the kafka spring production
    1. Verdict

    Don't ship this as written. The worst problem is that the Kafka offset for a payment is committed before the payment has been processed, and any exception is caught and only logged. So a normal deploy, a restart, or a brief ledger outage loses payments, and the only trace is a log line.

    Versions reviewed against: Spring Boot 3.3, spring-kafka 3.2, kafka-clients 3.7, running on JDK 21 (the virtual-thread pinning in finding 6 depends on that).

    2. Findings
    1. [Critical] Offsets are committed before the payment is processed

    Where: PaymentEventsListener.java, onPayment: workers.submit(() -> handle(event)); application.yml: enable-auto-commit: true

    What happens: there are two independent causes, and each one is enough to lose payments.

    1. onPayment hands the record to a virtual thread and returns at once. The container treats the record as done.
    2. enable-auto-commit: true makes the Kafka client commit offsets every 5 s during poll(), whether or not any work finished. This setting also overrides spring-kafka's own commit handling.

    Step by step: the pod receives SIGTERM during a deploy. The worker tasks that are still queued or running are dropped, and their offsets are already committed. The new pod starts after those offsets, so those payments are never saved or posted to the ledger, and nobody is told.

    The same hand-off causes three more problems:

    • Exceptions in the task never reach a Kafka error handler.
    • Two events for the same payment can run at the same time, so their order is not kept.
    • There is no limit on concurrency. A backlog creates thousands of virtual threads competing for 10 Hikari connections, so save() calls time out, and finding 2 then drops those payments too.

    Fix: do the work on the listener thread and delete the executor. Remove enable-auto-commit, so spring-kafka commits after the listener returns. Virtual threads don't add parallelism here: throughput comes from the number of partitions and concurrency.

    @KafkaListener(topics = "payments", groupId = "ledger-sync", concurrency = "6")
    public void onPayment(PaymentEvent event) {
        handler.handle(event);   // separate bean, see finding 4; throws on failure
    }
    

    Verify: an integration test with Testcontainers Kafka. Publish 1,000 events, stop the container partway through, start it again, and assert 1,000 payment rows.

    2. [Critical] Failures are swallowed and there is no dead-letter topic

    Where: PaymentEventsListener.java, handle: catch (Exception e) { log.error(...) }; no CommonErrorHandler bean

    What happens: the ledger returns a 503 for 30 s, or the database refuses a connection. Every payment in that window is logged and treated as succeeded, and none is retried. Even if the catch is removed, spring-kafka's default error handler tries 10 times with no pause and then only logs the record and skips it.

    Fix: remove the catch. Add a DefaultErrorHandler with back-off and a DeadLetterPublishingRecoverer, and declare payments.DLT with at least as many partitions as payments (full code in section 5). Set up an alert on any traffic to the DLT.

    Verify: stub the ledger to return 503 three times, then 200. Assert that the payment is posted once and nothing goes to the DLT. Then stub a 400 and assert the record lands on payments.DLT with the kafka_dlt-exception-* headers.

    3. [High] Redelivered events save the payment twice and post to the ledger twice

    Where: PaymentEventsListener.java, handle: payments.save(Payment.from(event)) and ledger.post(payment)

    What happens: once findings 1 and 2 are fixed, delivery is at-least-once, so redeliveries become routine. They happen on a rebalance, on a retry after the ledger call has already succeeded, or after a crash before the commit. Nothing checks whether an event was already processed. The second delivery inserts another Payment (if Payment.from generates the ID) and posts a second ledger entry. That moves money twice, so this is a duplicate that counts as data loss.

    Fix: two parts.

    • Record a dedupe row in the same database transaction as the payment insert, keyed on a stable event ID: INSERT ... ON CONFLICT DO NOTHING, then skip the event if no row was inserted.
    • Send the ledger an idempotency key derived from the event, such as Idempotency-Key: payment-<eventId>. That covers the case where the ledger call succeeds but the database commit fails.

    Code is in section 5.

    Verify: publish the same event twice. Assert one payment row, one ledger call (WireMock), and one payments-settled record.

    4. [High] @Transactional never applies, and the Kafka send is an unprotected second write

    Where: PaymentEventsListener.java, handle: @Transactional void handle(...) and kafka.send("payments-settled", ...)

    What happens

    The transaction does nothing. handle is called from a lambda inside the same class (this.handle), on another thread, and it isn't public. Spring's transaction proxy only applies when the method is called through the bean from outside the class. So there is no transaction: save() commits on its own. If ledger.post then fails, a payment row exists with no ledger entry.

    The Kafka send can be lost. kafka.send(...) returns a future that nobody checks. If the broker is unreachable past delivery.timeout.ms, or the pod dies before the send is flushed, the ledger has the entry but the payments-settled event is never published. A real transaction wouldn't fix this either, because the database commit and the Kafka send are two separate writes that can't be made atomic.

    Fix: move handle into its own @Component with a public @Transactional method. Write the PaymentSettled event to an outbox table in that same transaction, and publish it with a relay that marks a row as sent only after the broker acknowledges it.

    Verify: make the outbox insert or the commit fail after save(). Assert there is no payment row and nothing is published. Then kill the broker connection after the commit and assert the event is still published once the broker is back.

    5. [High] One malformed record blocks its partition forever

    Where: application.yml: value-deserializer: ...JsonDeserializer, spring.json.trusted.packages: "*"

    What happens: a producer publishes one record that isn't valid JSON, or that has a __TypeId__ header naming a class this service doesn't have. JsonDeserializer throws inside poll(), before the listener or error handler ever sees the record. The container then fails on the same offset in a loop, and every later payment on that partition stops.

    Separately, trusted.packages: "*" combined with type headers lets any producer on the topic choose which class Jackson creates. That is unsafe for a payments topic.

    Fix: wrap both deserializers in ErrorHandlingDeserializer. Set a fixed target type, turn off type headers, and trust only your own package (YAML in section 5). The bad record then goes to the DLT and the partition keeps moving.

    Verify: publish the raw bytes not-json to payments, then a valid event. Assert the first lands on payments.DLT and the second is processed.

    6. [High] synchronized token refresh can stall every virtual thread in the app

    Where: LedgerClient.java, currentToken: private synchronized String currentToken() with an HTTP call inside it

    What happens: on JDK 21–23, a virtual thread blocks the OS thread underneath it (it is "pinned") while it does I/O inside a synchronized method. Virtual threads waiting to enter that method are pinned too. There is one such OS thread per CPU core by default.

    When the token expires, which happens on every token lifetime, one thread makes the token call while pinned, and the threads queued behind it pin the rest. Every virtual thread in the JVM then waits: the Kafka listener containers (because spring.threads.virtual.enabled: true) and web requests alike. Combined with finding 7 (no timeouts), a slow token endpoint can freeze the whole service.

    Fix: use a ReentrantLock instead of synchronized (section 5). If you run JDK 24 or later, this pinning no longer happens (JEP 491); tell me and I'll downgrade this finding.

    Verify: run a load test with -Djdk.tracePinnedThreads=full or JFR's jdk.VirtualThreadPinned event, with the token expiry forced to a few seconds. Expect no pinning events from LedgerClient.

    7. [High] The ledger client has no timeouts

    Where: LedgerClient.java, constructor: builder.baseUrl(...).build() with no request factory settings

    What happens: by default the client has no read timeout. Once processing runs on the listener thread (finding 1), a ledger call that hangs holds that thread. After max.poll.interval.ms (5 min) the consumer is removed from the group, its partitions move to another consumer, and the batch is processed again. Without finding 3's idempotency key, that is a second ledger post.

    Fix: set a connect timeout of about 2 s and a read timeout of about 10 s (section 5). Keep the worst case for one poll's records well under 5 minutes, or lower max.poll.records.

    Verify: a WireMock test with a 30 s fixed delay. Assert that the call fails within the timeout and the record goes through retry and then the DLT.

    8. [High] auto-offset-reset: latest on a brand-new consumer group skips existing payments

    Where: application.yml: auto-offset-reset: latest

    What happens: ledger-sync is a new group, so it has no committed offsets on its first start. If producers start publishing to payments before this consumer's first deploy, or a rollout fails and is retried, the group starts at the end of the topic. Every payment already on it is never processed. The same happens if the group is idle for longer than the broker's offset retention (7 days by default).

    Fix: set earliest. Be careful: if payments already holds history that must not go to the ledger, earliest replays all of it. In that case, set the group's starting point once, before go-live, with kafka-consumer-groups.sh --group ledger-sync --topic payments --reset-offsets --to-datetime <cutover> --execute. Then keep earliest as the safety net.

    Verify: before go-live, run kafka-consumer-groups.sh --describe --group ledger-sync and confirm the committed offsets match the planned cutover.

    9. [High] acks: 1 loses acknowledged payments-settled events when a broker fails

    Where: application.yml: producer.acks: 1

    What happens: with acks: 1, the partition leader acknowledges the send before any follower has copied it. If the leader broker crashes right then, a follower without the record becomes leader and the event is gone, though the producer saw it as sent. acks: 1 also turns off producer idempotence, so the producer's own retries can duplicate or reorder events.

    Fix: remove the line (the default since kafka-clients 3.0 is all), or set acks: all. On the topic, use replication factor 3 with min.insync.replicas=2.

    Verify: run kafka-configs.sh --describe --topic payments-settled to check min.insync.replicas. A chaos test that kills the leader during sends should find no gaps in the outbox IDs the consumer receives.

    3. Checked and fine

    Exactly-once / Kafka transactions: nothing in the code claims exactly-once, and no transactional producer is configured. The fixed path is at-least-once with idempotent processing, which is the right model here.

    • Keys on payments-settled: keyed by payment ID, which is stable, so events for one payment stay in order.

    Shared mutable state: the listener holds no per-record fields. LedgerClient's token fields are only touched under the lock, so they stay safe after the ReentrantLock change.

    • Calling KafkaConsumer from other threads: not done.

    Large records and tombstones: nothing visible suggests large payloads or a compacted topic. See questions 1 and 6.

    4. Questions
    1. Does PaymentEvent have its own event ID, or only paymentId? If one payment can produce several events (authorized, settled, refunded), the dedupe key must be the event ID, or later events are skipped as duplicates. (Finding 3)

    Does the ledger API accept an idempotency key? If it doesn't, a crash between the ledger post and the database commit can still double-post, and you'll need a reconciliation job. (Finding 3)
    3. Does payments already contain events that must not reach the ledger? This decides between earliest and a one-off offset reset at cutover. (Finding 8)
    4. How many partitions does payments have, and what are the replication factor and min.insync.replicas on both topics? concurrency = "6" above the partition count leaves consumers idle, and payments.DLT needs at least that many partitions. (Findings 2, 9)
    5. Which JDK runs in production, 21 or 24+? (Finding 6)
    6. Do consumers of payments-settled depend on the __TypeId__ header that JsonSerializer adds? The outbox relay below sends plain JSON strings. If they need the header, the relay should add it. (Finding 4)
    7.

    Does /oauth/token need client credentials? The request sends no body or auth, so it likely gets a 401 in production. (Not a Kafka issue, but the service won't work without it.)

    5. Fixed version

    PaymentEventsListener.java:

    @Service
    public class PaymentEventsListener {
    
        private final PaymentEventHandler handler;
    
        public PaymentEventsListener(PaymentEventHandler handler) {
            this.handler = handler;
        }
    
        @KafkaListener(topics = "payments", groupId = "ledger-sync", concurrency = "6")
        public void onPayment(PaymentEvent event) {
            handler.handle(event);   // same thread; exceptions go to the error handler
        }
    }
    

    PaymentEventHandler.java (new bean, so the @Transactional proxy applies):

    @Component
    public class PaymentEventHandler {
    
        private final JdbcTemplate jdbc;
        private final PaymentRepository payments;
        private final OutboxRepository outbox;
        private final LedgerClient ledger;
        private final ObjectMapper json;
    
        // constructor omitted
    
        @Transactional
        public void handle(PaymentEvent event) {
            int inserted = jdbc.update("""
                INSERT INTO processed_event (consumer_group, event_id, processed_at)
                VALUES ('ledger-sync', ?, now()) ON CONFLICT DO NOTHING""", event.getEventId());
            if (inserted == 0) {
                return;                                           // already processed
            }
            Payment payment = payments.save(Payment.from(event));
            ledger.post(payment, "payment-" + event.getEventId()); // ledger dedupes on the key
            outbox.save(OutboxEvent.of(UUID.randomUUID(), payment.getId().toString(),
                    "PaymentSettled", json.writeValueAsString(PaymentSettled.of(payment))));
        }   // any exception rolls everything back and the record is retried
    }
    

    The ledger call runs inside the transaction, so it holds a database connection while it waits. With concurrency 6 against Hikari's default pool of 10 that's fine, but keep concurrency below the pool size. writeValueAsString throws a checked exception: wrap it, or declare throws.

    OutboxRelay.java:

    @Component
    class OutboxRelay {
    
        private final JdbcTemplate jdbc;
        private final KafkaTemplate<String, String> stringTemplate;   // StringSerializer, acks=all
    
        @Scheduled(fixedDelay = 500)
        @Transactional
        public void publish() throws Exception {
            var rows = jdbc.query("""
                SELECT id, aggregate_id, payload FROM outbox_event
                WHERE sent_at IS NULL ORDER BY created_at
                LIMIT 100 FOR UPDATE SKIP LOCKED""",
                (rs, i) -> new OutboxRow(rs.getObject(1, UUID.class), rs.getString(2), rs.getString(3)));
            for (var row : rows) {
                var rec = new ProducerRecord<>("payments-settled", row.aggregateId(), row.payload());
                rec.headers().add("event-id", row.id().toString().getBytes(StandardCharsets.UTF_8));
                stringTemplate.send(rec).get(10, TimeUnit.SECONDS);       // broker ack first
                jdbc.update("UPDATE outbox_event SET sent_at = now() WHERE id = ?", row.id());
            }
        }
    }
    

    The relay can publish an event twice (for example, a crash after the send and before the update), so consumers of payments-settled should dedupe on the event-id header. If strict order per payment matters across several replicas, run only one relay (for example with ShedLock).

    LedgerClient.java:

    @Component
    public class LedgerClient {
    
        private final RestClient http;
        private final ReentrantLock tokenLock = new ReentrantLock();
        private String accessToken;
        private Instant expiresAt = Instant.EPOCH;
    
        public LedgerClient(RestClient.Builder builder) {
            var factory = new JdkClientHttpRequestFactory(
                    HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(2)).build());
            factory.setReadTimeout(Duration.ofSeconds(10));
            this.http = builder.baseUrl("https://ledger.internal").requestFactory(factory).build();
        }
    
        public void post(Payment payment, String idempotencyKey) {
            http.post().uri("/entries")
                .header("Authorization", "Bearer " + currentToken())
                .header("Idempotency-Key", idempotencyKey)
                .body(LedgerEntry.of(payment))
                .retrieve()
                .toBodilessEntity();
        }
    
        private String currentToken() {
            tokenLock.lock();
            try {
                if (Instant.now().isAfter(expiresAt)) {
                    TokenResponse t = http.post().uri("/oauth/token")   // add client credentials, see question 7
                            .retrieve().body(TokenResponse.class);
                    accessToken = t.value();
                    expiresAt = Instant.now().plusSeconds(Math.max(0, t.expiresIn() - 30));
                }
                return accessToken;
            } finally {
                tokenLock.unlock();
            }
        }
    }
    

    KafkaErrorHandling.java:

    @Configuration
    class KafkaErrorHandling {
    
        @Bean
        DefaultErrorHandler errorHandler(KafkaTemplate<Object, Object> jsonTemplate,
                                         ProducerFactory<Object, Object> pf) {
            // Records that failed to deserialize carry their raw bytes, so they need a byte[] template
            var bytesTemplate = new KafkaTemplate<>(new DefaultKafkaProducerFactory<>(
                    pf.getConfigurationProperties(), new StringSerializer(), new ByteArraySerializer()));
            Map<Class<?>, KafkaOperations<?, ?>> templates = new LinkedHashMap<>();
            templates.put(byte[].class, bytesTemplate);
            templates.put(Object.class, jsonTemplate);
            var recoverer = new DeadLetterPublishingRecoverer(templates,
                    (rec, ex) -> new TopicPartition(rec.topic() + ".DLT", rec.partition()));
    
            var backOff = new ExponentialBackOffWithMaxRetries(5);
            backOff.setInitialInterval(500);
            backOff.setMultiplier(2.0);
            backOff.setMaxInterval(10_000);
            var handler = new DefaultErrorHandler(recoverer, backOff);
            handler.addNotRetryableExceptions(HttpClientErrorException.class);   // 4xx: send straight to the DLT
            return handler;
        }
    
        @Bean
        NewTopic paymentsDlt() {
            return TopicBuilder.name("payments.DLT").partitions(6).replicas(3).build();  // at least the partition count of "payments"
        }
    }
    

    application.yml:

    spring:
      threads:
        virtual:
          enabled: true
      kafka:
        bootstrap-servers: kafka-1:9092,kafka-2:9092,kafka-3:9092
        consumer:
          auto-offset-reset: earliest          # set the cutover offsets first, see finding 8
          key-deserializer: org.springframework.kafka.support.serializer.ErrorHandlingDeserializer
          value-deserializer: org.springframework.kafka.support.serializer.ErrorHandlingDeserializer
          properties:
            spring.deserializer.key.delegate.class: org.apache.kafka.common.serialization.StringDeserializer
            spring.deserializer.value.delegate.class: org.springframework.kafka.support.serializer.JsonDeserializer
            spring.json.value.default.type: com.example.payments.PaymentEvent
            spring.json.use.type.headers: false
            spring.json.trusted.packages: com.example.payments
        producer:
          acks: all
          value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
    

    enable-auto-commit is removed on purpose.

    Schema

    CREATE TABLE processed_event (
      consumer_group VARCHAR(100) NOT NULL,
      event_id       VARCHAR(100) NOT NULL,
      processed_at   TIMESTAMP    NOT NULL,
      PRIMARY KEY (consumer_group, event_id)
    );
    CREATE TABLE outbox_event (
      id UUID PRIMARY KEY, aggregate_id VARCHAR(100) NOT NULL, event_type VARCHAR(100) NOT NULL,
      payload TEXT NOT NULL, created_at TIMESTAMP NOT NULL DEFAULT now(), sent_at TIMESTAMP
    );
    CREATE INDEX outbox_unsent ON outbox_event (created_at) WHERE sent_at IS NULL;
    

    Before go-live, run the four tests together: the crash test from finding 1, the duplicate-delivery test from finding 3, the malformed-record test from finding 5, and the slow-ledger test from finding 7. Between them they cover every Critical and High finding except the cutover offsets (finding 8), the acks setting (finding 9) and the token-lock pinning (finding 6), which you check with the commands and load test listed in those findings.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Kafka code that passes every unit test can still lose payments on the next deploy. The listener hands work to a thread pool and returns, so the offset commits before the database write. A catch (Exception e) logs and moves on, so a failed record is marked done. A bad JSON message blocks its partition forever. Generic code review rarely catches these, because the bug is in how Kafka, Spring and the database interact, not in any single line.

    Kafka Spring Production Reviewer makes your agent review that interaction. For every listener and producer it traces the message from poll to commit, lists each side effect, and asks what happens when each step fails. Then it walks a ten-area checklist:

    1. Offsets and commits (auto commit, early commits, manual acks, off-by-one)
    2. Idempotent consumers (dedupe keys, races, external side effects)
    3. Retries and error handling (swallowed exceptions, Spring defaults, batches)
    4. Dead-letter topics (naming, partitions, alerting, replay)
    5. Poison messages and deserialization
    6. Exactly-once claims and Kafka transactions
    7. Transactional outbox and dual writes (including @Transactional that does nothing)
    8. Producer durability and unchecked send results
    9. Rebalances and consumer liveness
    10. Concurrency, ordering and virtual threads on Java 21

    Every finding comes with a severity (Critical, High, Medium, Low), the exact file and line, a step-by-step failure scenario, a minimal fix in your own names and types, and a test that proves the fix. A finding without a concrete failure scenario is not reported, so you get a short list you can act on, not a wall of maybes. It also says which areas it checked and found fine, and which facts it needs from you (partition counts, topic min.insync.replicas).

    The package has the SKILL.md, three reference files (the checklist, Spring Boot fix patterns for outbox, DLT, poison pills and idempotent consumers, and a table of Kafka and Spring defaults by version), and a read-only Python scanner that lists hotspots in a large repo so the agent knows where to look.

    Requires: an agent that loads SKILL.md skills, such as Claude Code. Java or Kotlin code using Kafka (Spring Boot and spring-kafka get the most specific advice). Python 3 only for the optional scanner. No API keys, no network.

    Known limitations

    • It reviews code and config it can see. Broker and topic settings (partitions, replication, min.insync.replicas) are asked about, not guessed.
    • Static review only: it does not run your app, a broker or your tests.
    • Kafka Streams, reactive Kafka and non-Spring clients get the general checks, not framework-specific fixes.
    • The scanner is a pattern matcher. It finds leads quickly; the full review still reads the code.

    FAQ

    Which versions does it know? Java 21+, Spring Boot 3.x, spring-kafka 3.x and kafka-clients 3.x to 4.x. It reads your build file and states the versions it reviewed against, because defaults changed between versions.

    Will it rewrite my code? It proposes fixes and, for small classes, a full corrected version. It changes files only if you ask it to.

    Does the scanner send my code anywhere? No. It reads the paths you pass, prints results, writes nothing and makes no network calls.

    Is it useful without Spring? Yes for commits, idempotency, outbox, rebalances and producer durability; Spring-specific fixes are skipped.

    It reviews code and config it can see. Broker and topic settings (partitions, replication, min.insync.replicas) are asked about, not guessed. Static review only: it does not run your app, a broker or your tests. Kafka Streams, reactive Kafka and non-Spring clients get the general checks, not framework-specific fixes. The scanner is a pattern matcher. It finds leads quickly; the full review still reads the code.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 10 days ago

    Permissions

    Terminal / Shell
    Read Files
    Listed10 days ago

    What's inside

    Frequently Asked Questions

    Java 21+, Spring Boot 3.x, spring-kafka 3.x and kafka-clients 3.x to 4.x. It reads your build file and states the versions it reviewed against, because defaults changed between versions.

    It proposes fixes and, for small classes, a full corrected version. It changes files only if you ask it to.

    No. It reads the paths you pass, prints results, writes nothing and makes no network calls.

    Yes for commits, idempotency, outbox, rebalances and producer durability; Spring-specific fixes are skipped.

    New in APIs & Backend