This post was created using Claude Code Router with the qwen3-coder model running on iFlow Platform. Enjoy Newsletter #57.

Agentic AI has changed my career

Elliot Graebert, a director of engineering at Skydio, confesses that for most of his career he barely wrote code because he moved into management too early. About four months ago, he started “vibe coding” directly in the multi-million-line monorepo that powers the company’s drone fleet, and he is now among its top five contributors, sometimes submitting up to ten pull requests per hour. He distinguishes between two approaches: vibe coding is like pair programming with AI (using tools like Windsurf or Cursor), where the loop is measured in seconds and requires constant attention; agentic AI is like delegating to an eager intern, where the loop is measured in minutes and you only check back once the task is done. His journey went from 0.5x speed (fixing small UI bugs in a single editor), to 1.5x by running three environments in parallel with Gemini, Claude, and GPT to “swarm” a tough bug, and then to 3x thanks to context files (Windsurf Rules) documenting code conventions and test commands, refined iteratively whenever the AI got stuck.

The jump to 10x came from Coder Tasks—automated environments that go from prompt to pull request—combined with two MCPs: GitHub to read issues and open pull requests (triggering CI and Vercel previews), and Playwright so the AI can launch a browser, reproduce a bug, fix it, and verify the fix itself. The core lesson is that agentic AI succeeds when it has a feedback loop that does not require a human in the middle; at that point, he can run dozens of tasks at once, such as completing an entire data-filter component migration in a single day. He also stresses that AI does not magically solve everything—you have to invest in tooling—and the most exciting result is that designers, product managers, and even the flight test team can now contribute directly to the product.

The Evolution Of Garbage Collectors From Javas CMS To ZGC And A JVM Vs Go Vs Rust Latency Shootout

Memory management is a critical topic in programming, especially in languages like Java, Go, and Rust. This article explores the evolution of garbage collectors (GCs) from Java’s traditional Concurrent Mark-Sweep (CMS) to the modern Z Garbage Collector (ZGC).

ZGC is a major leap forward in minimizing application pause times, aiming to keep pauses under 10ms regardless of heap size. This makes a dramatic performance difference compared to earlier-generation GCs like CMS.

The article also compares latency performance across platforms: - JVM (with ZGC): Significantly reduced pause times thanks to improvements in GC design - Go: Efficient low-latency GC powered by a concurrent algorithm and tri-color marking - Rust: Avoids GC entirely through its ownership model, delivering predictable performance without GC overhead

Key takeaways: - ZGC keeps application pause times under 10ms - Go uses an efficient marking algorithm to keep latency low - Rust eliminates the need for GC altogether through its ownership model - Language choice significantly impacts performance and user experience

New in Java25: Generational Shenandoah GC is no longer experimental

Java 25 officially graduates Generational Shenandoah from experimental status, making it ready for production use. Shenandoah is a low-pause-time garbage collector introduced in Java 12 that runs mostly concurrently with the application. Its generational mode, introduced experimentally in Java 24, separates heap memory into young and old generations. Because most objects die young, this separation spares the collector from repeatedly scanning long-lived objects unnecessarily, improving performance and reducing memory footprint.

In Java 25, the feature has been stabilized with numerous bug fixes, lower garbage collection overhead, more efficient memory region management, and improved tooling and logging. According to the article, these improvements make Generational Shenandoah mature enough for real-world applications, and you no longer need the -XX:+UnlockExperimentalVMOptions flag to enable it. It marks an important milestone in Java’s ongoing garbage collection optimization journey.

If all the world were a monorepo

Julie Tibshirani shares her experience with CRAN, the central package repository for R. Before accepting an update, CRAN not only checks the submitted package itself, but also runs checks across every package that depends on it. When she released grf 2.0 with a breaking API change, CRAN blocked publication until the downstream package policytree was updated. At first she found this unreasonable: why should she be responsible for someone else’s code? Over time, however, she realized this isn’t merely a different point on the speed-versus-stability trade-off spectrum, but a form of “radical empathy” in software maintenance: users’ code is the library author’s responsibility too, much like the mindset inside a monorepo.

