All Entries

If you feed the LLM your project's architecture and conventions before asking it to write code, the output gets dramatically better, and here's what to include and what to skip.

Torvalds said 'talk is cheap, show me the code,' but now that machines can generate code, the person who can clearly articulate the problem is the one who matters.

Feature flags are just if-statements with an expiration date, and the real problem is that most teams forget to clean them up.

If you start with background, people leave before they reach the interesting part, so find the one thing that makes your reader curious and open with that.

ASCII characters have shapes, not just brightness values, and once you match on geometry instead of treating them as pixels the rendering quality jumps dramatically.

AI coding assistants are basically a REPL that calls an LLM in a loop, and once you see the 200 lines that make it work, the magic disappears.

After 14 years at Google, the lessons that stuck aren't about code, they're about navigating ambiguity, building trust, and the difference between being productive and being impactful.

You can pretend the layer below doesn't exist right up until it breaks, and then you'd better understand it anyway.

You implement backprop, attention, and a GPT from scratch with no frameworks, and by the end you actually understand what the machine is doing instead of just calling library functions.

Angular's change detection gets a lot simpler once you understand that immutability lets the framework skip entire subtrees instead of diffing every object property.

Karpathy's dense, opinionated survey of everything that changed in language models over 2025, written by someone who has built these systems himself.

If the process is about to exit, the correct garbage collection strategy is to do nothing, because the OS will reclaim everything faster than you ever could.

The clearest visual explanation of how Transformers actually work, from self-attention to positional encodings, now referenced by courses at Stanford, Harvard, and MIT.

Rewrite React from scratch following the real architecture, and suddenly the rules about hooks and re-renders stop being arbitrary and start being obvious.

Most codebases aren't hard because the problem is hard, they're hard because someone made you hold too many things in your head at once.

Build a SQLite clone from scratch in C, and after that you'll never write a SELECT statement without knowing exactly what the machine is doing underneath.

Concurrency is how you organize the work, parallelism is whether you have enough workers to do it simultaneously, and most people mix the two up.

Practical system design advice from someone who builds systems, not someone selling interview prep, focused on knowing your actual bottleneck and when not to distribute.

Once you make one function async, every function that calls it has to be async too, and that's not a bug, it's a language design problem nobody solved cleanly.

Animating height forces the browser to recalculate layout every single frame, and here are the concrete alternatives that don't.

LLMs made writing code faster but the hard part was never typing, it was understanding the problem, and that part hasn't gotten any easier.

Google's paper on how they load-balance all their incoming traffic with consistent hashing, kernel bypass, and no shared state between balancer machines.

When you set a breakpoint, the debugger literally overwrites your instruction with a trap, and the rest of the trick is just ptrace and knowing when to put the original byte back.

Sometimes writing it yourself is the right call because the dependency you avoided understanding will eventually break, and then you'll have to understand it anyway under pressure.

Paul Graham's short, opinionated take on what makes writing good, worth re-reading every time you sit down to write a design doc or blog post.

When nobody in the organization is responsible for a bad outcome, that's not an accident, somebody designed it that way.

A well-researched deep dive into how SAD lights work and what “lumens” really mean - great for cutting through marketing hype.

Every frame your browser paints goes through the same pipeline, and most performance bugs come from accidentally triggering expensive stages you didn't need to.

If you're managing state with a pile of boolean flags, you've already built a state machine, just a buggy one without a diagram.

The most thorough single reference on everything that happens between typing a URL and seeing pixels, and it's held up since 2011.

Chrome's own team explains why your browser runs a separate process for each tab and what actually happens at the OS level when you click a link.

Most prompt advice is vibes. This whitepaper is the opposite - it breaks down why few-shot examples work, when chain-of-thought actually helps, and where most people over-engineer their prompts.

The best side projects aren't the ones that become startups. They're the ones where nobody's waiting on a PR review and the only deadline is whenever you feel like it.

Scroll-to-anchor seems trivial until you account for sticky headers, the back button, smooth scrolling race conditions, and intersection observer timing.

Someone implemented DOOM entirely in TypeScript's type system - no runtime, just the compiler crunching frames. It's the most unhinged proof that TS types are Turing-complete you'll ever see.

We want AI agents that can discover like we can, not which contain what we have discovered. Building in our discoveries only makes it harder to see how the discovering process can be done.

LLMs for software development offers a refreshing roadmap. By brainstorming extensively upfront, then iterating in small steps with careful testing, you can make quick progress without sacrificing maintainability. It’s a practical look at how to harness AI tools effectively, especially for creating clean, well-structured projects from scratch.