Enjoy Newsletter #133.

Why Go is an Ideal Language for AI-Assisted Software Engineering

Cameron Balahan and Richard Seroter from Google argue that the bottleneck in software engineering has shifted: when AI can generate hundreds of lines of code in seconds, the hard part is no longer writing code, but reviewing, verifying, and maintaining it. Languages designed from day one for long-term team collaboration have a natural edge, and Go was built at Google for exactly that purpose. Go is a complete platform: its standard toolchain ships with gofmt, a built-in testing framework, module management, and security tooling, alongside a rich standard library that minimizes third-party dependencies. Because Go favors explicitness over cleverness or terseness—and enforces a single canonical format across human- and LLM-written code alike—spotting hallucinated API calls or subtle logic bugs during code review becomes much easier.

On the reliability front, static typing and blazing-fast compilation create a tight self-correction feedback loop for coding agents. Go’s checksum database guards against tampered dependencies, while govulncheck alerts only on vulnerabilities in functions your code actually calls. For long-term maintenance, the Go 1 compatibility promise protects source compatibility within its documented scope; static binary compilation simplifies deployment (subject to configuration and C library dependencies), and go fix lets agents deterministically modernize legacy idioms. While the post makes a conceptual argument rather than presenting empirical benchmarks, its takeaway is clear: AI is a high-velocity teammate that needs sturdy guardrails, and Go provides them out of the box.

How does programming language affect token efficiency and correctness?

A popular claim holds that dynamically typed languages are more token-efficient than statically typed ones when working with large language models. Dan Luu puts this claim to the test, starting by auditing two existing benchmarks commonly cited in its favor. The first measures token counts on Rosetta Code tasks, which are too tiny and self-contained to generalize to real software. The second had a path bug that caused Rust and Haskell to fail unfairly alongside a broken test harness that passed regardless of output; once fixed and re-scored, Rust achieved a perfect score. Luu then builds two realistic benchmarks of his own: having agents write a complete zstd decoder from scratch using only the RFC specification (graded against a hidden test suite), and re-implementing a subset of Pandoc (graded against a held-out test suite).

The results tell a nuanced story: on zstd at medium reasoning effort, dynamic languages appear to have a slight edge, but at maximum reasoning effort several statically typed languages take the lead. Clojure failed 36 out of 40 runs at medium effort, largely because its signed byte coercion throws an exception on values 128–255. Assembly and niche languages performed poorly, while overall language popularity correlated modestly with both higher correctness and lower token cost. Notably, nearly every C and C++ Pandoc implementation contained memory-safety bugs that passed functional tests undetected. While Luu cautions that two benchmarks aren’t enough to draw universal laws, the blanket claim that “dynamic languages are better for LLMs” doesn’t hold water; picking a popular mainstream language is a sensible default, and clear specifications help across the board.

My Agentic Coding Setup, July 2026

Domenic Denicola shares the agentic coding setup he converged on after months of experimentation—one that lets him steer frontier models to fix bugs on real projects straight from his phone while riding the train. His requirements are concrete: agents must run on Linux because they are far more fluent in Bash than PowerShell; sessions must roam seamlessly between his desktop, laptop, and phone without losing state; multiple agents must work in parallel on the same repository; and interactive permission prompts must be nearly eliminated. The foundation is a “semi-disposable” Ubuntu VM running on an always-on desktop, connected to all his devices over a private Tailscale tailnet for SSH and HTTPS access from anywhere. Inside the VM, he runs Claude Code and Codex CLI in full-auto (--dangerously-skip-permissions / --yolo) mode with gh pre-authenticated so agents can manage repos, PRs, and CI autonomously. He readily admits this setup isn’t hardened against a determined prompt-injection attack, relying primarily on pushing commits to GitHub early and often as his safety net.

The remaining pieces solve each workflow friction point: git worktree lets multiple agents work on the same repo in parallel (he prefers Codex/ChatGPT’s worktree layout because Claude nests worktrees inside the project directory), VS Code Remote-SSH handles deeper code review, a tool called Portless wrapped over Tailscale gives every dev server its own private HTTPS URL accessible only on his tailnet, and chezmoi syncs his AGENTS.md, skills, and dotfiles across machines. Remaining rough edges include adopting devcontainers for tighter isolation, session histories being tightly coupled to directory paths, and the lack of automated durable backups for agent transcripts.

