Newsletter #114
Enjoy Newsletter #114.
Go errors are a story, most teams lose the plot
Robin Siep examines a fundamental difference in how Go handles errors: unlike Java and many other languages, Go errors do not automatically carry stack traces. Instead, developers wrap errors with context at each layer they pass through—such as fmt.Errorf("unable to get user: %w", err)—ultimately producing a chain like unable to get user: failed to query users table: connection refused. The author calls this a “logical trace”: when maintained well, it is easier to read than a multi-dozen-line stack trace and stays intact even when errors cross channels, goroutines, or other handoff boundaries where call stacks can get lost.
The catch is that a logical trace requires relentless discipline from the entire team. Forget to wrap an error at just one call site, and your logs may be left with a bare connection refused; and much like code comments, an error-wrapping message written two years ago can drift out of date or become misleading. In the author’s observation, most teams fail to keep up with this maintenance burden, leaving production errors without enough context to diagnose root causes. The proposed middle ground is to attach a stack trace the moment the application creates an error or first receives one from a third-party library, and then add manual context only when it genuinely clarifies the problem. That way, the stack trace serves as a cheap, always-present fallback. Implementing this yourself is straightforward, or you can reach for Dave Cheney’s pkg/errors or cockroachdb/errors if you want an actively maintained library.
The Last Technical Interview
Steve Yegge—who has conducted technical interviews for nearly 35 years, serving as an Amazon Bar Raiser and a Google Hiring Committee member—argues that the traditional technical interview loop is reaching the end of the line. The model of cramming several one-hour interviews into a single day has barely changed in fifty years despite terrible results: interviewers routinely disagree with one another, interview scores barely correlate with actual on-the-job performance, and resumes are becoming increasingly useless now that AI writes them. His most memorable anecdote comes from Google, where recruiting handed the hiring committee a batch of anonymized interview packets disguised as a “calibration exercise”; the committee voted to reject roughly two-thirds of them, only to learn afterward that the packets were their own historical interview files.
According to Yegge, the strongest hiring signal has always come from real work—internships, six-month co-ops at Geoworks, or contract-to-hire trials—so it is time to stop “simulating work.” A new “campfire” model is emerging in San Francisco: inviting candidates for a paid multi-day stint working on real code, real requirements, and alongside the real team. To make this fair, every stint should “count twice”: the company gets high-signal evaluation and real output, while the candidate walks away with a durable, company-verified record of what they built and how well they performed, whether or not they receive an offer. Such a system only works if those “stamps of approval” are issued honestly.
Guidelines for Respectful Use of AI
Camille Fournier argues that many leaders view AI policies purely through the lens of security, compliance, or cost, overlooking how teams actually work together when AI enters the picture. AI lets an individual generate far more output, but if that person doesn’t review it themselves, the quality-control burden simply gets pushed onto teammates and overall team productivity drops. Her first rule is therefore simple: never ask someone else to read or review something you haven’t read yourself. This applies to code and even more so to documents, since the context in your head while chatting with an AI may be completely absent from the final text; if you cannot explain and discuss a document yourself, you shouldn’t send it out.
Her second rule is “shorter is better”: AI-generated code often reads like verbose tutorial code, pull requests balloon to thousands of lines, three-page documents turn into 10-to-20-page essays, and Slack messages and emails become walls of text. She suggests a litmus test: if this change breaks at 3 a.m. and every AI tool is down, can you debug it yourself? For long documents, put a concise summary of the key points right at the top; if you find yourself writing a massive email to explain something, you should probably hop on a call instead. Ultimately, AI is not an excuse to turn off your brain or your empathy: use the productivity gains to ship simpler, better-tested work.
Software After AI
Tomasz Tunguz argues that the familiar software era—where SaaS products manage databases through fixed workflows—is giving way to the era of the “harness”: the surrounding layer that turns a raw LLM into a reliable agent. He compares an LLM to a wild horse that needs to be broken in. When every company has access to the exact same foundation models, competitive advantage no longer lives in the model itself, but in whoever builds the best harness.
The post outlines seven components of an AI harness. Context and memory require domain-specific retrieval alongside a “context database” capturing how a business actually operates. Tools and actions are exposed through a registry with parameter validation and approval gates for sensitive operations, with MCP acting as the connective tissue. Orchestration is the think-act-observe-repeat loop, complete with planning, subagents, and stopping conditions. State and persistence allow a mid-flight failure to resume from the last verified checkpoint (for instance, finishing step 7 and resuming at step 8) instead of starting over from scratch. Sandboxing isolates the execution environment. Observability and governance—traces, logs, evals, and human-in-the-loop approvals for high-stakes decisions—turn a demo into a production system. Finally, cost and workflow optimization decide which steps belong in deterministic code and which call for large or small models. Frontier labs will win the markets they prioritize, but thousands of vertical markets remain wide open for startups.
Design Patterns Are Dead. Long Live Design Patterns.
Christina Lin, a veteran developer, asks whether classic design patterns still matter when AI writes most of the code. Patterns like Singleton, Factory, and Observer were created for human comprehension rather than compilers, so at first she wondered if they had become obsolete. Once a codebase grows large enough, however, AI starts to ramble because it has limits of its own: Chroma’s research across 18 models showed reliability degrading as input length grows (“context rot”), with the drop-off varying by model. As a result, design patterns aren’t dead—they’ve been promoted from implementation blueprints to ways of compressing intent into prompts and enforcing architectural guardrails around probabilistic models.
Lin reclassifies patterns around a single question: is this pattern here to help humans read code, or to constrain AI? Patterns that merely patched missing language features, like Iterator or Prototype, are dead; speculative abstractions built “just in case” should also be pared back now that code is cheap and intent is expensive. Conversely, three patterns matter more than ever: Adapter forces AI outputs into strict schemas before touching the database and feeds validation errors back for self-correction; Decorator wraps retries, timeouts, and token-cost tracking around core logic; and Facade hides complex multi-step agent workflows behind a clean, auditable interface. The unifying principle is treating AI output as untrusted input: isolate it, validate at the boundary, and trust it only once proven valid.
Merge Intervals
Jaspreet Singh walks through Merge Intervals, a classic interview problem: given an array of [start, end] intervals, merge all overlapping intervals and return the disjoint result. At first glance it looks like a simulation problem, and the brute-force approach checks every subsequent interval to extend the current end point in O(N²) time. The key insight is that once intervals are sorted by start time, any overlapping intervals are guaranteed to sit adjacent to one another, so you only ever need to compare the current interval against the most recently merged one.
That makes the optimal algorithm clean and compact: sort by start and scan left to right; if the end of the last interval in the result list is smaller than the current interval’s start, append the current interval as a new entry; otherwise, update the last interval’s end to the maximum of both ends. For input [[1,3],[2,6],[8,10],[15,18]], this produces [[1,6],[8,10],[15,18]]. Overall time complexity is O(N log N) due to sorting, while the linear scan takes O(N). The author also shares interview tips: clearly explain why sorting makes overlapping intervals contiguous, and remember the “sort first, then sweep left to right” pattern for related problems like Insert Interval, Meeting Rooms, and Non-overlapping Intervals.
Best Time to Buy and Sell Stock
Jaspreet Singh follows up with another classic LeetCode problem, Best Time to Buy and Sell Stock: given an array of daily stock prices where you may buy once and sell once on a later day, find the maximum profit. For [7,1,5,3,6,4], buying at 1 and selling at 6 yields a profit of 5. The brute-force approach treats every day as a buy day, checks every subsequent sell day, and tracks the maximum profit—correct, but O(N²) because it evaluates far too many redundant buy-sell pairs.
The key observation is that on any given day, you don’t need to remember every prior price—only the lowest price seen so far, because the best profit you could make by selling today is today’s price minus that historical minimum. The author notes that he initially considered a dynamic programming array dp[i], before realizing that the minimum price is the only state that matters, collapsing the array into two scalar variables: minPrice and maxProfit. A single pass that computes today’s potential profit, updates the best answer, and updates the running minimum achieves O(N) time and O(1) space. This is the classic “prefix minimum” pattern: whenever a problem asks for a maximum profit, maximum difference, or future outcome relative to past values, think about maintaining a running minimum or maximum during a single sweep.
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.
Comments