Enjoy Newsletter #138.

What I believe about the future of software development

Thorsten Ball reposts to his blog a series of predictions that sparked intense debate on X, capturing a snapshot of what he believes in September 2026. In his view, line-by-line human code review is effectively dead: humans will stop hunting for syntax or logic bugs in model-generated diffs and instead review system architecture and how components fit together. Unit tests as we know them may fade too, now that frontier models can one-shot 900 lines of working Arduino C on the first try. The craft of hand-writing code will atrophy much like cobbling shoes by hand, while the craft of building software—solving real business problems, knowing when to ship, and tightening feedback loops—will matter more than ever. Most future bugs will be specification bugs (“you asked for the wrong thing”) rather than implementation bugs, and hand-crafted performance optimization by humans will remain a rare specialty.

His spicier predictions go further: terminals, shells, and CLIs will cease to be human-first interfaces; tokens are the new compute primitive of the “post-binary” era; the classic PM/Design/Engineering triad alongside Agile and Scrum rituals will dissolve, and engineers who act merely as “meat proxies” translating Jira tickets into agent prompts will lose their jobs. Even our notion of “clean, maintainable code” exists primarily to serve human working-memory limits, so it may stop mattering once agents perform the vast majority of edits. Developers priced out of frontier token budgets risk getting left behind, and bespoke UIs will be generated on the fly. Still, Ball acknowledges it will take a full generation for “new software” to replace “old software”—ten years from now people will still be hired to write code by hand, though the real question is whether you’ll want that job.

Trying the Software Factory pattern.

Will Larson reflects that in 2026, effective AI engineering patterns are emerging faster than he can adopt them. At his company Imprint, the year’s progression moved rapidly: in January, getting every engineer using Claude Code daily; in March, expanding Claude Code and Claude Cowork to every non-engineering function; in April, hitting the limits of local git worktree setups and provisioning ~10 full multi-repo workspace checkouts per developer so agents could open coordinated PRs across monorepos; in June, migrating the entire company off Jira onto Linear so agents had clean, low-friction access to task context without permission headaches; and in July, launching “Agent Fleet,” an internal cloud orchestration harness inspired by Stripe’s Minions for autonomously knocking out small tickets.

The next frontier Larson is experimenting with is the Software Factory pattern: pointing a long-running harness at a broad multi-week project goal and letting it drive progress continuously. His first prototype, a /linear-project-loop skill, reads a Linear project and checks whether it has both a Notion RFC (defining goals, metrics, and technical approach) and a Datadog dashboard or Snowflake query tracking those metrics—collaborating with the human to create them if missing. On subsequent runs, the loop checks live metrics and open issues, files missing follow-up tasks, and picks up unblocked work like drafting PRs, nudging reviewers, or posting clarifying questions. Running the loop immediately exposed how much project context Larson had been keeping in his own head rather than writing down, and proved especially valuable after launch—automatically flagging a spike in passkey error rates and queueing up remediation tasks. His takeaway: these pieces only compound when wired together—Datadog MCP, Snowflake, Linear as a single source of truth, and a cloud harness that keeps running when your laptop closes.

Back to Coupling and Cohesion

Daniil Bastrich argues that junior developers and Clean Code zealots routinely over-apply acronyms like SOLID, GRASP, and KISS, producing labyrinthine codebases that look impressive on a whiteboard but are miserable to maintain. In his view, every one of those principles is really just a specialized corollary of managing coupling and cohesion across different scales. Coupling measures how tightly components are entangled such that changing one forces changes in others; cohesion measures the degree to which everything inside a single component serves one unified purpose. To move past hand-wavy intuition, Bastrich proposes quantifying both directly from real development history: for every task, log the effort spent across each touched component; for each component, log the effort spent across each business concern. Using formulas analogous to the Gini-Simpson diversity index and Herfindahl-Hirschman index, coupling is $1 - \frac{\sum e_i^2}{(\sum e_i)^2}$ across components for a task, while cohesion is $\frac{\sum e_i^2}{(\sum e_i)^2}$ across concerns inside a component.

