I’ve used iFlow’s free API quite a lot already, so today I’m trying out iFlow’s CLI—iFlow CLI—to see how it goes, using the GLM-4.6 model. Enjoy Newsletter #66.

The Ultimate List of Best Software Architecture Books (2026)

Software architecture is the foundation that determines a product’s quality: good design reduces bug risk and makes adding features later far easier. Patrick Roos curates a reading list of software architecture books for 2026, spanning classics like Richards and Ford’s Fundamentals of Software Architecture, Software Architecture in Practice (4th edition), Designing Data-Intensive Applications, and Enterprise Integration Patterns, as well as modern practical guides like Software Architecture: The Hard Parts on distributed-systems trade-offs and Building Multi-Tenant SaaS Architectures for cloud platforms.

The list also emphasizes the human and organizational side of architecture: Susanne Kaiser’s Architecture for Flow combines Wardley Mapping, Domain-Driven Design, and Team Topologies to align business strategy with architecture; Gregor Hohpe’s The Software Architect Elevator helps architects bridge the gap between engineering and the business; Collaborative Software Design shows how to involve stakeholders in the design process; and Facilitating Software Architecture and Reviewing Software Systems (introducing the lightweight LASR architecture review method) help architects and developers collaborate more effectively. The list also highlights two new/upcoming titles for late 2025–2026: Lilienthal and Schwentner’s Domain-Driven Transformation, offering a roadmap for modernizing legacy systems, and Simon Brown’s The C4 Model on communicating software architecture through structured diagrams.

How I use AI (Oct 2025)

Ben Stolovitz shares how he uses AI—primarily large language models (LLMs)—in his daily work as of October 2025. Coding is where AI has made the biggest difference: he calls GitHub Copilot’s autocomplete “magical” for finishing boilerplate and discovering idiomatic patterns in unfamiliar languages, even if it struggles with complex algorithms. Agent mode is increasingly helpful for larger changes, though it still requires solid tests, clear documentation, and human oversight. For search and research, AI excels at tracking down tip-of-the-tongue articles or explaining general concepts, but falls short when shopping for products or finding academic papers, and remains prone to hallucinating citations or sycophantically validating whatever assumption the user feeds it.

Summarization and transcription are standout strengths: AI can condense hundreds of pages of documentation or an entire meeting recording in minutes. Conversely, Stolovitz refuses to let AI write for him because he views his blog as personal self-expression; he uses AI only as a tough copy editor to suggest better phrasing, then rewrites the text in his own voice. He is most skeptical of AI-generated visual art and music, finding them lacking in creative depth and genuine human connection.

Stop Vibe Coding Your Unit Tests

Andy Gallagher warns against handing unit test writing over to LLMs on autopilot. Left to their own devices, LLMs tend to generate far too many tests that merely assert what the code currently does rather than verifying what the code should do. Given a simple React button component, for instance, Claude Sonnet 4 generated roughly 30 tests spanning ~200 lines, mostly testing trivialities like default rendering, prop passthrough, or HTML attributes that React and the browser already guarantee. Such tests lock the codebase to its current implementation so every refactor breaks a pile of tests, while polluting the agent’s context window, degrading semantic code search, and turning pull requests into a slog for teammates to review.

Gallagher’s remedy is intentional, test-by-test authoring: explicitly specify which behavior you want to test, carefully review what the AI generates, and keep test files lean and focused. LLMs still do well on self-contained, algorithmic code, but for everyday product code, what actually needs testing is whether the team is building the right thing. The core principle: fewer, higher-quality tests beat bloated test suites every time.

Game design is simple, actually

Raph Koster outlines a systematic 12-step framework for understanding game design. At their core, games are about mastering problems: fun comes from making progress in our ability to predict outcomes, not from surface-level flash. A toy is a system with constraints; add a goal and it becomes a game, centered on a core mechanic—a “problem object” to be solved. Players interact through loops: an operational loop (act, receive feedback, learn) and a progression loop where situations continually escalate and shift so old strategies stop working. Good feedback must tell players what they can do, what they just did, what happened as a result, and whether they are getting closer to their goal, while difficulty must match their learning curve.

At the macro level, a game is assembled from smaller sub-games whose loops interlock to form economies and value chains. How a problem is dressed up—through narrative, visuals, audio, and metaphor—strongly shapes the player’s experience, making game design a synthetic art form that demands both systems design and experience design. Player motivations vary widely too, which is why no single game appeals to everyone. The individual principles sound simple, but executing all 12 well at the same time is the real challenge.

Architectural debt is not just technical debt