The Bedrock of Software Design

Alex Fedoseev argues that algebraic data types (ADTs) have shaped how he designs software more than any other concept—and that they are far simpler than their academic name suggests. Product types combine multiple fields into a single value, like a struct with an id and a role; sum types (tagged unions) express that a value is one of several mutually exclusive variants, each carrying its own specific data—for example, a session that is either Anonymous or Authenticated(User). When business rules live scattered across comments and runtime validation helpers, they are easy to forget. Instead of modeling a UI component with a boolean flag plus several nullable fields that are only valid in certain combinations, you model it as a sum type with Switchable and Fixed variants, each holding only the fields that actually apply, making illegal states unrepresentable.

The same thinking applies to errors and the absence of values. With unchecked exceptions, a function’s type signature shows only the happy path; in Rust or OCaml, expected failures are returned explicitly via Result, whose error type can itself be a domain-specific sum type carrying rich context. Option<T> replaces null, and a signature like Result<Option<User>, FindUserError> cleanly distinguishes three outcomes: found, not found, and lookup failed. Exhaustive match expressions force callers to handle every variant, so when a new Staff role is added, the compiler points to every single place in the codebase that needs a decision. Fedoseev’s conclusion: sum types and exhaustive pattern matching should be table stakes for any modern programming language.

90 % of the t distribution

This post reminds readers that small sample sizes make uncertainty estimation harder and introduces Student’s t-distribution as a practical tool. However, the formula in the original post conflates a prediction interval (or standard-deviation band) with a confidence interval for the mean. For independent observations drawn from a normal distribution with unknown variance, a two-sided 90% confidence interval for the population mean is $\bar{x} \pm t_{0.95,, n-1} \times \frac{s}{\sqrt{n}}$, where $s$ is the sample standard deviation—dividing by $\sqrt{n}$ to get the standard error of the mean cannot be omitted.

With $n = 7$ observations, a sample mean of 32 minutes, and $s = 8$ minutes, the critical value $t_{0.95,, 6} \approx 1.943$ yields a 90% confidence interval for the mean of $32 \pm 5.88$ minutes. The rounded multiplier table in the article illustrates how t-multipliers widen relative to a normal distribution at small $n$, but you still have to pick the right interval formula (confidence interval for the mean vs. prediction interval for the next observation) for the question you’re asking. And with just $n = 2$ observations, sample variance is too noisy to draw firm conclusions about whether a third measurement is an outlier.

Your agent needs a computer, not a container — introducing @cloudflare/computer

Cloudflare has released a preview of @cloudflare/computer, an open-source, npm-installable agent runtime that gives every AI agent its own virtual “computer” complete with a filesystem, shell, tools, and code execution. The core thesis is that spinning up a dedicated Linux container per agent will never scale economically when hundreds of millions or billions of agents run concurrently. Lightweight V8 isolates are a much better default: they spin up and tear down in milliseconds, hibernate for free when idle, persist state automatically, and scale horizontally—reserving full Linux containers only for the subset of tasks that genuinely need a complete OS environment. Cloudflare’s target is for containers to handle less than 10% of an agent’s workload.

Architecturally, the runtime decouples the agent’s “brain” from its “hands”: the agent loop lives inside a Durable Object, while a container can be attached on demand and invoked like a tool. The workspace is a virtual filesystem backed by SQLite, seeded from cloud object storage or a Git repo, exposing read, write, edit, list, and exec operations alongside a node:fs-compatible wrapper. Two execution backends sit behind a unified exec interface: the isolate backend uses just-bash to interpret shell commands in pure JavaScript, while the container backend mounts the workspace via FUSE to sync file changes seamlessly. Every file operation is audited and logged, and the LLM itself chooses whether a command needs the full container or can run in the fast isolate—a routing decision frontier models handle surprisingly well.

