Newsletter #76
Enjoy Newsletter #76.
TCP vs. UDP vs. gRPC: Choosing the Right Protocol for Your Architecture
When you call a local function, data moves entirely within a single machine’s memory; modern software, however, constantly communicates with databases, APIs, and browsers halfway around the world. Network protocols are the rules governing data formats, how conversations are opened and closed, and how errors are handled. This article starts at the transport layer with its two pillars: TCP and UDP. TCP prioritizes reliability: before sending data, both sides perform a three-way handshake (SYN, SYN-ACK, ACK); the protocol then guarantees that every byte arrives intact and in order, automatically retransmits lost packets, and uses flow control and congestion control to avoid overwhelming the receiver. That makes TCP ideal when accuracy matters more than raw speed, such as database queries, email, and web pages. UDP is the opposite: connectionless, no handshake, no packet numbering, and any packet dropped in transit is gone for good; in exchange, latency is minimal, making it a great fit for live video streaming or online gaming, where dropping a frame is far better than pausing to wait for an old one.
At the application layer, HTTP follows a request–response model using methods like GET, POST, PUT, and DELETE, headers carrying metadata, and status codes like 200 OK or 404 Not Found. The HTTP version matters too: HTTP/1.1 processes requests one at a time per connection and suffers from head-of-line blocking when a slow resource holds up the entire page; HTTP/2 adds multiplexing so multiple requests and responses can run concurrently over a single TCP connection; and HTTP/3 drops TCP entirely in favor of QUIC (built on top of UDP) for better performance on lossy networks. Finally, WebSockets overcome HTTP’s unidirectional limitation: a connection begins as an HTTP request asking for an “upgrade” and then stays open so both client and server can push messages at any time without per-message header overhead—ideal for chat apps or live stock tickers that need low-latency bidirectional communication.
Software Engineering in 2026
Ben Congdon observes that the biggest impact of LLM tooling so far is a dramatic drop in the marginal cost—both in time and money—of producing high-quality code. Because writing code is only one part of software engineering, the bottleneck is shifting elsewhere. He breaks an engineer’s job down into building, evolving, and operating distributed systems: the first two have become much cheaper and easier thanks to LLMs, while operations remains largely untouched. The market will expect engineers to harness LLM productivity, making the profession feel more “industrialized” yet also higher-leverage. As a result, investments in solid infrastructure pay off faster than ever: metrics, logging, feature flags, deployments, autoscaling, and configuration should be self-service for both humans and LLMs via ergonomic CLIs or MCP-ready APIs. CI infrastructure also becomes more critical as AI agents write more code, potentially justifying investments in property-based testing and formal verification—and since LLMs don’t mind writing tests, there is no longer any excuse for poor test coverage.
He emphasizes human-guided abstractions: without clear guardrails, LLMs fill in the blanks with greedy solutions just to get CI green, steadily degrading the codebase. Module boundaries, library interfaces, and contracts between infrastructure and product layers become the primary levers for maintaining long-term quality. Human code review also becomes a new bottleneck: style issues should be offloaded to automated linters so reviewers can focus on hard-to-reverse decisions like interface changes, data persistence, and performance-critical paths. This creates a paradox for junior engineers, who need to develop “review taste” earlier while writing less code by hand to build that intuition. Project estimation variance will also widen, since cost now depends heavily on how amenable a task is to LLM automation. On build-versus-buy, thin CRUD-style SaaS tools will increasingly tilt toward “build” at mid-to-large companies, whereas infrastructure and compliance SaaS will change much less because operational costs haven’t fallen like development costs have.
Reflections on 2025
Samuel Albanie looks back on 2025 across three themes in his trademark witty style. First is “The Compute Theory of Everything”: in 2021, the handcrafted architectural inductive biases he painstakingly designed for computer vision at VGG (Oxford) were swept aside by a simpler system backed by massive pre-training compute. He revisits Hans Moravec’s 1976 argument that intelligence is not about magical symbolic manipulation, but raw processing power—“with enough thrust, anything flies.” Moravec noted that AI capability scales in lockstep with researchers’ access to faster hardware; since upcoming hardware clusters will make 2025’s supercomputers look like pocket calculators, Albanie believes we are nowhere near hitting a ceiling. His second theme is model evaluation: AI systems are becoming increasingly general, while our benchmarks remain narrow. METR’s approach measures the duration of tasks models can complete compared to a skilled human, which jumped from roughly 5 minutes in early 2024 to 4 hours and 49 minutes with Claude Opus 4.5 in late 2025, even as the surface area needing evaluation has exploded from MNIST digit recognition to nearly the entire economy.
His final theme, “Floreat Britannia,” examines the UK: real wages grew 33% per decade from 1970 to 2007 before stalling out, industrial electricity prices are the highest in Europe, the Hinkley Point C nuclear plant cost £46 billion, and an acoustic fish deterrent system alone cost roughly £700 million while projected to save just 0.083 salmon per year. In his view, the bottleneck is coordination and decision-making, and he is optimistic that AI will make high-quality probabilistic forecasting cheap and ubiquitous. Still, good forecasts are useless if the culture is paralyzed by risk aversion; invoking Benjamin Franklin flying a kite in a thunderstorm and inventing the lightning rod, he concludes that Britain needs both boldness and prudence—both the “kite” and the “lightning rod.”
8 Predictions for 2026. What comes next in AI?
Philipp Schmid rarely writes prediction posts, but after a watershed 2025, he outlines eight AI trends for 2026. Generative UI will take off once code-generation latency and quality are good enough for apps to synthesize bespoke interfaces in real time tailored to each user’s task and preferences. Personal agents will move to the edge, powered by Small Language Models (SLMs) running locally on dedicated hardware. The smart home will finally deliver on its promise as assistants understand context and intent rather than rigid voice commands, blending into general assistants like the Gemini or ChatGPT apps. As traditional benchmarks saturate, AI labs will compete on “harnesses”—complex environments that prove agents can reliably execute multi-day workflows. Vibe coding will mature into real engineering: engineers will spend 99% of their time reviewing, evaluating, shaping ideas, and thinking, with the core skill being connecting implementation details, code quality, velocity, and business goals; knowing how to code becomes a distinct competitive advantage.
His remaining three predictions revolve around social media: “AI slop” will turn human-created content into a premium market; every post on X, Instagram, or LinkedIn will be assumed AI-generated by default unless it carries a cryptographic signature under a “Human-Signed” metadata standard (like C2PA for cameras), with unsigned content downranked by algorithms as “synthetic noise”; and to fight agent spam, platforms will carve out a “verified human web” requiring biometric proof of personhood. In closing, he isn’t worried about the future of software engineers and believes learning to code is still well worth it, as deep technical understanding is more important than ever for steering these systems. His advice: build and learn—closely observe what others are building, dissect the “why” and “how,” and build your own version. Agents will remain center stage as successful patterns from coding agents spread to general-purpose agents that proactively anticipate needs rather than waiting for prompts.
This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.
Comments