Frederick Van Brabant distinguishes architectural debt from technical debt. While technical debt usually refers to localized shortcuts inside a codebase, architectural debt consists of structural decisions with long-term consequences that reach far beyond code. He breaks architectural debt down across three layers. At the application and infrastructure layer, enterprise architects should focus on integration patterns, overlapping systems, and vendor lock-in, because debt here inflates costs and slows delivery. The business layer involves ownership, governance responsibilities, and outdated processes—where inaccurate documentation can create serious trouble during audits. The strategic layer is the most dangerous: poorly defined capabilities or half-baked framework rollouts plant flawed assumptions across the organization for the next three to five years.

Enterprise architects have the vantage point and time horizon to spot this kind of debt, but merely raising the alarm isn’t enough: they need to build a compelling business case laying out the current state, target state, and business upside backed by concrete numbers to win leadership buy-in. Van Brabant also advises picking your battles wisely: it’s fine to tolerate more debt in experimental innovation systems than in systems of record, provided you clean it up once the experiment concludes and secure real resources to pay the debt down.

The Search Problem: Why Your Computer Finds Things Faster Than You Do

This article explains why B-trees are so foundational in modern storage systems. The author recounts implementing a binary search tree (BST) from scratch and watching it fall apart once simulated disk reads and writes were introduced. A BST’s lookup cost scales with its height: O(log n) when balanced, but degrading to O(n) when unbalanced. Under a model where each node visit costs one disk read, searching across 100,000 files takes roughly 17 disk reads with a balanced BST, whereas a B-tree needs only 3. That’s because a B-tree packs many keys into each node (“fat nodes”) sized to fit a single 4KB disk block, keeping the tree extremely shallow. In the author’s simulation, inserting 100,000 sequential items caused the BST to degenerate into a 40,000-level linked list that took roughly 23.5 minutes, while the B-tree stayed 3 levels tall and finished in 3 seconds.

Because they guarantee predictable worst-case performance regardless of insertion order, B-trees and their variants power indexes in MySQL, PostgreSQL, MongoDB, and countless filesystems. The broader lesson extends beyond data structures: hardware context dictates optimal design. B-trees trade away theoretical best-case simplicity in exchange for rock-solid worst-case guarantees—which is what matters in production systems.

Kafka is fast – I’ll use Postgres

This post benchmarks PostgreSQL as a pub/sub and job queue system in place of dedicated message brokers like Kafka. With 1 KiB messages in a pub/sub workload, a 4-vCPU instance in the author’s test setup achieved roughly 5,000 messages per second on writes (4.8 MiB/s) and 24.6 MiB/s on reads with a 5x fan-out, at a 60ms p99 latency. A three-node replicated cluster maintained the same throughput while increasing p99 latency to 186ms. Scaling up to a 96-vCPU instance reached 238 MiB/s on writes and 1.16 GiB/s on reads while using only about 10% CPU. In a work-queue pattern, the 4-vCPU machine handled roughly 2.81 MiB/s at a 17.7ms p99 latency, while the 96-vCPU machine reached 19.7 MiB/s.

The author’s takeaway is simple: use Postgres until you genuinely outgrow it. For the vast majority of organizations operating below a few megabytes per second, Postgres covers 80% of use cases with 20% of the effort, whereas the operational overhead and organizational complexity of adopting a separate distributed broker usually outweigh its benefits at modest scale. That simplicity and reliability are exactly why the “Just Use Postgres” movement keeps gaining traction.

You Need To Become A Full Stack Person

Den Delimarsky argues that in the AI era, everyone needs to become a “full-stack person.” As LLMs commoditize many narrow coding skills, combining creativity, critical thinking, and execution speed becomes the durable career moat. Boundaries between traditional roles are blurring, reflected in the rise of the product engineer who owns frontend, backend, and customer empathy end to end. In Delimarsky’s view, the T-shaped skill model (one deep specialty atop a broad base) is obsolete; replacing it is the Pi-shaped model with two deep pillars—product sense and technical craft—resting on broad interdisciplinary knowledge.

The post highlights ten skills to cultivate: creativity and taste, critical thinking, communication, interdisciplinary breadth, AI leverage, product sense, execution speed, rapid learning, systems thinking, and agency. AI cannot replace taste or judgment; it is a vehicle for turning ideas into reality, lowering the cost of writing code without lowering the cost of deciding what is worth building. Typing code is no longer the bottleneck, and a high-agency “start doing, then figure it out” mindset is what sets people apart.

Verdict: iFlow CLI did a pretty good job on the first few articles, though toward the end it started leaving too many English words untranslated. A nice plus is that iFlow CLI can fetch many URLs by bypassing blocks through a proxy (though it’s a Chinese proxy, which feels a bit sketchy). While running it I also saw a bunch of log lines in Chinese, which was confusing and slightly unnerving :v I’ll try to refine AGENTS.md and test it again later.


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.