Enjoy Newsletter #85.

How I Use Claude Code

Boris Tane shares the workflow he has used with Claude Code over roughly nine months, built around one rule: never let Claude write code before a written plan has been carefully reviewed and approved. This keeps architectural decisions in the developer’s hands and produces far better results. In the research phase, the author instructs Claude to read the relevant codebase “deeply” and write its understanding to research.md; without such emphatic wording, Claude tends to skim. This file makes it easy to verify whether Claude actually understands the system, because the costliest AI coding failures are changes that work in isolation but break everything around them.

Next, Claude writes plan.md, covering the approach, illustrative code snippets, files to modify, and trade-offs. The most valuable part is the annotation loop: the author adds inline notes directly into the plan to correct faulty assumptions, strip out unnecessary options, or inject domain knowledge, then asks Claude to update the plan with an explicit “don’t implement yet” guard. This loop repeats one to six times, after which a detailed task checklist is added to the plan. Once every decision is settled, a standard prompt tells Claude to execute everything, mark progress right inside the plan, and continuously run type checks. Implementation then becomes “boring”: just short course corrections, reverting when things drift, and running the entire workflow in a single long session so Claude accumulates context.

Next-Generation DB Ingestion at Pinterest

Pinterest introduces the first part of a series on its next-generation database ingestion framework, replacing legacy batch pipelines. The old system regularly had latencies exceeding 24 hours, reprocessed entire tables daily even when less than 5% of rows changed, and lacked row-level deletion support. The new framework is built on change data capture (CDC) using Debezium/TiCDC, Kafka, Flink, Spark, and Iceberg, supporting MySQL, TiDB, and KVStore. CDC services publish events to Kafka with sub-second latency, Flink writes them into append-only Iceberg CDC tables on S3 (under 5 minutes of latency), and Spark periodically deduplicates to the latest change per primary key and uses Merge Into to update the base table—a replica of the online table with 15-minute to one-hour latency.

The team chose Merge-on-Read over Copy-on-Write because the latter incurred much higher storage costs. The post highlights three optimizations. First, base tables are partitioned by the hash of the primary key via bucket() so data distributes evenly and Spark can process partitions in parallel. Second, setting WRITE DISTRIBUTED BY PARTITION groups records from the same partition into a single write, solving the small-files problem. Third, for massive tables, the team stages CDC data into a temporary table with matching partitioning to enable a bucket join, avoiding a full shuffle of the base table before every merge and cutting compute cost by over 40% while significantly reducing latency. Part two will cover automated schema evolution.

Thank you, AI

Gerd Hoffmann recounts shutting down the self-hosted git server he had run publicly since 2011, and as a CVS server before that. AI scraper bots hammered the cgit web interface with pointless requests until the modest server collapsed, even though the most efficient way to get an entire repository is simply to clone it. Unwilling to spend his free time fighting bots, the author decided not to bring the server back and instead migrated completely to GitLab and GitHub—where most of his repositories were already mirrored—while updating old links to point there.

The only remaining self-hosted service is the web server running his blog, which moved from WordPress to Jekyll in 2018 and serves static pages that are very hard to overload. Even so, the bots caused another incident: millions of 404 responses weren’t enough to convince them that cgit was gone, and the access logs grew so fast that default logrotate settings couldn’t rotate them in time, filling up the disk. He tuned the configuration to fix it. This short story illustrates the very real burden the AI scraping wave places on people running small self-hosted services.

Java UI in 2026: The Complete Guide

Robin Tegg surveys more than 25 Java UI frameworks and libraries as of 2026 across four platforms: web, desktop, mobile, and terminal. His central point is that these aren’t legacy relics hanging on for dear life, but production-ready, actively maintained technologies running at major enterprises, banks, and government agencies serving hundreds of millions of users. On the web, Vaadin and Apache Wicket let you write full UIs in Java without JavaScript, PrimeFaces and Jakarta Faces serve the Jakarta EE ecosystem, HTMX paired with Spring Boot follows a hypermedia approach, j2html generates type-safe HTML, Thymeleaf remains the classic template engine choice, and TeaVM compiles Java bytecode to JavaScript or WebAssembly.

On the desktop, JavaFX is the modern standard, JCEF embeds Chromium for HTML/CSS interfaces, Swing gets a fresh look via FlatLaf, and the NetBeans Platform and Eclipse RCP suit large modular applications with plugin architectures. For mobile, Codename One offers write-once-run-anywhere with cloud iOS builds that don’t require a Mac, while Gluon Mobile extends JavaFX with native compilation via GraalVM. In the terminal space, JLine handles command-line input and powers Maven and Gradle, while Lanterna provides a text-GUI toolkit. Each framework comes with a description, code example, getting-started links, and a decision matrix for picking the right tool for each scenario.

Java Full Stack Development in 2026