For example, if changing a password-length rule requires editing both the registration form (effort 4) and the password-reset form (effort 6), the task’s coupling score is 0.48, even though each form has a cohesion of 1.0. Framing design around these two forces maps every classic rule back to first principles: Single Responsibility is simply high cohesion; Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, DRY, and the Law of Demeter all exist to reduce coupling or raise cohesion; and KISS bounds the working memory required to hold a component in your head. Even so, Bastrich reminds readers that low coupling and high cohesion aren’t free—in ultra-low-latency trading systems, embedded firmware, or throwaway scripts, tightly coupled code is often the right engineering trade-off.

Introducing System One Models & Jev

Diogo Almeida—founder of TypeSafe AI and an early OpenAI researcher who worked on the foundations of ChatGPT—poses a pointed question: LLMs surpassed human-level chat years ago, so why hasn’t enterprise automation caught up? Coming out of two years in stealth, TypeSafe AI introduces System One Models, a new class of frontier models purpose-built to make fast, structured, calibrated decisions inside software pipelines rather than chatting with humans. Built on a custom architecture, a parallel sampler, and a training methodology called Reinforcement Learning for Calibrated Decisions (RLCD), their debut model Jev (now in early access) acts like a “frontier-intelligence function call”: it ingests unstructured context and returns strongly typed decisions paired with calibrated probabilities. By abandoning token-by-token autoregressive text generation, Jev cannot produce syntax/type errors or free-form hallucinations, evaluates multiple structured questions in parallel in a single pass, responds in 70–500 ms, and costs just $0.042 per million input tokens with free output.

To benchmark real-world utility, the team built a code-level workflow evaluation suite comparing Jev against an ensemble consensus of GPT-6 Astra and Fable 5.1. Across those workflows, Jev ran 193.6x faster and 444.6x cheaper at matching accuracy (though the team transparently notes that benchmark figure sits at the upper end of their target distribution). Ideal use cases include acting as a “smart if statement” inside application control flow, massive map-reduce classification over unstructured data, real-time interactive agents, and fast guardrail verification over LLM outputs—illustrated by live demos of Jev playing DOOM at 10 queries per second for ~$7/hour and playing Wikipedia Wikiracing. The category name nods to Daniel Kahneman’s Thinking, Fast and Slow, while “Jev” honors economist William Stanley Jevons: make machine intelligence orders of magnitude faster and cheaper, and entirely new software architectures become viable.

System One Models 🚦 Explained

Agam More breaks down how System One models—led by TypeSafe AI’s Jev—work in practice, describing them as a fast, dirt-cheap if statement that knows exactly how confident it is. Instead of asking a model to generate an essay, you pass unstructured context alongside a typed schema of closed-ended questions, and the model returns a JSON object with calibrated probabilities for every option, like grading a multiple-choice exam in a single forward pass. Jev exposes three primitives: Choice (picking one option from an enum), Score (rating along a defined rubric scale), and Noul (estimating the boolean probability that a proposition is true). Given a support ticket complaining that a Stripe integration has been broken for three days, for instance, Jev routes it to technical with probability 0.85 and flags urgent: true in under 100 ms. Under the hood, Jev undergoes standard pretraining followed by RLCD post-training on synthetic data that explicitly rewards Brier-score calibration so a 0.80 confidence score genuinely means the model is right 80% of the time.

More advises reaching for a System One model whenever your backend asks an LLM the exact same closed-ended routing, triage, moderation, or extraction question thousands of times a second—letting you auto-execute high-confidence predictions (p > 0.95) and route low-confidence edge cases to a heavier reasoning model or human queue. On the public JevBench suite, Jev is 6x to 7x cheaper per decision than GPT-5.6 Luna or Gemini 3.1 Flash-Lite. Conversely, don’t use it when the answer space isn’t known up front, when you need free-form text generation, or when deep multi-step reasoning matters more than latency; also remember to include an explicit "none_of_the_above" enum variant if inputs can fall outside your categories. Competing approaches in this emerging space include SemIf, Laya, Kev, GLiNER2, and grammar-constrained decoding via Outlines.

How Data Is Replicated In Distributed Systems | Raft From Scratch - Part 1