Notes on incidents

Sean Goedecke shares candid lessons from years of on-call incident response. First, most incidents are surprisingly boring and consist mostly of waiting: waiting on another team, waiting on a deploy pipeline, or waiting for someone to wake up to a page. In his experience, a huge share of incidents self-heal automatically as Kubernetes restarts crashed pods or queues drain a transient traffic spike—he estimates that over half the incident calls he has joined would have resolved in roughly the same time even if nobody had touched a thing. Conversely, frantic “firefighting” often makes things much worse: purging a backed-up production queue to fix latency can accidentally wipe out unbilled usage records, turning a brief latency blip into a major billing incident. Consequently, the best first move on joining an incident call is often to do nothing at all—go make a cup of tea or take a five-minute walk while gathering facts.

When intervention is needed, effective fixes are almost always dead simple, like flipping a feature flag off or reverting a recent deploy. The single biggest asset during an outage is deep system familiarity: an engineer who knows the codebase inside out will spot the culprit flag or commit in minutes. That engineer also needs the decisiveness to state clearly on the call what they plan to do, pause briefly for objections, and execute. While visible incident heroics can win praise from leadership, Goedecke warns against relying on firefighting for career capital, since executives rarely distinguish genuine heroics from obvious one-line reverts—and the best incident is still the one that never happens.

Beyond “Clean Code”: Why Your Comments Matter

Tom Moertel argues that good comments are an indispensable part of well-engineered code. Code logic can only express what the machine is instructed to do, whereas human readers also need to know what the author intended and why the code was written that way—information that is often best communicated in plain prose. You should make code self-explanatory where it comes naturally, but you shouldn’t contort control flow or invent awkwardly long identifier names just to avoid writing a comment. While Moertel agrees with Robert C. Martin’s Clean Code that comments shouldn’t be used as deodorant for needlessly tangled code, he argues that the dogma “every comment is a failure” goes way too far. Crucial “why” context—like a global lock acquisition ordering to prevent deadlocks, an array length invariant, or why a brute-force search is safe because the input is guaranteed to have at most five elements—cannot be deduced from local syntax alone.

Moertel offers a simple litmus test: squint at the code and ignore all the identifier names; if the structural shape looks more convoluted than the underlying algorithm requires, you may be bending the code into pretzels to avoid writing a comment. He also dismantled common anti-comment tropes. “Comments lie”: without a comment stating the intent, buggy code leaves zero clue that it’s doing the wrong thing, whereas a contradiction between a comment and the code is a valuable signal to investigate. “Comments rot”: stale comments are a code-review culture problem, solved by reviewing comments with the same rigor as code rather than banning comments altogether.

Relying on Go

Many new programming languages pitch themselves as “like Go, but with more features” or “like Rust, but simpler.” Anton Zhiyanov takes the opposite path with Solod, a “systems language for C and Go programmers”: instead of forking Go or inventing Go-like syntax, Solod is a strict subset of valid Go. Because every Solod program is syntactically valid Go, it inherits the entire Go ecosystem for free on day one: syntax highlighting, gopls autocomplete, linters, formatters, and go.mod package management. The developer workflow is identical to Go: install the so CLI tool, initialize a Go module, import Solod’s standard library package, and write normal Go code; so run . compiles and runs the binary just like go run. Even Solod’s standard library reuses large swaths of Go’s standard library code and test suites, adapted for manual memory management.

Zhiyanov is upfront about the trade-offs: standard Go tooling doesn’t know about Solod’s subset restrictions, so gopls won’t warn you if you use unsupported Go features like closures or iterators—catching those is up to the so compiler. Nor is ported Go code automatically memory-safe in Solod without its own tests. Under the hood, so transpiles Go syntax into readable C11 and compiles it via GCC or Clang, benefiting from decades of C compiler optimizations; because there is no Go runtime or garbage collector, C interop has zero FFI overhead. His broader message: a new language doesn’t have to bootstrap a brand-new tooling ecosystem from scratch—leaning on Go is Solod’s greatest strength.


This post was reviewed and updated 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.