Enjoy Newsletter #115.

Go Experiments Explained

Alex Edwards explains the experimental feature mechanism Go ships in each release: sometimes a new standard library package like testing/synctest, sometimes a compiler or runtime change like a new garbage collector, and more rarely a language behavior change like loop variable scoping before it became the default in Go 1.22. The goal is to gather real-world feedback before locking a feature in; if it causes problems or draws pushback, it can be revised or dropped entirely. The typical lifecycle starts disabled by default, flips to enabled by default after a release or two (often with a transition period allowing opt-out), and eventually retires the flag—though exceptions happen: Arenas was put on indefinite hold after negative feedback, while Swiss tables went straight to default.

Because there is no official status page tracking experiments, Edwards compiled a reference table for Go 1.26 from go doc goexperiment.Flags, the internal/buildcfg source, and release notes. To use them, pass comma-separated lowercase names in the GOEXPERIMENT environment variable to enable features, or prefix a name with no to disable it, across go build, go run, and go test. For everyday Go developers, the most notable flags are GreenTeaGC and Dwarf5 (already enabled by default, so worth knowing how to disable if issues arise), JSONv2, GoroutineLeakProfile for catching leaked goroutines, RuntimeSecret for code handling sensitive data, and RuntimeFreegc. One important caveat: experiments fall outside Go’s compatibility promise, so use them to test, benchmark, and give feedback rather than relying on them prematurely in production.

Low-Level Network Optimizations: Socket Options That Matter

This entry from the Go Optimization Guide examines socket options that directly impact latency and throughput in Go network applications. Operating system defaults prioritize safety and broad compatibility, meaning under heavy load they often become bottlenecks well before CPU or memory. TCP_NODELAY disables Nagle’s algorithm so small packets are sent immediately at the cost of higher bandwidth overhead; Go enables this by default on TCPConn. SO_REUSEPORT lets multiple processes or threads bind to the same port while the kernel distributes incoming connections across separate queues, reducing lock contention and scaling across CPU cores. Receive and send buffer sizes (SO_RCVBUF and SO_SNDBUF) should roughly match the bandwidth-delay product: too small increases syscalls and caps throughput, while too large wastes memory and inflates latency via bufferbloat.

For TCP keepalives, OS defaults are very conservative; common production settings wait 30–60 seconds, probe every 10–15 seconds, and retry 3–5 times, though tuning them too aggressively increases traffic and risks false drops on congested links. In Go, SetKeepAlivePeriod only controls the initial idle time; starting in Go 1.23, SetKeepAliveConfig lets you configure Interval and Count without dropping down to raw syscalls. SOMAXCONN governs the listener backlog queue and is tuned at the OS level via sysctl. To apply socket options at the right moment—before the socket is bound—use the Control callback on net.ListenConfig with syscall.RawConn. The overarching advice: change one setting at a time, test under realistic load, and rely on measurements rather than copy-pasting configs from elsewhere.

When Is 100% Vibe Coding OK ?

Viorel PETCU opens with the frustration of spending hours reviewing “vibe-written” specifications: they read smoothly on the surface but say almost nothing concrete and cannot be applied to an existing system. The author isn’t against vibe coding—in fact, he uses it regularly for one-off scripts, throwaway charts, quick parsers, or docs nobody has to maintain, where speed matters more than rigor. Once software needs long-term maintenance, however, the equation changes completely.

His motivating example is a wooden puzzle of 25 identical pentacube pieces that must pack a 5×5×5 cube. After failing to solve it by hand, he used Go and ChatGPT to write a solver: the initial struggle wasn’t the algorithm, but the domain representation—coordinate conventions, slice notation, piece rotations, and naming. Once the model stabilized, the rest was classic brute-force recursion with backtracking, and modern hardware was fast enough that no further optimization was needed. Within about two hours, the project evolved into a general solver complete with OBJ/MTL export for viewing in Blender. Crucially, the author was able to push past hallucinated constraints, wrong assumptions, and buggy code because he already knew for a fact that the puzzle had a physical solution. His conclusion: 100% vibe coding is fine when a human holds the invariants, the constraints are real, and the output is verifiable; if the requirements themselves are just vibes, the system has nothing solid to converge on.

Self-calling executables

Olivier introduces the “self-calling executable” pattern: a running program spawns another instance of itself, directly or indirectly, to take on a different role. The first use case is black-box testing a main function when the codebase relies on global state that causes in-process tests to interfere with one another. A test invokes the test binary itself via os.Args[0] along with an environment variable like TEST_MAIN; inside TestMain, if that variable is set, the binary runs the real entrypoint instead of the test runner, isolating each invocation inside a fresh child process.

The second use case is integrating with external tools, illustrated by jjui, a terminal UI for Jujutsu. The ssh command uses the SSH_ASKPASS environment variable to invoke an external helper when it needs a passphrase; jjui points SSH_ASKPASS back at itself so that when ssh prompts for a password, the grandchild process connects back to the main jjui process over a Unix domain socket (with the PID embedded in the path so multiple sessions can run concurrently), forwards the prompt, collects the user’s input, and prints it to stdout for ssh. Because this handles sensitive credentials, the author adds two safeguards: each child receives a random token it must present on connect, and the main process walks the connecting client’s ancestor PID chain to verify lineage. Downsides include harder debugging, risk of infinite recursion if environment variables are misconfigured, and the Go race detector sleeping for 1 second on every process exit—which once stretched Forgejo’s integration suite from 45 minutes to over 2 hours, fixable via GORACE="atexit_sleep_ms=0".