Sushant Dhiman kicks off a two-part hands-on series with a foundational distributed systems problem: when you replicate a stateful service like a database across five machines for fault tolerance, how do the nodes agree on a single leader without split-brain? His answer walks through Raft, the consensus algorithm designed by Diego Ongaro and John Ousterhout specifically to be easier to understand and implement than Paxos. Consensus ensures that a cluster of replicas agrees on a single ordered sequence of operations even in the face of crashes and network partitions, preventing scenarios where one replica commits 10 transactions while another only sees 7. Part 1 focuses entirely on Leader Election. In Raft, every node is in one of three states at any moment: the Leader handles client writes and coordinates replication, Followers passively respond to RPCs from the leader, and a Candidate is a follower that steps up to call an election after its leader heartbeat times out. Two RPCs drive the entire protocol: AppendEntries (used both to replicate log entries and to send periodic empty heartbeats) and RequestVote (sent by candidates campaigning for leadership).

When a leader crashes or gets partitioned away, followers stop receiving heartbeats; once a follower’s randomized election timeout (say, between 150 ms and 300 ms) expires, it increments its monotonic election term (which acts as a Lamport logical clock), transitions to Candidate, votes for itself, and sends RequestVote RPCs to all peers. Randomized timeouts ensure nodes rarely campaign at the exact same millisecond, preventing endless split votes; within any given term, each node grants its vote to at most one candidate on a first-come, first-served basis, and any node that observes a message carrying a higher term number immediately steps down to Follower. Dhiman concludes with a clean educational implementation in Go and gRPC—wiring up the election timer loop, RequestVote, heartbeat AppendEntries, and protobuf definitions across three local nodes on ports 5001–5003—saving log replication and persistence for Part 2.

Jev means structured output is interesting again

Sean Goedecke rarely writes about new model releases, but makes an exception for TypeSafe AI’s Jev. Standard LLMs generate text autoregressively one token at a time, which makes them wonderfully general-purpose at the cost of high latency and occasional formatting quirks. Jev accepts arbitrary natural-language prompts but only emits structured classification/scoring outputs—and leaning completely into that constraint unlocks compelling systems properties. Because Jev doesn’t generate tokens sequentially and instead evaluates multiple structured decisions in parallel within a single pass, its latency is tightly bounded between 70 ms and 500 ms—fast enough to play DOOM in real time from text descriptions of the screen state. To Goedecke, sub-100 ms, dirt-cheap structured intelligence feels like a genuine new computing primitive: once you can sprinkle 100 ms probabilistic judgements directly into standard control flow, you can build software that looks nothing like a chatbot.

That said, Goedecke offers a sober technical reality check: fast structured output from small models was already possible if you cared to optimize for it. Most structured-output pipelines feel slow only because developers ask frontier chat models to emit massive nested JSON schemas via grammar-constrained decoding. For closed-ended classification, you can simply prefill the assistant response up to "choice": " and run a single forward pass constrained to valid option tokens—an experiment Goedecke ran locally with Qwen2.5-1.5B-Instruct that immediately sped up classification by 2x to 3x. Consequently, Jev’s architectural moat may be shallower than advertised (though post-training specifically for calibrated probabilities via RLCD is a real differentiator), it will never match frontier reasoning models on problems that require test-time chain-of-thought compute, and calling wrong answers “classification errors” instead of “hallucinations” is mostly semantics. Even so, he hopes Jev succeeds and pressures the major labs to ship dedicated ultra-low-latency structured-output endpoints of their own.

Why do we listen to people with no skin in the game?

Writing from the trenches of industrial software engineering, Redowan Delowar argues a simple rule borrowed from Nassim Taleb: if someone doesn’t bear the consequences of running the software in production, their opinions about how to build it are probably wrong. Influence does not equal correctness, and talking about code online is a completely different sport from shipping and maintaining production systems under real organizational constraints. A classic culprit is the “AI-pilled” executive or director who spends a Saturday afternoon vibe-coding a throwaway greenfield app, concludes that software engineering is completely solved, and shows up Monday demanding 10x feature velocity while dismissing compliance, legacy integration, and operational friction as excuses. Delowar uses LLMs heavily every day, which is precisely why he hits their sharp edges far more often than someone who only one-shots toy todo apps. You still have to humor your management chain to keep your paycheck, he notes, but never confuse organizational authority with technical truth—the person with real skin in the game is the one holding the pager when “vibe-slop” catches fire at 3 a.m.

