- Obituary for a Quiet Life — THE BITTER SOUTHERNER — The idea I keep turning over is that contentment with a small life is actually subversive, a quiet refusal of the American reflex to keep climbing. Jones writes his grandfather Ray as a man who got fired from mills for refusing unsafe work and organizing, then spent decades on biscuits and trash runs and “Hey thar, pretty girl,” and the essay insists those ordinary acts are the holy part. What got me is the frustration underneath the form, how an obituary’s standardized fields can’t hold a dialect where things “liked to happen” or went “ever which a’way but loose.” It made me wonder what I’d want counted at the end, and whether the stuff that actually rippled outward would even make the page.
- RIP, vector database — The inversion is the whole post, turbopuffer is demoting ANN search from the organizing principle to just another secondary index, and a vector database that stops being vector-first is a fun thing to publish under your own name. The argument that landed is that making the vector the primary key poisons everything else, you duplicate non-vector data per embedding, SPFresh rebalancing drags whole documents around, and query plans get pinned to 100 to 200 doc clusters so the CPU never gets a big enough block to chew on. Their FTS numbers are the proof they lead with, moving from ~1.5 postings per block to fixed 256-doc blocks made the index 10x smaller and queries up to 20x faster. The lesson I’m taking is broader than search, the primary layout decision quietly sets the ceiling on every access pattern you bolt on later.
- The most important product decision is what you don’t build — The move I want to steal is selling restraint with running cost instead of build cost, because “this is cheap to ship” always wins the room until you show the years of maintenance across iOS, Android, and web. His two failure shapes are painfully familiar, the document hub that mutates into a worse Google Drive and the notification bell that becomes a bad Gmail clone, both arriving one reasonable request at a time. The bit that reframed it for me is that we’re wired to miss subtractive fixes, and removal gets treated as lesser work while McGovern’s data shows cutting most of a site’s content raised sales. I’m less sure the “makes the boat go faster” test is as clean in practice as it reads, since the hard cases are features that help one loud segment and quietly tax everyone else.
- What Even Is An OS Now? — The framing that caught me is that an OS mostly exists to wall untrusted software off from itself, so if all your apps share one provenance because you generated them, that whole security apparatus is overhead you’re carrying for a threat that’s gone. He pushes it to software that was never worth building commercially, the hyper local weather tool or the one-off commute optimizer, things too trivial to ship but trivial to conjure on demand. The line about today’s systems being frozen in 1970s thinking, built for fixed-function apps from a priesthood, is the kind of provocation I enjoy even when I don’t fully buy it. Where I get skeptical is the clean premise that your own generated code is automatically trustworthy, since the model wrote it, it pulls in who knows what, and “I asked for it in English” is not the same as “it’s safe.”
Reading log
A reading log that automatically updates every week.
I save articles to my read-it-later app and write quick thoughts as I read. An automated task pulls everything I've read during the week, uses AI to review the content and expand my notes into something more coherent, then publishes them here.
- Semantic Search Without Embeddings — The insight that reframed this for me is that embeddings nail representation and similarity but are weak at the third piece, deciding what’s actually in or out. Doug’s point that there’s no magic 0.8 threshold where something stops being a match is the crack in the whole vector-search story. His alternative, a path hierarchy tokenizer plus BM25 over a managed taxonomy, is old school in a way I found convincing, because BM25 rewards the specific category naturally since it has lower document frequency. The “long johns” versus “base layers” example is the one I’ll keep, and the real twist is that LLMs quietly make taxonomy maintenance feasible again, which is what makes the argument land now instead of five years ago.
- Choose Boring Technology — I’d absorbed the innovation tokens idea secondhand for years, but the original is sharper: you get about three, every unusual choice spends one, so save them for the actual business and not the infrastructure. What I hadn’t internalized is his framing of unknown unknowns, boring tech wins not because it’s good but because its failure modes are already documented. The Etsy story is the gut punch, a pointless middle layer that took years to remove while search latency hit two minutes and they shipped nothing. Still chewing on where the line sits, because “boring everything” is also how you end up unable to hire or move.
- EXTREME SERVER SIDE RENDERING — The trick is dumb in the best way, keep the HTTP connection open forever and stream CSS updates so the page animates with zero JavaScript. A server-side Flappy Bird running physics at 60 FPS and pushing CSS is the kind of thing that shouldn’t work, and the numbers are wild, around 500 concurrent games per core and 20 KiB/s each. Latency is the wall it can’t climb, round trips make it unplayable far from the server, which is the whole reason we moved logic to the client in the first place. My favorite detail is that it accidentally caused rolling blackouts on Fediverse servers because nothing expects a connection that never closes.
- simple is not small — The distinction I keep coming back to is Hickey’s, simple means one braid, complex means braided together, and small is a totally separate axis. The word-count example nails it, the Unix pipeline is tiny but couples aggregation to ordering, so the moment you want original file order it collapses into temp files and joins. Google Drive is enormous and still feels simple because its parts are decoupled, which inverts the instinct that fewer lines equals cleaner. The uncomfortable takeaway is that fixing complexity sometimes makes the program bigger, and that decoupling well is taste, which is the hard thing to teach.
- Doing everyone else’s job — The stat that reframed the Pareto cliché for me is his sharpening of it, 20% do 80% of the work, but the goal only gets reached thanks to the under 5% who do the thing someone else was supposed to do. The Intel patching Microsoft’s compiler story makes the point that this isn’t charity, you fix the neighbor’s problem because your own success runs through theirs. What resonated is the patch-the-dependency move being faster than navigating locked quarterly planning, I’ve done exactly that and felt vaguely guilty about it. His regret about avoiding the boring areas is the warning I’m noting for myself.
- I don’t want the details — The reframe I want to steal is swapping “why did this happen” for “what are we changing so this class of failure is less likely.” The SVP refusing the details wasn’t dismissiveness, it was trust, skip proving you’re competent and go straight to the fix. The test that gives it teeth is whether the fix survives if everyone from the incident left tomorrow, which instantly exposes “we’ll communicate better” as organizational folklore. Good explanations aren’t fixes is the line I’ll bring to the next postmortem.
- What Sun got wrong — Cantrill’s claim is almost insulting in its simplicity, Sun didn’t lose on strategy, it got bored with the mechanics of running a business. The 2005 story is the whole thesis, a startup wanted to buy Sun hardware because OpenSolaris actually worked, and Sun couldn’t be bothered to sell it, while Dell’s Steve answered a web form so well the customer felt like Steve worked for them. That’s the part that stings, the strategy was working and the company still couldn’t execute a basic sale. The kicker that Steve later became his Oxide co-founder turns the cautionary tale into something almost cosmic.
- Alice GG • Attention is all you have — The framing that stuck is that letting someone else pick what’s on your screen is handing them the key to your brain, and the Tetris effect is the proof that sustained attention literally reshapes how you think. Her catalog of the feeds is bleak and accurate, YouTube nudging you to doomscroll, Spotify’s AI slop, Reddit as LLMs talking to Russian trolls. The line about nobody putting dead kids and far-right propaganda after a pancake recipe on the old web is the one that clarified what actually changed. Her fix, going back to RSS and a slower finite internet, is the same bet I keep making with these notes, though I’m not sure it scales past people who already miss the old web.
- Forward Deployed Engineers from the trenches — javisantana.com — Santana’s contrarian hire is the part I keep turning over, he skipped the “people skills” candidates and took backend engineers because developers smell incompetence instantly and a suit loses the room. The single objective, get the customer into production as fast as possible, is a cleaner north star than any success metric, and his “customer success is a plague” line is a direct shot at optimizing for revenue extraction. Keeping technical people out of the money conversations so they don’t internalize the wrong incentive is sharp and slightly cynical. The daily-learnings documentation requirement is the boring habit underneath all of it, and probably the one that actually compounds.
- the senior engineer death spiral — The pattern he names is one I’ve watched happen, you take on the ambitious thing, go quiet for two or three weeks convinced that working harder will close the gap, and by the time you surface you’ve traded sleep and relationships for a project nobody could see progress on. What reframes it is his claim that the actual failure is visibility, remote work and solo ownership let you silo yourself, and the secret catch-up sprint only deepens the hole. His fix is counterintuitive and I think right, drop a level, become the best teammate on the bugs and docs and support, and let momentum plus trust earn you the big project instead of heroics. The line “you are in the reputation-building business, and software is actually downstream of that” is the one I’ll repeat, though I’m still chewing on how it sits next to wanting the work itself to be the point.
- The revolt of the reader — This is the sequel to the “intellectual fly is open” piece I flagged a couple weeks ago, and now he has numbers, Dunlop’s survey of 668 developers where 78% stop reading the moment they detect AI and 71% then avoid the author for good. The spam analogy is the load-bearing one, spam didn’t die because it got ugly, it died because filtering plus consequences made it uneconomical, and he’s betting detectors like Pangram do the same to generated prose. Oxide now gates public writing on passing Pangram, which is a striking thing to mandate but consistent with his claim that the real cost is trust, not aesthetics. I’ll admit reading this while an agent drafts my reading notes is uncomfortable, though the skeleton-versus-ghostwriter line is the one I keep telling myself I’m staying on the right side of.
- Will agents like Git any more than we do? — Amplify Partners — The framing that clicked for me is that Git’s quirks were never a problem because a human was always there to absorb them, and agents don’t do absorbing, they just hit the wall at 2 to 3 merges a second and stall. The staging-area state machine is the obvious tax, tracking whether a file is untracked, unstaged, staged, or committed is exactly the kind of ceremony an agent shouldn’t have to model. What actually sold me on jj is first-class conflicts, letting the conflict live in the data structure instead of blocking all forward progress is the difference between a human who stops to resolve and a fleet of agents that need to keep moving. Calling Git “an informally specified spec half implemented by five or six people” is funny because it’s true, and it reframes why a cleaner model might genuinely win this time.
- Version control second coming — What this adds over the agents-and-Git argument is the market view, and Santos has earned it fighting Git for 20 years with Plastic SCM, so his read that GitHub could go the way of SourceForge isn’t just contrarian. The roll call is genuinely useful as a map, Entire doing provenance for agent code, Pierre and Origin chasing AI-scale traffic, Diversion betting centralized and cloud-first against the whole distributed premise, ERSC commercializing jj. The prediction I keep circling is that repos past 300 GB and a million files simply break the distributed model, which quietly concedes that Git’s core design choice is the thing under pressure. His own hedge is the honest note, “ask me in two months,” because nobody actually knows which of these survives, only that the freeze is over.
- What comes after git — After two pieces arguing Git has to go, ERSC’s answer is the pragmatic one, don’t replace the protocol, replace the storage engine underneath it and keep speaking Git so nobody has to migrate on day one. That bridge framing is smart because it sidesteps the usual chicken-and-egg, you get horizontal scaling and independence from the big platforms without asking teams to abandon their clients. The number that recalibrated me is that the Linux kernel is ~43 million lines while companies were already running monorepos in the billions of lines years ago, so the scale Git struggles with isn’t hypothetical, it’s just been hidden inside Google and Meta. The jj-with-swappable-backends detail ties it to the other reads, the path they’re selling is Git protocol now, native protocols and jj later, migration as a slope instead of a cliff.
- If coding is solved, what now?: Measuring the sloppiness of code | EARENDIL — The reframe here is that correctness stopped being the interesting axis, models pass the tests, so the real question is what the code does to a project over time, and that’s much harder to score. The finding that stuck is that using an LLM as a quality judge is “basically equivalent to a random number generator,” and worse, renaming the solutions flips its verdict, which tells you it’s grading on surface, not structure. The two metrics in SlopCodeBench give it teeth, verbosity roughly doubling from 0.15 on real repos to 0.33 on agent code, and erosion jumping from 0.31 to 0.68, so the sloppiness isn’t a vibe, it’s measurable and it’s about 2x. Ties directly to the sloppiness worry underneath all the version-control pieces, the “aircraft progress by weight” line is the whole trap, and their answer that human taste is still the thing you can’t automate away is where I land too, even if it’s an inconvenient conclusion given who’s writing these notes.
- You should never be angry at work — The line that got me was “you are not Linus Torvalds or Bryan Cantrill”, because the famous angry engineers can afford anger only since they already control the decisions, and that’s not the position most of us are arguing from. The mechanism he describes is the uncomfortable part, an angry colleague quietly becomes a problem to route around, so people start backchanneling and excluding you, which feeds exactly the frustration that started it. I’ve felt the caring-overflow thing he names, where anger is just competence spilling past the edge of the tube, and I want to believe his claim that he gets more done now while calm than he did when volatile. Still chewing on the redirect-your-caring-toward-shareholder-value advice, it sounds right as self-management but a little bleak as a description of what work should feel like.
- How we saved 100 terabytes of memory by optimizing 1.1.1.1’s DNS cache — The framing that reset my sense of scale is that at 250 billion cached entries, wasting one byte per entry costs 250 gigabytes, so this is a post about squeezing individual struct fields and it still adds up to 100 terabytes. Most of the wins come from one observation, cached DNS responses never change, which means the capacity field in a Vec is dead weight and swapping to Box slices reclaims 64 bytes an entry. My favorite move is inferring the owner name from the cache key instead of storing it, since it trades a tiny bit of read-time work for dropping the allocation on roughly 80% of records. The counterintuitive result is that shrinking memory made it faster too, insert throughput up 43% and lookup latency down 19%, because a tighter layout is just better for the CPU cache. Good reminder that “make it smaller” and “make it slower” are not the same axis.
- Creepy crawlies — What makes this infuriating is the sheer waste, the whole kernel repo is trivially cloneable, and yet the scrapers pick the single most expensive path, rendering 1.48 million commits across 922 forks as HTML page by page. The number that lands is that only 2% of the roughly 6 million daily requests are real developers, and 14 to 16 of 90 cores are permanently pinned just serving bots. The detail that actually worries me is the arms race, Anubis proof-of-work worked until the bots started solving difficulty-5 puzzles, which means the training data is worth enough to burn compute on. And the residential-proxy swarm through compromised IoT devices kills IP blocking as a defense, so there’s no clean answer here, just a slow tax on shared infrastructure that everyone else pays for.
- lessons in latency — The reframe I’m taking from this is latency as a budget, if the page needs to render in 100ms then serving it in 50ms buys your customer nothing, it just costs you more. That flips optimization once you’re inside the threshold, the goal stops being speed and becomes capacity and cost. The distinction I keep underselling is that average latency sets your throughput via Little’s Law, but it’s p99 that actually eats the budget, so two systems with the same 2ms average can behave completely differently when one has a 1% tail at 100ms. The storage point ties it together nicely, cheaper high-latency storage needs more replicas to hit the same throughput, so the “savings” quietly claw themselves back. Useful lens for arguing against optimization work that feels virtuous but moves no real number.
- Me divorcié de una vida de 10 años — Lo que más se me quedó es el reencuadre del título, no se divorció de una persona sino de un plan de vida entero, la casa comprada, el trabajo estable, el guión que sus padres le enseñaron. Su frase de que llevaba años intentando encajar en un molde que ya no era suyo describe algo muy concreto, tenerlo todo y aun así sentirse vacía. La semana de despedidas, desayuno de empresa, firma del divorcio y vuelo con cinco maletas es brutal por lo comprimida que fue. Y la idea final me parece la honesta, salir de una vida de diez años no termina al firmar ni al cerrar la maleta, termina mucho después cuando te reconoces en lo que estás construyendo.
- Your intellectual fly is open — The title is the whole argument, people notice the AI tells in your writing, the emoji bullets and the “it’s not just X but also Y” cadence, and no one points it out, so you keep walking around exposed. The cost he names isn’t ugliness, it’s trust, once a reader suspects the post is generated they stop believing it’s real, which poisons everything you actually did write. I appreciate that he isn’t anti-LLM, he draws the line at authorship, brainstorming and editing keep your voice central while letting the tool write for you erases it. Funny detail aside, calling LinkedIn the Gerald Ford of social networks is a good jab, it survived mostly because its rivals imploded. Sits a little pointedly next to me handing an agent my own reading notes, though the line he draws is exactly the one I’m trying to hold.