Modern Engineering Values

Christoph Nakazawa shares that he now rarely writes code by hand: projects like Vite+, fate, and Athena Crisis are largely written by coding agents, primarily via Codex CLI. His workflow is to have the agent propose a plan and ask clarifying questions before executing, require a failing test before fixing a bug, run several automated review passes, and only then review the diff himself. When writing code is no longer the bottleneck, discussing and reviewing code becomes the limiting factor.

From there, the post proposes a set of engineering values for the agentic era. Strong ownership: agents amplify engineers with deep product understanding just as much as they amplify noise from people lacking context, meaning effective teams will be small—around two to three people—with clear boundaries, and code review will focus on alignment rather than nitpicking individual lines. Good taste to know what is actually worth building. Tight guardrails and fast feedback loops—linters, automated tests, and tools that operate only on changed files—because working with agents is like onboarding a brand-new hire with zero context on every prompt. Keeping context inside the repo rather than scattered across docs, chat threads, or tribal memory. Owning your stack instead of pulling in heavy third-party dependencies, since agents have drastically lowered the cost of building in-house. As for management, he believes the role will become increasingly technical: as execution becomes cheap, judgment becomes the bottleneck.

Building Software Is Learning

Thorsten Ball publishes an internal note sent to the Amp team on why building new software is always a learning process. The idealized sequence—“we need this feature,” “I built it,” “that’s exactly what I wanted”—almost never happens without a detailed spec; reality usually looks more like “that’s not what I meant,” “there are three ways to do this, which one do we want?”, or “I tried it and I don’t like how it feels.” That is because people only truly understand what they are building while building it, and avoiding that discovery entirely would require specifying every detail up front—which is just programming by another name.

The good news is that you can shrink the gap between a confident “I’ll build it” and contact with reality. Instead of disappearing for four weeks, build a prototype in an hour, write a spec in thirty minutes, break the work down and ship a piece every day, cut scope to isolate the unknowns, record a fake demo video, write the release announcement first, or draft README examples to test an API design. Feedback can come from CI, teammates, users, or yourself dogfooding the feature. Ball adds two practical warnings: a prototype riddled with obvious bugs will only get you bug reports instead of useful design feedback, and keeping a branch alive for three weeks before merging 27 commits at once means when CI breaks, you have 27 potential culprits. The question to keep asking is how to get feedback as early and as often as possible so you can learn faster.

You Must Fix Your Asserts

Loris Cro argues against the habit of disabling assertions in production, using Zig as context. An assertion is a line of code stating a program truth—a precondition, postcondition, or invariant; if the type system can express the constraint, use types, and otherwise assertions catch programming bugs, often more effectively than unit tests when paired with fuzzing. In Zig, std.debug.assert is built on unreachable: in checked build modes like Debug or ReleaseSafe, a violated assertion panics; in ReleaseFast or ReleaseSmall, the compiler treats the assertion as an assumed fact for optimization, meaning a false assertion leads to unpredictable undefined behavior. Unlike C/C++, Zig’s assert is a regular function rather than a macro, so its argument expression is always evaluated.

According to Cro, you have three choices: keep assertions active as runtime checks, let the compiler optimize around them and accept the risk, or strip them out—and the third option is the worst. Disabling assertions means that when the “impossible” happens, the program keeps running on broken assumptions, silently diverging from its spec while stripping away the very signal that would have caught it. Worse, future maintainers will write new code trusting those false assertions, allowing vulnerabilities to creep in unnoticed. He points to TigerBeetle keeping assertions enabled in production and Ghostty shipping ReleaseFast builds. The takeaway: fix broken assertions, gate genuinely expensive checks behind debug-only flags, log instead of crashing where appropriate, and choose build modes based on your risk model rather than erasing error signals.

The Software Engineering Books I keep recommending

Dr. Milan Milanović shares the software engineering books he recommends most often, noting that reading gives him both breadth and depth in technical discussions and decision-making—and in the AI era, helps him evaluate and steer AI tools more effectively. Rather than presenting a one-size-fits-all “must-read” list, he groups the books by the specific problem a reader is facing, arguing that the right question isn’t “what should I read?” but “where am I currently stuck?” Most of the picks aren’t tied to specific frameworks, so their lessons age well.

For coding mindset, he highlights The Pragmatic Programmer, Clean Code (noting some rules are dated), and A Philosophy of Software Design, the book he re-reads most often. Architecture covers Fundamentals of Software Architecture, Software Architecture: The Hard Parts, and Domain-Driven Design Quickly; systems and data feature the second edition of Designing Data-Intensive Applications alongside the more approachable Understanding Distributed Systems. The AI section pairs The Hundred-Page Language Models Book on how language models work with Chip Huyen’s AI Engineering on building real-world AI applications. Rounding out the list are The Art of Unit Testing for testing, Accelerate (with the four DORA metrics) and Refactoring for development workflow, and The Software Engineer's Guidebook and Deep Work for career growth. He also mentions his own new book on laws in software engineering.


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.