The second group with zero skin in the game is software influencers peddling engagement-bait absolutes like “rewrite everything in Rust,” “TypeScript is dead,” or “Kotlin is Temu Java”—because nuanced engineering trade-offs don’t please social media algorithms, and selling hot takes and courses is far more lucrative than maintaining a five-year-old billing service. Podcast guests who actually built systems are often worth listening to, while professional hosts and course-sellers—many of whom pivoted seamlessly from JS framework bootcamps to Web3/NFTs and now to “AI agent mastery”—should be tuned out. Real companies choose tech stacks based on local hiring pools, iteration speed, and what the founding engineers already know, and LLMs haven’t changed that fundamental reality. Talk is cheap; always check whether the speaker will be around when the pager goes off.

You can run git on object storage if you re-make packfiles

Xe Iaso is building objgit, an open-source Git server backed directly by Tigris S3-compatible object storage. A naive first prototype that mapped loose Git objects onto an object-storage filesystem hit a brick wall on real-world repositories. At its core, Git is a content-addressable store of millions of tiny objects—the Linux kernel repository alone contains roughly 11 million objects, so fetching them one by one at 10 ms per GetObject HTTP call would take over 30 hours. Standard Git solves this with packfiles (.pack + .idx), which bundle objects together and delta-compress them, but the Git packfile format was designed around local disks and mmap, where random seeks cost nanoseconds rather than a 10 ms network round trip. Worse, standard .idx files record only each object’s byte offset and uncompressed size—not its compressed byte length in the pack—making it impossible to construct an exact HTTP Range: bytes=start-end request to fetch a single object out of S3 without reading neighboring headers.

Drawing inspiration from 1990s CD-ROM .bin/.cue rip files, Iaso designed a cloud-native packfile format for objgit: compressed objects are concatenated into .bin blobs capped at 128 MiB, while a separate binary “cue sheet” index stores every object’s offset alongside both its compressed and uncompressed sizes—effectively turning a Git repository into a columnar store. With the exact compressed byte span in hand, objgit can fire precise HTTP Range requests for individual objects at the tail of a packfile while streaming the full packfile in the background until the sequential download catches up, all compressed with zstd. Reinventing Git’s packfile format sounds like violating Chesterton’s Fence, Iaso admits, but because Git itself is distributed and content-addressed, if the server’s storage format breaks you can simply git push again from a local clone. The payoff was dramatic: pushing the Xe/x repository dropped from 3 minutes 29 seconds down to 14.3 seconds, and S3 API calls fell from over 9,000 down to 30. (objgit still lacks authentication and authorization, so don’t expose it to the public internet yet.)

Why CAFEBABE?

Back in May 1996, while writing his “The Class File Lifestyle” column for JavaWorld, Bill Venners got curious about the famous magic number sitting at the start of every compiled Java .class file: why must the first four bytes always be 0xCAFEBABE? Venners posted the question to the comp.lang.java Usenet newsgroup and archived the entire thread on this page. Readers chimed in with clever theories: a 32-bit magic number is fast to check on 32-bit architectures and unlikely to collide with ASCII text; the Java team wanted a coffee-themed hex constant, and since hexadecimal only gives you the letters A through F (no J or V), combinations using CAFE beat out alternatives like 0xAFABCAFE, 0xCAFEFACE, or the ominous 0xABADCAFE—while one reader wished they had picked 0x00C0FFEE (reading the leading zeros as the letters "OO" for “Object-Oriented Coffee”).

The Usenet thread also serves as a charming mini-museum of computing folklore around hex magic numbers: the Burroughs B6700 initialized unused memory to 0xBADBADBADBAD; classic IBM systems and AIX RS/6000s filled uninitialized memory with 0xDEADBEEF so pointer bugs jumped right out in a debugger; classic Mac OS placed 0x50FFC001 at address 0x0 so dereferencing a NULL code pointer would immediately trap; SGI IRIX started shared arena files with 0xDEADBABE; and debug builds of Solaris overwrote freed heap blocks with 0xCAFEFEED. Another reader pointed out that NeXTSTEP had already used 0xCAFEBABE as the magic number for multi-architecture “fat” binaries alongside 0xFEEDFACE for Mach-O object files. Finally, Patrick Naughton—one of the original members of Sun’s Green Project that created Oak (later renamed Java)—replied with the authoritative answer: he picked 0xCAFEBABE himself years before the name “Java” even existed! He simply wanted a fun, memorable 32-bit hex constant for the object file format, and 0xcafebabe beat out the runner-up 0xdeadbabe. Any connection to the baristas at Peet’s Coffee or the eventual name “Java” was pure serendipity.