She contrasts this with her time working on Elasticsearch, where leaving individual projects to upgrade on their own left thousands of projects stuck on old versions years later. Watching large-scale migrations at Databricks, she saw that when engineering teams took end-to-end ownership—including fixing downstream dependent code—completion rates rose dramatically. Although R packages tolerate less consistent APIs than ecosystems like npm or PyPI, users enjoy nearly painless dependency upgrades, offering a lesson worth pondering for other ecosystems.

9 Software Architecture Patterns for Distributed Systems

This article introduces nine common architectural patterns in distributed systems that are useful both in real-world design and in system design interviews. The communication patterns include: Peer-to-Peer, where nodes exchange data directly without a central coordinator, used in file sharing and blockchains; API Gateway, a unified entry point for backend services that handles security and load balancing in microservices architectures; Pub-Sub, which decouples message senders and receivers through a broker, well suited for real-time messaging, event-driven systems, and IoT; and Request-Response, where a client sends a request and receives a corresponding response from a server, ubiquitous in REST APIs and web applications (though the pattern does not strictly require synchronous execution).

The data management and processing patterns include: Event Sourcing, which stores state as an immutable sequence of events for easy auditing and replay, commonly seen in financial systems; ETL (extract, transform, load) to consolidate data from multiple sources into a data warehouse for analytics and data migration; Batching, which groups data into batches to process all at once for higher efficiency; Streaming Processing, which processes continuous data streams in real time for finance, IoT, or cybersecurity; and Orchestration, which uses a central coordinator to manage workflows across services. Understanding the strengths and trade-offs of each pattern helps you build reliable, scalable, and maintainable systems as requirements evolve.

Sort Lines in Source Code

Kyle Freeman’s post on the Google Testing Blog, adapted from a “Tech on the Toilet” episode, opens with a familiar scenario: you enable two-player mode on the last line of a config file, but when you run the game, the feature doesn’t show up. The culprit is that the enable_two_players flag was declared twice with different values—easy to miss when lines are in random order. Simply sorting the lines places the duplicates right next to each other, exposing the bug immediately. The main takeaway is that sorted lists and source lines are easier to read, easier to maintain, and help prevent bugs.

To automate this, the author introduces keep-sorted (github.com/google/keep-sorted): you wrap the lines to sort with keep-sorted start and keep-sorted end comments, run keep-sorted [file1] [file2] ..., and optionally hook it into pre-commit so it runs automatically on every commit. The tool also supports case-insensitive sorting, numeric sorting, prefix order, and regular expressions (for example, using by_regex to sort a Go slice by its end-of-line comments). One important caveat: before sorting, make sure the original order doesn’t carry semantic meaning, such as dependency load order.

Rating 26 years of Java changes

Neil Madden looks back on 26 years of working with Java, from Java 1.1.8 in 1999 to Java 25, and gives subjective ratings to language and core library changes (skipping UI, graphics, the JVM, and GC). Top marks go to java.util.concurrent (10/10), so well designed that people use it in place of the original collection classes; try-with-resources (10/10), which made exception handling far safer; Records (10/10), which he says Java “should have had all along”; UTF-8 by default (10/10), fixing thousands of character-encoding bugs at a stroke; along with Generics (8/10) and var type inference (9/10). The Collections Framework gets just 4/10, lambdas 4/10 because of ugly stack traces, and switch expressions 6/10 as a pleasant minor improvement.

On the flip side, NIO gets 0/10 for its convoluted API, Streams get 1/10 and are called one of modern Java’s biggest mistakes due to complexity, overpromised parallelism, and easy resource leaks, while the cryptography APIs get 1/10 for being easy to misuse. Worst of all is Modules at -10/10: massive disruption for very little practical benefit. Virtual threads are deemed promising but not yet battle-tested enough to score. The post also touches on time-based release cadences, pattern matching, and post-quantum cryptography, closing with an invitation for readers to debate his ratings.

Bonus: Some cool visuals from ByteByteGo

Python vs Java Design Patterns Cheat Sheet Design Patterns Cheat Sheet CI/CD Simplified Visual Guide How Apache Kafka Works? Load Balancers vs API Gateways vs Reverse Proxy Understanding Load Balancers: Traffic Management at Scale

Overall, the output is concise and I’m fairly satisfied—probably around 80% compared to Claude Code with Claude models, and since it’s free I’m very happy with it :)))


This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.