Reading
Books and articles I think are worth your time.
Showing all 243 items.
-
Improving heuristics for A* search
Landmark-based differential heuristics that make A* explore far less of the graph, with no change to the algorithm itself — just a better distance estimate.
-
A harness for every task: dynamic workflows in Claude Code
Patterns for orchestrating coding agents: fan-out with synthesis, adversarial verification, tournaments, routing and loops, and when extra compute actually pays off.
-
Landing the plane
A playbook for the final 10% of a project — protecting scope, tightening cadence, communicating with stakeholders — so work ships instead of sitting at "almost done".
-
Control and complexity: tension in systems design
A systems-thinking look at the tension between decomposition and control on one side, emergence and adaptation on the other. Timely for teams reshaping practice around AI.
-
Compression is prediction
Walks from arithmetic coding and entropy to why compression and prediction are the same problem, which is a useful lens on what language models actually do.
-
A shell exclamation mark is not for yelling
A practical guide to shell history expansion: event designators, word modifiers, previewing before you run, and the underused fc command.
-
A deep (and fuzzy) dive into search
A deep dive into fuzzy search — Levenshtein automata, n-gram similarity, trie pruning — with the complexity bounds behind each approach.
-
Two-Tower Models for Recommendation Systems
How two-tower models power large-scale recommendation retrieval, learning separate user and item embeddings so millions of candidates can be matched by similarity.
-
Beyond Happy Path Engineering: Time
Makes the case for treating clock skew, scheduler delay and timestamp ordering as first-class concerns in distributed systems, not database details.
-
Middle Management Roles Are Also a Trap
Will Larson argues that middle-management incentives can erode the domain depth and execution habits effective engineering leadership depends on.
-
Get Up to Speed Unbelievably Fast: A Practical Guide to Rapid Onboarding
A framework for ramping up fast: sort new knowledge into facts, processes and transferable concepts, then deliberately build a mental model of the system.
-
The Antithesis Principle
A decision-making lens — for any useful observation about how people behave, ask how to avoid being manipulated through that same tendency.
-
Growing as an engineer in a world of AI
Practical advice on keeping reasoning, debugging and systems instincts sharp when AI produces working code faster than you can absorb it.
-
Notes on incidents
A realistic account of incident response, including the case for stabilising a system and letting it recover rather than intervening heroically.
-
Every Byte Matters
A benchmark-backed refresher on cache lines, struct layout and working-set size, and where tightening data layout produces outsized speedups.
-
How to create your own decentralized messenger protocol
Builds a decentralised messaging protocol from first principles — federation, discovery, HPKE, signing keys, idempotency — with concrete schemas.
-
Engineering Management After the Cost of Code Collapsed
An engineering-management take on cheap code generation meeting expensive verification, and where specifications and accountability move as a result.
-
Design Can't Be Proven Right — Only Falsified
Argues a design can only be falsified, never proven right, so the engineer's job is making falsification cheap: executable constraints, reviewer rules, externalised intent.
-
Stop sloppypasta
A short manifesto on using AI to sharpen what you send rather than to skip the thinking behind it.
-
The Conductor Developer
Makes the case that human attention, not typing speed, becomes the limiting resource once a developer is orchestrating several agents at once.
-
Loop Engineering
Moving from turn-by-turn prompting to self-running loops that discover work, dispatch it to agents, verify output and keep state between runs — with the warning that unattended loops also fail unattended.
-
The Big Management Lie: Overpromising
Argues managers should promise only what they control, replacing career guarantees with explicit commitments to advocacy, process and honesty.
-
My Agentic Coding Setup, July 2026
A field report on one agentic coding setup — disposable VMs, Tailscale, remote IDE access, worktrees, preview servers — with attention to the blast radius of autonomous agents.
-
When AI Costs More Than The Engineer
Runs the numbers on when per-engineer token spend overtakes salary, and lands on 2029.
-
How To Write An Effective Software Design Document
A guide to design docs centred on reversibility, risk, operational behaviour and the alternatives considered, rather than on document structure.
-
90% of the t distribution
A reminder that small samples should increase your uncertainty rather than your confidence, using the t distribution to show by how much.
-
Good tools are invisible
Argues the best developer tools disappear into the work instead of demanding attention and configuration of their own.
-
Everyone Should Know SIMD
A practical introduction to SIMD: vector lanes, reductions, handling the tail, and checking what the compiler already auto-vectorises before reaching for intrinsics.
-
The Invisible Ceiling: Why Excelling at Your Assigned Work Alone Won’t Take You Far Enough
On why consistently delivering assigned work eventually stops producing growth, and how expanding past the boundaries others set changes the trajectory.
-
When 'if' slows you down, avoid it
An introduction to branchless programming and the cases where avoiding a decision is faster than making one.
-
The Best Mentors Adapt: Why One Size Doesn’t Fit All
Argues mentoring has to adapt to where the engineer actually is, because one approach rarely transfers across career stages.
-
How Claude code works, from tokens to agents
A visual walkthrough of how Claude Code works, from tokens through tool calls to the agent loop, showing that context management carries most of the weight.
-
Guide to Data Tools Landscape for Developers
A map of the data tooling landscape — ingestion, warehouses, lakehouses, streaming, orchestration, lineage, governance — and how the pieces relate.
-
The Economic Benefit of Refactoring
An experiment measuring what structural refactoring does to AI-agent context cost, reporting an 83% drop in input tokens.
-
Make No Assumptions
Will Larson on reasoning horizons: how AI-generated work compounds flawed assumptions, and why the author should inspect the output before a reviewer ever sees it.
-
How Big Is a Git Commit?
A hands-on tour of Git object storage — trees, compression, packfiles — explaining why a three-byte edit produces several objects.
-
Small programming tricks
A collection of small, high-leverage habits, from Git's pickaxe search to getting more out of shell history.
-
htop explained
Explains what htop is actually showing you — load averages, process states, memory as RSS versus virtual — and the /proc plumbing behind each number.
-
Lucas' Laws of Project Management
Ten blunt rules for getting projects to land: keep scope variable, get something working early, plan for operations, and make the status board show reality.
-
Why AI Hasn't Replaced Software Engineers, And Won't
A measured argument for why AI has not replaced software engineers, and why the author expects that to hold.
-
How I Find Problems to Solve as a Staff Engineer
How a staff engineer picks what to work on: telling root problems apart from feature requests, waiting for evidence to pile up, stress-testing elegant ideas first.
-
The Best Prioritization Is No Prioritization
Argues that raising delivery speed and giving teams durable ownership beats repeatedly ranking work that was never really comparable.
-
Work loudly
Argues for making the issue, design and decision trail visible while the work happens, so the artefacts do the talking later.
-
I Inspected My Take-Home Interview Project. It Was a Whole Operation.
A security investigation that starts with a suspicious take-home exercise and ends in malicious Git hooks and payload analysis.
-
The Vital Few
Uses and then challenges Price's Law, framing concentrated performance as a resilience risk rather than a reason to lean harder on the reliable few.
-
Staying On The Path To High Performing Teams
Will Larson on why strong teams quietly degrade over time, and what to put in place before yours does.
-
How Successful Companies Go Blind
How companies lose the ability to read their environment precisely because earlier success taught them to trust signals that no longer hold.
-
In Defense Of Not Understanding Your Codebase
Argues you do not need to understand a whole codebase to work in it well: a trustworthy local model plus cautious changes beats attempting a rewrite.
-
The Harness Is All You Need (Mostly)
Practical guidance on building with AI coding tools, worked through a date-picker example. Written for Copilot, but the harness principles carry over.
-
Building service topology at scale
A production account of building real-time service topology at Netflix: Kafka lag, hot nodes, GC pressure and backpressure, and how each was handled.
-
Virtual memory from first principles
Virtual memory explained from first principles, clearly enough to replace whatever you half-absorbed in an operating systems course.
-
Broker-visible vs client-local parallelism
On Kafka scaling: once each unit of parallelism is a consumer the broker must track, connection count becomes the real workload. Includes the arithmetic.
-
Harness Engineering Deep Dive: Where the Term Came From, and How to Actually Build One
Moves agent reliability away from prompt superstition and towards sensors, durable state, constrained tools, verified completion and trajectory debugging.
-
In-House LLM Serving at Netflix
Serving LLMs in-house with vLLM and Triton: engine choice, version pinning, rollout strategy, missing metrics, and a constrained-decoding bottleneck under real traffic.
-
You Don’t Have to Be Smart If You Can Think Clearly
Argues that difficult engineering problems yield to patient reasoning from invariants rather than to flashes of intuition.
-
LLMs aren't world models
Argues language models cannot genuinely reason about the world yet remain useful — above all when you can check the answer, or already know it and would rather not type it.
-
Security Risks of Third-Party LLM API Proxies (arXiv Paper)
A paper formalising the threats in unofficial LLM API proxies, including response tampering and credential theft, and the trust boundaries they quietly cross.
-
How to Buy Cheap Claude Tokens in Bulk - ChinaTalk
Looks at the grey market reselling discounted AI API tokens, and what it means when requests pass through intermediaries able to log or alter them.
-
How 2004 RuneScape fit a multiplayer RPG into 56k dial-up
How the 2004 version of RuneScape fit a multiplayer RPG into 56k dial-up. A masterclass in bandwidth thrift under hard constraints.
-
Building Ask DoorDash (Part 2): Intelligence
How DoorDash built the intelligence layer behind its assistant, with retrieval-augmented generation running in production rather than in a demo.
-
Stop using Conventional Commits
A contrarian argument that feat:/fix: prefixes optimise for the wrong thing. Worth reading even if you keep the convention afterwards.
-
How Shopify Replaced Redis with MySQL for Inventory Reservations at Scale
Shopify swapped Redis for MySQL to handle inventory reservations at scale, and explains why the less exciting database turned out to be the right call.
-
Engineering the Forge Billing Platform for Reliability and Scale
How Atlassian built the billing platform behind Forge, its serverless app platform, from overall architecture through the hardest problems hit before launch.
-
Why is Meta destroying its engineering
Gergely Orosz on how internal incentives and repeated reorganisations are reshaping engineering at Meta.
-
Clustering billions of products
How Shopify clusters billions of catalogue products, and the trade-offs that only show up at that scale.
-
Building a design system specced for engineers and agents
Building a design system that both engineers and AI agents can consume, which turns out to be mostly a question of how precisely it is specified.
-
Six SQL patterns I use to catch transaction fraud
Six SQL patterns for catching transaction fraud, each with the query and the reasoning behind why it works.
-
Faster than Light: Optimizing Generative Recommender Training Efficiency at LinkedIn
How LinkedIn cut GPU cost and training time for its generative recommender models.
-
How Palantir reindexes Elasticsearch at scale without breaking search
Reindexing a production Elasticsearch cluster at scale without degrading search, and the observability that makes it safe to attempt.
-
I Built an AI That Knows When I’m Wasting Time
A build log for a tool that infers drifting attention from activity patterns, using a model as a reasoning layer instead of blunt app blocking.
-
Pushing and Pulling: Three Reactivity Algorithms
Three reactivity strategies — push, pull and the hybrid — explained with spreadsheet analogies and diagrams. A usable model for what signals libraries do.
-
AI-assisted engineers are burning out, is this fine?
On AI-assisted development producing cognitive overload, what that kind of burnout looks like, and how to keep it in check.
-
The invisible engineering behind Lambda's network
The networking engineering behind AWS Lambda that makes the service feel effortless from the outside.
-
AI engineering for developers
A practical scope of what an engineer actually needs to know to build with LLMs, without first acquiring a research background.
-
Easter egg features Commodore 64 code
An obscure easter egg in Lego Batman that hides working Commodore 64 BASIC code inside a modern game.
-
Life is too short for a slow terminal
On terminal latency, and why a few milliseconds of input lag matter more than they sound like they should.
-
How Container Filesystem Works
Builds a container filesystem from scratch, so the layers underneath Docker stop being magic.
-
Training an agentic search model to be 20x faster than GPT-5
How a model was trained to search iteratively instead of trusting the first retrieval, reported as 20x faster than GPT-5 on the task.
-
Beyond code generation: rethinking engineering productivity in the age of AI agents
Dropbox found that generating code faster simply moved the queue to code review, and rethought the surrounding pipeline instead.
-
From decentralized Docs-as-Code to a centralized repository: Evolving Grab's documentation strategy
Why Grab moved from docs-beside-the-code to a central repository, and how they keep documentation from rotting at scale.
-
Learning Software Architecture
The author of rust-analyzer on Conway's Law, on incentives shaping systems, and on the architecture book he wishes already existed.
-
Nobody pushed back: Why engineers stay silent until it's too late
On why engineers stay quiet about problems they can all see coming, and what makes speaking up possible earlier.
-
Things you didn't know about indexes
Details about database indexes that people using them daily have often never had to learn, and what the query planner does with them.
-
Programming Still Sucks
A ship-captain metaphor for engineering leadership that turns into a harder point about what the industry is doing to the junior pipeline.
-
Selective test execution at Stripe: Fast CI for a 50M-line ruby monorepo
How Stripe stopped running every test on every commit across a 50-million-line Ruby monorepo while keeping CI trustworthy.
-
Being oncall taught me everything
On how being on call teaches real system behaviour faster than any other assignment.
-
When AI builds AI: recursive self-improvement
Anthropic on AI systems improving AI systems, and how they frame the risks of that loop.
-
Barely Treading Water
Rands on a senior leader failing without realising it, and the conversation that finally names it out loud.
-
A Real-World Story of CPU Bottlenecks
A production debugging story from Pinterest: tracking down zombie processes quietly consuming CPU across a fleet.
-
Nobody cracks open a programming book anymore
An affectionate look at what the era of thick programming books taught a generation of engineers, and what has replaced it.
-
Git's magic files
A tour of the lesser-known files inside .git/ and what each of them is actually for.
-
10 Lessons For Agentic Coding
Ten lessons from extended pairing with coding agents, built around code being cheap while maintenance stays expensive.
-
The Two Abstractions Of System Design: Hide Or Reduce
Argues "abstraction" means two different things — hiding detail versus reducing it — and that conflating them is why formal modelling feels so hard.
-
Patterns For Reducing Friction In AI-Assisted Development
Five patterns from Martin Fowler's team for reducing friction in AI-assisted development, treating the agent as a capable but stateless newcomer.
-
MicroGPT explained interactively
An interactive walkthrough of a minimal GPT implementation, with the attention weights visualised as they update.
-
How To One-On-One
A playbook for one-on-ones, starting from the argument that spending synchronous time on status updates is a waste of both people.
-
The Slop Cannons In Your Engineering Org
On colleagues who run several agents at once and cannot explain the resulting diff, alongside data showing experienced developers were 19% slower with AI.
-
Databases were not designed for this
Databases assume deterministic, well-behaved callers, and agentic systems are neither. Practical defences against autonomous code quietly corrupting data.
-
Email is Crazy
How a protocol from the 1970s still runs on SPF, DKIM, DMARC and goodwill, starting from the fact that SMTP's From header is essentially self-declared.
-
Interrogatory LLM
Martin Fowler names the pattern of letting a model interview you to assemble context, instead of writing the whole brief up front.
-
Cloud Computing without Containers
How Cloudflare Workers achieve lower latency than container-based serverless platforms, and the trade-offs between V8 isolates and containers.
-
Monotasking as a habit
On attention, distraction and the state of flow, and why single-tasking is a habit worth rebuilding deliberately.
-
The AI Engineering Stack We Built Internally
Cloudflare's account of adopting AI across its R&D organisation: MCP servers, an AI gateway, automated code reviewers, and the team that wired it together.
-
High Performance Git
Techniques for keeping Git responsive once a repository has grown large enough that everyday commands start to stall.
-
Be The Idiot
Argues the most effective engineers ask the obvious questions, borrowing from military communication protocols where precision beats sounding competent.
-
Swissing a Table
A step-by-step path from a naive hash table to Go's Swiss table implementation, benchmarked at every stage along the way.
-
The Economics of Software Teams: Why Most Organizations Are Flying Blind
Puts a monthly cost figure on a team and then asks what it actually produces, doing arithmetic most organisations avoid.
-
The Skill of Using AI Agents Well
Field-tested habits for working with coding agents — worktrees, verbose logging — and the uncomfortable conclusion that the human review loop is the bottleneck.
-
Shell tricks that actually make life easier
Shell techniques that go well past the usual alias advice, aimed at things you will genuinely reuse.
-
Quantization from the ground up
What actually happens to a model's weights and its accuracy when you squeeze them into fewer bits.
-
7 More Common Mistakes in Architecture Diagrams
Seven more recurring failures in architecture diagrams, each given a name so you can point at it during review.
-
My AI Workflow (Without Losing My Skills)
An honest account of one AI-assisted coding workflow deliberately built to avoid dependence on the tool, with an aviation analogy that sticks.
-
113 Pragmatic Lessons from Tech Lead to CTO
One hundred and thirteen lessons from seventeen years scaling a Django monolith to a million lines, from tech lead through to CTO.
-
JPEG compression
How JPEG turns photographs into surprisingly small files, with the discrete cosine transform explained approachably.
-
Components of a Coding Agent
Sebastian Raschka breaks down the six building blocks that make coding agents feel far more capable than the same model does in a chat window.
-
Why your engineering team is slow (it's the codebase, not the people)
A five-question rubric for telling whether a team is slow because of the people or because the codebase actively resists change.
-
Rendering DOOM in 3D with CSS
Builds a playable DOOM renderer where every wall, barrel and enemy is a div positioned in 3D with CSS transforms — effectively a stress test of browser compositing.
-
The Git Commands I Run Before Reading Any Code
Five Git one-liners that surface churn hotspots, bus-factor risk and bug clusters before you open a single file.
-
Encoding team standards
Argues AI coding instructions deserve the same treatment as infrastructure — versioned, reviewed, shared — rather than living in one senior engineer's head.
-
Agents With Taste
How one designer packaged their judgement about animation quality into skill files, so agents produce interface work that matches it.
-
Who Will Be The Senior Engineers of 2035?
If AI absorbs the junior work and hiring slows to match, where does the next generation of senior engineers actually come from?
-
Introduction to Digital Filter Design in 30 minutes
A thirty-minute introduction to digital signal processing and filter design, focused on cleaning up or amplifying the regions of a signal you care about.
-
Making Illegal State Unrepresentable
Models the same builder in Python, Java, Kotlin, Rust and Gleam to show how far a type system can go in making invalid states impossible to express.
-
How To Understand Things
On the intellectual habits that separate genuine understanding from memorisation, drawing on Feynman and Faraday.
-
How The Heck Does Shazam Work?
An interactive explanation of audio fingerprinting, and how a noisy few seconds of recording gets matched against an enormous catalogue.
-
Inside Amazon Live Events
A conversation with a Prime Video engineer about delivering targeted advertising to millions of concurrent viewers during live events.
-
Queueing requests queues your capacity problems, too
Why putting a queue in front of a capacity problem defers the problem rather than solving it.
-
Reading leaked Claude Code source code
What 132,000 lines of leaked TypeScript reveal about how Claude Code is actually built, oddities and all.
-
Context Rot in LLMs - Chroma
Chroma's study showing model reliability degrades as input length grows even with task complexity held constant, and degrades further with distractors present.
-
Good APIs Age Slowly
On API boundaries and convenience traps, and why the interfaces that impress fastest tend to cause the most pain later.
-
Mechanical Sympathy
On engineers who think like product designers, and why coding agents still lack the judgement that requires.
-
Agent harness engineering
Addy Osmani on why the scaffolding around an agent matters more than the model inside it, and why waiting for the next model is not a strategy.
-
USB for Software Developers
An approachable walkthrough of writing userspace USB drivers with libusb, demonstrated against a phone in bootloader mode.
-
The Peril of Laziness Lost
Bryan Cantrill on laziness as a programming virtue, and why sheer volume of generated code is the wrong thing to celebrate.
-
My Heuristics Are Wrong. What Now?
Marc Brooker on what to do when hard-won engineering intuitions stop matching the world they were built for.
-
Feedback Flywheel
Argues teams plateau with AI tooling because they never build a practice for feeding what they learn back into shared artefacts.
-
What is inference engineering?
An accessible tour of inference engineering: quantisation, speculative decoding and disaggregation, without the usual density.
-
Chess in Pure SQL
A playable chess board implemented with nothing but SELECT, UPDATE and conditional aggregation.
-
Understanding Traceroute
How traceroute discovers each hop using a TTL trick, reimplemented in roughly eighty lines of Rust.
-
The Impact of AI on Software Engineers in 2026: Key Trends
Over 900 survey responses on who is genuinely benefiting from AI tooling, who is drowning in low-quality output, and what the bill looks like.
-
The Vertical Codebase
Argues that organising code by technical type — components, hooks, utils — ages badly, and that agents do not rescue you from it.
-
S3 Files and the Changing Face of S3
How S3 grew from plain object storage into supporting filesystem semantics, and what that changes about storage design.
-
Eight years of wanting, three months of building with AI - Lalit Maganti
A senior engineer's account of building a SQLite parser with AI assistance, concluding it multiplies implementation speed but substitutes poorly for design judgement.
-
The Complicators, The Drama Aggregators, and The Avoiders
Rands on three colleague archetypes that consume most of a manager's energy, and how to deal with each of them.
-
The unwritten laws of software engineering
Seven laws most engineers learn the hard way, including that nothing lasts like a temporary fix and that backups are not real until you restore from one.
-
Floating point from scratch
Builds floating point from scratch, so that "floating point is weird" becomes something you can actually explain.
-
How to Kill The Code Review
A pointed argument about whether code review still earns its ceremony once most of the code arriving is AI-assisted.
-
Say the Thing You Want
On telling your manager which direction you actually want to go, since opportunities cannot be routed towards an unstated goal.
-
How I built a sub-500ms latency voice agent from scratch
A detailed build of a voice agent under 500ms end to end, with the latency budget and architectural trade-offs shown rather than summarised.
-
The rise and fall of IBM's 4 Pi aerospace computers: an illustrated history
An illustrated history of the ruggedised System/360 descendants that flew in fighter jets and the Space Shuttle, covering redundancy, radiation hardening and decades of obsolescence management.
-
Lessons from Building Claude Code: How We Use Skills
Anthropic's framework for agent skills, drawn from running hundreds in production: nine skill types, how to write them well, and how to distribute and measure them.
-
Building a C compiler
Anthropic's engineering account of building a C compiler, which is among the less forgiving things to get right.
-
How Slack Rebuilt Notifications
The engineering story behind rebuilding Slack's notification system, where making it reliable proved harder than making it deliver.
-
Harness design for long-running application development
Anthropic on harness design for long-running autonomous coding work, and what it took to push further on frontend tasks.
-
Interviewing Tactics For A Post-LLM World
Practical interviewing strategies for a world where every candidate has an assistant, mostly by probing for depth.
-
Every Layer Of Review Makes You 10x Slower
Avery Pennarun argues the approval process rather than the work is the bottleneck, and puts numbers on what each additional review layer costs.
-
Scaling Software Engineering with AI
Applies scaling principles from systems thinking to software organisations trying to absorb AI tooling.
-
Rendering 100M pixels a second over ssh to run snake
Pushing SSH far past its intended use to render a massively multiplayer game of snake at a hundred million pixels a second.
-
Warranty Void If Regenerated
A short science-fiction story about software mechanics in a post-AI world, where the hardest bug to fix is a bad specification.
-
Clinejection: prompt injection via GitHub Actions
A real supply-chain attack that used prompt injection against Cline by way of GitHub Actions.
-
Finding and Fixing Ghostty's Largest Memory Leak
Finding and fixing the largest memory leak in Ghostty, which doubles as an explanation of how the terminal works internally.
-
YAML? That's Norway Problem
YAML's most cursed corners, starting with a parser that reads NO as a boolean and quietly turns Norway into false.
-
ASCII Characters Are Not Pixels: A Deep Dive into ASCII Rendering
Why ASCII characters behave nothing like pixels, and what that means for anyone rendering onto a character grid.
-
Decision Trees – Interactive Visual Explainer
An interactive explainer that turns entropy and information gain into something you can see happening, in roughly five minutes.
-
The two kinds of error
A clean split between expected errors, which you handle, and unexpected ones, which should crash — a framing that changes how error handling gets written.
-
How GPUs communicate
What actually happens between GPUs when they are not computing: interconnects, topologies and the real cost of moving data around.
-
SFQ: Simple, stateless, stochastic fairness
Marc Brooker explains stochastic fairness queueing, a stateless approach to fairness that is markedly simpler than most load-balancing schemes.
-
How I Run 4–8 Parallel Coding Agents With tmux and Markdown Specs
A working system for running four to eight coding agents in parallel using tmux and markdown specs, refined over several hundred features.
-
How Michael Abrash doubled Quake framerate
How Michael Abrash doubled Quake's frame rate through assembly-level optimisation, dissected instruction by instruction.
-
Knowledge Priming
Martin Fowler on priming an assistant with the right context up front, and how much downstream friction that removes.
-
Awesome falsehood
A collected list of false assumptions programmers hold, where the sections on names, time and addresses are the most humbling.
-
An interactive intro to quadtrees
An interactive introduction to quadtrees that you can manipulate rather than merely read about.
-
How many branches can your CPU predict?
Daniel Lemire measures how many branches a modern CPU can keep predicting, and where the predictor gives up.
-
Against query based compilers
The engineer who helped popularise query-based compiler architecture argues against it, based on what it costs in practice.
-
My AI adoption journey
Mitchell Hashimoto describes where AI has genuinely landed in his own workflow, avoiding hype in either direction.
-
Design-First Collaboration
Argues that generating code without design up front just produces technical debt faster, and puts design ahead of prompting.
-
Secure Communications in a News App at Multiple Layers
How The Guardian built a covert secure-communications channel inside a news app for hostile environments, where even contacting a known endpoint is incriminating.
-
How we made Notion available offline
The engineering behind making a cloud-native application work offline, which turned out to involve far more than caching.
-
Logging sucks. And here's how to make it better.
An interactive guide to wide-event logging, with implementations and simulations showing where conventional log lines fall short.
-
Two years of vector search
Two years of lessons from running vector search at scale, well past the point where embeddings alone are the answer.
-
Management In The Age Of AI
An opinionated argument that hiring mistakes cost far more now, given how widely output varies between engineers using AI well and badly.
-
How I Became Good at Leading Incidents
What one engineer learned about running incidents after more than a hundred of them, focused on what matters while systems are still burning.
-
Systems Thinking in Enterprise Architecture
Argues enterprise architecture should be treated as a complex adaptive system rather than a diagram of boxes and arrows.
-
Postgres locks explained
Postgres locking explained clearly enough that the distinctions might still be with you tomorrow.
-
Harness Engineering
Birgitta Böckeler examines harness engineering — constraining agents with linters, structural tests and curated context — with welcome scepticism.
-
Writing my first evals
Building evaluation systems from scratch for output that differs every run, and finding that passing and being good are not the same thing.
-
Slow Down To Speed Up
Argues AI makes it easier than ever to build the wrong thing quickly, so deliberate slow thinking matters more rather than less.
-
Hybrid Quota-Linear Rate Limiter
A hybrid quota-linear rate limiter, for cases where token buckets and sliding windows do not fit the problem.
-
AI Fatigue Is Real And Nobody Talks About It
An infrastructure engineer on shipping more code than ever and feeling worse for it, and the cognitive cost nobody is accounting for.
-
Reflections on the Future of Software Engineering Retreat
Reflections from an industry gathering on how engineering is changing, including the finding that AI is raising cognitive load rather than lowering it.
-
Measuring Agents in Production
A paper review finding that most agents running in production are effectively state machines with fewer than ten steps.
-
How Codex is built
A deep look at how OpenAI's Codex is put together, based on conversations with the people who built it.
-
How I Use Claude Code
One engineer's day-to-day workflow with a coding agent, written as what actually works rather than as a demonstration.
-
When Memory Growth Isn't a Leak: Debugging Native Memory in a JVM Service
Chasing steady memory growth in a JVM service whose heap and GC metrics looked entirely healthy, ending at allocator fragmentation and what standard tooling cannot see.
-
Nobody Gets Promoted For Simplicity
On the unglamorous simplification work that keeps systems alive and almost never appears in a promotion packet.
-
A Decade of Docker Containers
An ACM retrospective on ten years of Docker containers, and how a single tool reshaped the way software gets shipped.
-
How The New York Times Is Scaling Unit Test Coverage Using AI Tools
How the New York Times raised unit test coverage from 60% to 83% using agents, under two constraints: no changes to source, and a read-only coverage report.
-
Architectural Lessons From Sub-100-ms APIs
Patterns for keeping API responses under 100ms when every layer in the stack is inclined to add a little latency of its own.
-
Things I’ve learned in my 10 years as an engineering manager
Ten years of engineering management lessons compressed into a few minutes of reading.
-
Use it or lose it
On skill decay — which engineering abilities fade once you stop exercising them, and what that implies as more work is delegated to tools.
-
How to work in tech when your job isn't safe
Tactical advice for working in tech through a stretch of layoffs, centred on staying demonstrably relevant.
-
Autonomous Big Data Optimization: Multi-Agent Reinforcement Learning to Achieve Self-Tuning Apache Spark
Wraps Spark job submission in an agent layer that uses reinforcement learning to tune configuration from the observed shape of the data.
-
Challenging projects every programmer should try
A list of projects worth building at least once — the kind that teach far more than a tutorial precisely because they are hard.
-
How do daily stand-ups boost team performance?
A research digest on whether daily stand-ups actually improve team performance, and under which conditions they do.
-
The Bet On Juniors Just Got Better
Kent Beck argues the case for hiring junior engineers has strengthened rather than weakened in the current environment.
-
The Decision Triangle: a simple way to improve decision making
A simple framework for improving decisions by first being explicit about which kind of decision you are making.
-
Why your coding agent keeps undoing your architecture?
Argues architectural decision records serve as agent memory: the code shows the current state, but never the transitions that produced it.
-
CSS at Scale With StyleX
What StyleX is, and how Meta uses it to keep CSS manageable at very large scale.
-
Expert Generalists
Martin Fowler's case that deep specialisation is no longer the only credible route to being genuinely good.
-
Synchronous Work, Asynchronous Work
On which work genuinely needs to happen synchronously and which does not, and what it costs to confuse the two.
-
Tracing the thoughts of a large language model
Anthropic's interpretability work tracing what actually happens inside a model as it produces an answer.
-
How to Work Better with AI
Why AI assistance fails, how unplanned coding quietly accumulates technical debt, and a four-step spec-driven alternative walked through in Kiro.
-
Scaling maintenance: Rethinking HDFS block placement for exabyte-scale clusters
Rethinking HDFS block placement for exabyte-scale clusters, and what routine maintenance looks like at that size.
-
Software Testing Fundamentals Every Developer Should Understand
A refresher on the testing fundamentals every developer should hold, which matters more now that agents write much of the code.
-
How Google Manages Trillions of Authorizations with Zanzibar
How Google's Zanzibar answers trillions of authorisation checks, and the data model that makes that tractable.
-
Agent Psychosis: Are We Going Insane?
Armin Ronacher on the point where current enthusiasm for agents stops being rational.
-
We got Claude to teach open models how to write CUDA kernels!
How a stronger model was used to teach open models to write CUDA kernels, and how well that capability transferred.
-
Why AI Agents Keep Deleting Prod Databases
Why coding agents keep destroying production databases, and which guardrails actually prevent it.
-
How AI assistance impacts the formation of coding skills
An Anthropic study finding AI assistance can speed experienced developers up while measurably weakening comprehension and debugging scores, with juniors most exposed.
-
Everything I know about good system design
Practical system design advice, deliberately unlike the version that circulates on social media.
-
How Dependabot Actually Works
How Dependabot actually works underneath the pull requests everyone is used to seeing.
-
7 learnings from Anders Hejlsberg: The architect behind C# and TypeScript
Seven lessons from the architect behind C# and TypeScript, drawn from decades of language design.
-
Apache Hudi™ at Uber: Engineering for Trillion-Record-Scale Data Lake Operations
How Uber runs a trillion-record data lake on Apache Hudi, and the engineering that keeps it maintainable.
-
LLMs and your career
A plainly stated view on what language models mean for an engineering career.
-
Vibe Coding to Disciplined Development
Argues that as writing code gets cheaper, the principles that produce high-quality systems matter more rather than less.
-
Scaling PostgreSQL to power 800 million ChatGPT users
How OpenAI scaled a single-primary PostgreSQL setup to millions of queries per second serving hundreds of millions of users.
-
The RAG Obituary: Killed by Agents, Buried by Context Windows
Argues that with million-token context windows, agents reasoning over raw documents beat chunking, embeddings and vector databases on accuracy, latency and cost.
-
A Social Filesystem
Dan Abramov on what social software might look like if it were built on files rather than platforms.
-
How the Creator of Claude Code Uses Claude Code: A Complete Breakdown
A breakdown of how the creator of Claude Code uses the tool himself, summarised from his own thread.
-
The way I run standup meetings
One approach to running stand-ups that keeps them short and actually worth attending.
-
The PERFECT Code Review: How to Reduce Cognitive Load While Improving Quality
A code review framework aimed at lowering reviewer cognitive load while improving what the review actually catches.
-
Vibe Coding Without System Design is a Trap
What goes wrong when an agent builds without a system design, and why the planning is the part you cannot skip.
-
Why You Need To Clear Your Coding Agent's Context Window
Why clearing an agent's context between tasks yields better results, with simulations of how context bloat degrades edits, plus ways to persist what matters.
-
Scaling the data storage layer in system design
A short tour of scaling the storage layer in system design, and the point where each option stops working.
-
Observability for Notion’s Redis Queue
What Notion gained by instrumenting its Redis queue closely, and which signals turned out to be worth collecting.
-
How AI will change software engineering – with Martin Fowler
Martin Fowler on how he expects AI to change software engineering, and which parts of the craft he thinks hold.
-
Tech predictions for 2026 and beyond
Amazon's CTO, Werner Vogels, sets out his technology predictions for 2026 and the years after.
-
Career Path for Software Engineers in Large Tech
Tactics for getting promoted through the senior engineering levels, and how to judge when to move into management, from a former Amazon vice president.
-
Interesting study:: Butter-Bench: Evaluating Practical Intelligence in Embodied LLMs
A benchmark testing language models as high-level orchestrators for mobile robots — navigation, visual inference, social understanding — rather than analytical puzzles.
-
Kafka is fast -- I'll use Postgres
Benchmarks behind the argument that Postgres can serve as your queue or pub/sub system instead of reaching for Kafka.
-
Linux ate my ram!
Why Linux looks like it has eaten all your memory, and what the difference between free and available actually means.
-
Enhancing Uber’s Guidance Heatmap with Deep Probabilistic Models
How Uber improved its driver guidance heatmap using deep probabilistic models.
-
Eventual vs strong consistency
A short, clear post on the practical difficulties eventual consistency introduces, and where strong consistency earns its cost.