The author recounts migrating www.scanii.com from a Spring Boot application using webpack and TypeScript to a leaner architecture where all rendering happens on the server. In his view, React, TypeScript, and split codebases only make sense when you have specialized front-end and back-end teams; for a small team of generalists, simplicity yields much higher productivity. The result is a unified codebase that launches with a single “Run” button in IntelliJ, zero front-end build time with live reload, partial page updates that still feel like a single-page app, a 100 Lighthouse performance score, and easier debugging with no transpilation step in the way.

The migration took three steps. First was picking a template engine supported by Spring Boot; the team chose JTE because it gives access to the full JDK right inside templates. Next was dropping the bundler in favor of standard HTML importmaps, paired with WebJars to serve libraries directly from the app without third-party CDNs. Finally, they added interactivity with Hotwire’s Turbo and Stimulus, following the Rails playbook to get partial page updates and a familiar MVC structure for the remaining JavaScript. Two major hurdles were the lack of hot reload—solved by having the browser poll for changes while the server watches the filesystem—and Spring Security’s per-form random CSRF tokens, which clashed with Turbo’s page caching. The team wrote a custom CSRF filter based on the browser’s Sec-Fetch-Site header.

Sharding Databases with Spring Boot: Patterns, Pitfalls, and Failure Modes

This guide explains database sharding—horizontally partitioning data across multiple smaller databases—and how to implement it with Spring Boot. Sharding becomes necessary when vertical scaling hits a wall, queries degrade with table size, write throughput becomes a bottleneck, or higher availability is required. The most consequential decision is choosing the shard key, such as a user ID or tenant ID: it needs high cardinality, should keep most queries on a single shard, and must rarely change. The article compares four strategies—range-based, hash-based, directory/lookup-based, and geo-based—and shows why simple modulo hashing forces almost every key to move when shards are added or removed, whereas consistent hashing only disturbs roughly 1/N of the keys on average.

The implementation walkthrough covers configuring multiple data sources, a shard resolution service, and a routing JdbcTemplate. Queries that include the shard key go straight to one shard, while queries without it must scatter-gather across all shards. Cross-shard joins are the hardest part and can be handled via denormalization, application-level joins, or co-locating related data on the same shard. Because two-phase commit is slow and prone to blocking when the coordinator fails, the author recommends the Saga pattern and embracing eventual consistency. The post also covers monitoring with Actuator, zero-downtime migration via dual writes, and common pitfalls like picking the wrong shard key, hardcoding the shard count, or lacking per-shard backups. Bottom line: only shard when you truly have to.

Go Made Me Fast, Rust Made Me Care, AWS Made Me Pay

The author reflects that for years of running Go on AWS everything seemed fine—fast deployments, productive teams—until realizing that in the cloud, systems rarely fail loudly; they “fail financially.” Go earns its place as a default backend language thanks to its simple concurrency model, strong standard library, small binaries, fast startup, and predictable failure modes. The catch is that inefficiency compounds quietly: an extra 10% CPU here, 200MB of memory there, one more instance “just to be safe.” Go’s garbage collector, good as it is, still costs memory headroom, CPU cycles, tail-latency spikes under load, and lower container density—while AWS simply sends the bill.

Rust entered the picture when high-throughput services and streaming data pipelines started straining Go. The author stresses that Rust isn’t magically faster; it forces developers to confront allocations, ownership, memory layout, and cache behavior. The first Rust service took three times longer to write, but in production its memory graph was flat, latency stayed rock-steady, and CPU usage matched expectations. That translated into smaller EC2 instances, higher container density, fewer OOM kills on ECS/EKS, and lower Lambda bills for CPU-heavy workloads. The takeaway is to put each language where it shines: Go for APIs, business logic, and glue code; Rust for data pipelines, latency-sensitive components, and CPU-bound tasks.

The Cloud Is Not Your Computer: Why Go and Rust Developers Secretly Miss the Monolith

In a companion piece written with a satirical edge, the same author argues that the cloud isn’t your computer—it’s a negotiation. Writing Go or Rust gives you a sense of determinism and control, yet in the cloud the “server” is virtual, the “disk” is over the network, the “network” is software-defined, and the security boundary is an IAM policy copy-pasted from somewhere, meaning you aren’t really running software so much as “renting probability.” Go assumes everything can fail and calmly returns an error, while Rust makes you prove memory ownership up front, yet that carefully verified binary still runs behind layers of containers, clusters, VPCs, load balancers, and CDNs. You debug the code while the real culprit is a security group or a missing index.

The author admits a nostalgia for the monolith because it was predictable, easy to deploy, and straightforward to debug: SSH into one machine, read the logs, and fix the issue, instead of opening CloudWatch, Prometheus, Grafana, and Datadog while still having no idea why a 503 happened. Even so, Go and Rust thrive in the cloud because they are honest languages in an dishonest environment: Go treats errors as first-class values, Rust proves memory safety at compile time, and both reduce uncertainty. Consequently, a great cloud engineer today doesn’t just write good code—they understand network topology, IAM blast radius, observability strategy, latency budgets, failure domains, and cost models.

Bonus

Images: Must-Know Software Architecture Patterns


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.