Newsletter #45
This post was put together using Cline + Kimi K2. Enjoy Newsletter #45.
The Best
In his essay “The Best Essay,” Paul Graham asks: what would the best possible essay look like? His first answer is that it must tackle the most important topic about which one can still say something surprising—but that line of thought leads toward major scientific discoveries, which are tied to the moment of their discovery rather than being timeless. So he reframes it into a more practical question: how do you write a truly great essay? According to Graham, everything starts with a compelling initial question where the writer has a fresh perspective or a distinct approach.
The writing process turns vague ideas into concrete prose, followed by ruthless rereading and revision until the gap between the current answer and the truth becomes visible—sometimes opening up an entirely new direction. An essay works like a recursive exploration: each answer spawns new questions, and the writer should follow whichever branch offers the best combination of generality and novelty, ready to discard whole passages already written if they no longer serve the main thread. Although the initial question caps the maximum quality of the essay, Graham advises against being overly cautious when choosing topics; instead, write a lot, because most questions can yield a good essay. The ability to ask great questions comes from broad knowledge and deep experience across multiple fields.
AI Tools Make Developers 19% Slower, Not Faster
The research organization METR conducted a randomized controlled trial with 16 experienced open-source developers across 246 real tasks in their own repositories, which averaged over 22,000 stars and more than one million lines of code. Each task was randomly assigned to either allow or disallow AI tools (primarily Cursor Pro with Claude 3.5/3.7). The results were surprising: before the experiment, developers predicted AI would make them 24% faster; after finishing, they still felt they had been 20% faster; yet the actual measurements showed they were 19% slower when assisted by AI.
The researchers emphasize that these findings apply specifically to this setting and do not represent the entire software industry; future models or more effective usage patterns could yield different outcomes. The slowdown appeared consistently across multiple metrics and stemmed from several factors at once: when allowed to use AI, developers spent time prompting the AI, waiting for responses, reviewing AI output, and idling, rather than directly writing code or looking up documentation. The takeaway is that the gap between subjective perception and actual productivity can be huge, so measure rather than relying on gut feeling when evaluating new tools.
Evolution of Uber’s Search Platform
This article recounts the three-stage evolution of Uber’s search platform. Initially, Uber treated Elasticsearch (built on Apache Lucene) almost as a “black box,” with engineers focused mainly on keeping operations stable. A major limitation was Lucene’s near-real-time mechanism: new data became searchable only after being flushed to the index, introducing latency in time-sensitive scenarios like matching riders with drivers. Starting in 2019, Uber built Sia in-house, extending Lucene with an in-memory live index for real-time search, switching to lighter-weight gRPC/Protobuf communication, pull-based ingestion via Kafka, and active-active multi-region deployment. However, the complex custom architecture made it very difficult to adopt new Lucene features such as vector search, while most use cases didn’t actually need real-time freshness.
In 2024, with Project Sunrise, Uber recognized that maintaining a custom fork was no longer sustainable and migrated to OpenSearch, becoming a founding member of the OpenSearch Software Foundation. The current architecture separates the write path from the read path: data from Kafka is compacted into optimized segments and uploaded to remote storage, while search nodes simply download them to serve queries, keeping all ingestion overhead off the query path. Uber also contributed features back to OpenSearch 3.0, including pull-based ingestion and gRPC APIs. The lesson: custom-built solutions are expensive to maintain when the ecosystem moves fast, and complexity should only be accepted where it is genuinely needed.
Vercel
Lee Robinson reflects on his five years at Vercel, where he grew from an individual engineer to VP, watching the company scale from 30 people and $1 million in ARR to 650 people and over $200 million. His first lesson is work-life balance: he once answered work messages even during his honeymoon, and only broke free by building processes and hiring people capable enough to run things themselves. Second, speed is a competitive advantage: asking “what would it take to ship this next week?” forces teams to find creative solutions, and even if you miss the deadline, you still finish faster than if you had set none at all.
Third, scaling requires hiring rather than doing everything yourself—always be recruiting, keep the bar high, and only hire candidates who genuinely excite you. Fourth, avoid unilateral decisions: he once parachuted into a product launch at the last minute and demanded changes without full context, something he regrets; leaders should get involved early and build consensus before making calls. Finally, stay adaptable and admit mistakes: personally reviewing every company social media post created a bottleneck, and delegating ownership alongside clear quality guidelines produced better results. These are valuable lessons for any developer moving toward a leadership role.
Tools
Armin Ronacher, creator of Flask, argues that when working with AI agents, “code is all you need.” He critiques the MCP protocol, which lets language models invoke external tools and services: this approach is hard to compose because every step depends on model inference, consumes substantial context on each tool call, and scales poorly when automating repetitive tasks. In his view, without AI, a software engineer solves problems by writing code—so AI should do the same.
Model-generated code has explicit logic that humans can inspect, runs repeatedly at low cost once written, and is easier to debug. As an illustration, Armin describes migrating his entire blog from reStructuredText to Markdown: the model wrote AST-based conversion scripts, wrote additional scripts comparing the old and new HTML to verify the output, and iterated on that feedback loop with almost no human intervention. Here, the model acted as a code quality evaluator rather than manually executing each step. He concludes that MCP looks like a dead end for large-scale automation, and a more promising path is combining code generation with having the model evaluate the results after execution.
How I Build Software Quickly
Evan Hahn shares how he builds software quickly while maintaining acceptable quality. The core principle is balancing speed and quality: aim for “8 out of 10, delivered on time” rather than chasing perfection. What counts as “good enough” depends on context—a 24-hour game jam tolerates messy code, whereas a pacemaker demands excellence—so you need to understand what your team considers good enough. He recommends building a rough draft first, full of TODOs, hardcoded data, and unhandled errors, to uncover unforeseen problems early, avoid wasting effort on code that will be thrown away, and prevent premature abstraction.
Doing less is also a way to move faster: question the scope, combine screens, skip unnecessary edge cases, or trim API parameters. To stay focused, he sets timers for tasks and pair-programs. Small changes are easier to write, review, revert, and debug—for instance, fixing a bug, upgrading a library, and adding a feature in separate changes. The skills that speed him up most include reading code (the most important one), data modeling, writing automation scripts, using a debugger, taking breaks, writing pure functions, and leveraging LLM tools.
The Most Mysterious Bug I Solved at Work
Cadence recounts the most mysterious bug she ever solved on an electronic patient referral application in Australia, a system that converts referral data into HL7, CDA, or PDF formats to send to healthcare providers. Occasionally, the system threw the error Illegal Character entity: expansion character (code 0x2) not a valid XML character. Character 0x2 (Start of Text) is an obsolete control character from the early days of computing with virtually no modern use—yet it was showing up inside referral letters typed by doctors.
Investigation gradually uncovered the clues: the affected letters all had unusual hard line breaks, and the same doctor was submitting identical letters multiple times. It turned out the doctor was copying text from PDFs of previous referrals stored in their practice management software, and character 0x2 appeared right where hyphens sat at the ends of lines in the PDF. The culprit was Microsoft Edge’s built-in PDF viewer—the default on Windows—which mistakenly converted end-of-line hyphens into 0x2 when copying text. The team fixed the issue by automatically replacing 0x2 with a hyphen rather than stripping it, preserving the intended text. The story reminds developers that the root cause of a bug sometimes lies outside the codebase, in users’ habits and the tools they rely on.
How to Think About Time in Programming
Shan Rauf lays out a clear mental model for handling time in programming. The foundation is absolute time, consisting of “instants” and “durations”: an instant is represented as seconds elapsed since a reference point called an epoch (Unix uses January 1, 1970), while a duration is the length of time between two instants, so comparisons and calculations require only basic arithmetic. Humans, however, use civil time based on the Gregorian calendar, with months of varying lengths. UTC defines the second using atomic clocks and occasionally inserts leap seconds to stay aligned with Earth’s rotation, meaning a day can be 86,401 or 86,399 seconds long; JavaScript’s Date ignores leap seconds. Time zones are not fixed offsets but evolving sets of rules: during daylight saving transitions, certain civil times are skipped or repeated twice, and the IANA time zone database (such as America/New_York) records known rules and historical transitions, though it does not guarantee accuracy for every location prior to 1970.
In practice, chat messages should be stored in UTC and displayed in the viewer’s local time zone. For events, intent matters: a class held at a physical location should be stored as local time plus a time zone identifier, whereas an absolute event like a solar eclipse should be stored in UTC. The author recommends bundling the IANA database and updating it regularly, using Unicode CLDR data to display friendly time zone names, and never assuming a UTC offset is immutable. The advice “just use UTC” isn’t enough, because converting to UTC too early discards information about the user’s original intent.
Phrase origin: Why do we “call” functions?
Arthur O’Dwyer investigates why we say we “call” a function. There are three intuitive hypotheses: calling as in visiting a friend (dropping by, staying a while, then leaving), calling as in summoning a servant to do a task, or calling on the telephone to ask a question and get an answer. The real answer is closest to the second hypothesis, but via a detour through library science: in closed-stack libraries, patrons “called for” books by their shelf mark—the term “call number” coined by Melvil Dewey in 1876. Early computer scientists borrowed this metaphor for subroutine libraries, where programmers “called” prewritten routines off the shelf much like a librarian retrieving a book by its call number.
The timeline shows the evolution clearly: in 1947, John Mauchly wrote about subroutines being “called in” from a library on magnetic tape; in 1956, MANIAC II assembly used a “call number” to identify subroutines; in 1958, Fortran II introduced the CALL statement, turning “call” into a runtime action; around 1959–1960, Algol and other languages adopted the term; in 1961, the verb phrase “call a subroutine” was first recorded in Burroughs documentation; and by 1963, modern usage had settled into MIT’s curriculum. The author concludes that Fortran II’s CALL keyword is what cemented “call” as the standard verb for invoking a function.
After testing again with many URLs, it seems Cline + Kimi K2 overflowed its context window; after compacting, it forgot parts of the context and easily got confused, needing repeated reminders that this environment is Windows and requires PowerShell-compatible commands instead of Linux ones. On top of that, it made a few silly mistakes like summarizing… the wrong URL :>
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