Enjoy Newsletter #84.

Automatic programming

Salvatore Sanfilippo (antirez), creator of Redis, coins the term “automatic programming” for writing software with AI assistance—and believes that before long, we will simply call it “programming.” He draws a sharp line between automatic programming and “vibe coding”: in vibe coding, you hand a vague prompt to an LLM and let it generate software while you stay mostly out of the loop, only nudging it when something breaks. In automatic programming, the human programmer understands everything happening under the hood, continuously steers the model according to their own vision across every level of abstraction—from high-level architecture down to how a specific function should be implemented—and decides what to build in the first place. Because of that, the same model produces vastly different results depending on who is in the driver’s seat.

Sanfilippo argues that code produced this way is genuinely yours and something you have every right to be proud of. Since the training data behind these models came from humanity’s collective output, he sees LLMs more as a shared gift from humanity to itself than as theft. He points to Redis as an example: technically speaking, Redis contained very little novel computer science—just basic data structures and networking code that any competent systems programmer could write; what made Redis valuable was the product vision and taste behind it. His conclusion: programming can now be automated, but vision (for now) cannot.

Software Performance Engineering: The Ideas I Keep Coming Back To

Rico Mariani distills eight performance engineering ideas he keeps returning to across decades and programming languages, centered on one core theme: performance is not about clever tricks or micro-optimizations, but a way of thinking. First, performance is a systems problem: the hardest issues almost always stem from architectural choices like excessive allocations, poor data locality, hidden synchronization, or unbounded growth rather than a single slow function. Abstractions are never free—they merely hide cost, so you need to know what they expand into and how often they run. Cost models matter more than APIs: two APIs that look identical on the surface can differ by 10x because one allocates on every call or touches cold memory. And profilers only tell you where time went, not why it was spent.

Memory is the real bottleneck, as the speed gap between CPUs and main memory continues to widen. Meanwhile, Knuth’s famous quote that “premature optimization is the root of all evil” is routinely abused: the real sin is designing systems with zero cost awareness, which leads to “premature pessimization.” Programming languages also shape how engineers think about cost—languages that make ownership and lifetimes explicit make cost much easier to reason about. Finally, performance rarely dies in a single commit; it erodes through a thousand tiny, invisible cuts, requiring regular check-ins to verify that reality still matches your architectural intent.

Go’s synctest is amazing

Eric Chiang from Oblique shares his experience using Go 1.25’s testing/synctest package to test a codebase full of background control loops, such as purging expired database sessions or running distributed leader election across instances. The headline feature of synctest is running tests inside an isolated “bubble” with a fake clock so time.Sleep completes almost instantaneously. According to Chiang, however, its even bigger superpower is letting you deterministically reason about the ordering of concurrent events. synctest only advances its fake clock when every goroutine inside the bubble is durably blocked—typically on channels, wait groups, or time operations—and then advances the clock just enough to wake the shortest sleep. That lets tests use time itself as a synchronization primitive, something that would be an anti-pattern in production code; for example, a background ticker loop that runs once a minute is guaranteed to execute exactly three times after sleeping for three fake minutes.

In practice, simply sleeping slightly longer than the interval of RunDeleteExpiredSessions guarantees the background cleanup pass has finished before the test asserts against the database, and the entire test finishes in under a second. His team even applied synctest to their database-backed leader election logic spanning dozens of concurrent loops without modifying a single line of production code, pausing execution at arbitrary points in time to inspect database state. He notes two caveats to keep in mind: understanding which operations count as “durably blocked” (network and file I/O do not) and ensuring all spawned goroutines exit cleanly before the bubble closes.

Why Clean Architecture Confuses Everyone (And How I Learned to Stop Worrying)

Drawing on more than 10 years of software engineering experience, Rômulo Pereira explains why Clean Architecture confuses so many developers: teams spend hours arguing over folder structures while missing the core principle. Frameworks like Spring Boot make violating boundaries effortless—a single annotation on a domain class tightly couples your business logic to JPA, Jackson, and the framework runtime. Organizing packages by technical layer (controller, service, repository, model) also pulls you into technology-first thinking, whereas organizing by feature (order, product, customer) keeps the focus on what the system actually does. From his experience building high-volume billing systems and real-time data platforms, he argues that business logic should be “boring”: completely agnostic to where data is stored, whether requests arrive over REST or a message queue, or which framework is in use. And don’t create an interface for every class just because “Clean Architecture requires ports and adapters”—an interface that will only ever have one implementation is pure ceremony.

The real litmus test is replaceability: could you swap your database, move from REST to GraphQL, or upgrade your framework without touching your core domain logic? His pragmatic approach is to write plain, annotation-free use cases and push Spring wiring to the outer boundary of the system. Instead of debating package names, ask whether your business rules are easy to unit-test in milliseconds, how many files break when you upgrade a framework, and whether a new teammate can tell what the system does at a glance. Start simple, keep business rules pure, and test them without mocking the entire world.

The third golden age of software engineering – thanks to AI

In this episode of The Pragmatic Engineer podcast, Gergely Orosz sits down with Grady Booch, co-creator of UML and Chief Scientist for Software Engineering at IBM. Booch divides the history of computing into three “golden ages”: the first revolved around algorithms (1940s to 1970s), the second around object-oriented abstractions (1970s to 2000s), and the third—which we are in today—around systems of systems. In his view, this third age began when our unit of abstraction rose to entire libraries, frameworks, and platforms, well before the current AI wave. He reminds listeners that existential dread in software is nothing new: when compilers and high-level languages first appeared, assembly programmers feared they would be replaced, yet the profession evolved and expanded. AI coding tools simply raise the level of abstraction one step further; as he puts it, “tools change, the problems remain the same.”

Booch notes that today’s AI models are trained primarily on problems that have already been solved thousands of times, making them great at automating familiar patterns like web CRUD apps while the true frontier of computing remains vast. When the industry moves at breakneck speed, strong fundamentals become more important, not less. He does acknowledge that routine software delivery plumbing is the easiest target for automation, meaning engineers in purely mechanical roles will need to upskill. His closing message: this is a moment to soar, not to fear the abyss.

AI coding workflow

In this guest post for The System Design Newsletter, Louis-François Bouchard shares the workflow he uses to get reliable results from AI coding tools after realizing AI is not a “vending machine” where you paste a bug and get working production code out. His core mental model: treat AI like a brilliant new teammate who joined your project five minutes ago—it types fast and knows every language, but has zero awareness of your architecture, conventions, or constraints unless you tell it. AI works best inside a tight six-step loop: Context (supplying the README, rules files like AGENTS.md or CLAUDE.md, relevant files, and stack traces or logs), Plan (asking for a strategy before any code is written, because fixing a plan is much cheaper than debugging code), Code (making small, incremental changes that are easy to review), Review, Test, and Iterate.

He also uses a lightweight multi-agent pattern with four distinct roles: a Planner to break down tasks and spot edge cases, an Implementer to write code strictly following the approved plan, a Tester to write unit and edge-case tests, and an Explainer to summarize what changed and why. He pairs a strong reasoning model for planning with a faster model for implementation. The post also catalogs common failure modes like context drift in long chats, hallucinated or outdated APIs, debugging death spirals, gradual codebase rot, and over-reliance on AI. The overarching rule: treat AI output as a first draft, and always rely on human review and automated tests as your safety net.

Bonus

Images: Git pull vs. git fetch Top Authentication Techniques


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.