Dead Code

A lot of developers love programming for the same reason. You tell the computer what to do, and eventually it does exactly that. Dave Copeland explains why that feeling of control and discovery is what makes coding satisfying & why AI coding tools challenge that relationship.

For a long time, software engineering felt like one of the safest careers in tech. High demand. Endless jobs. Always more code to write. Dave Copeland talks about the strange moment when that assumption stopped feeling guaranteed.

The failure mode is simple: the “sensible” architecture can’t ship on the real timeline. Sean Goedecke explains why design handoffs collapse under constraints, and how incentives create complexity engineers maintain. If you’ve seen a diagram, then opened repo in despair, yep.

AI coding tools are forcing a lot of experienced devs to ask a hard question: What happens to the craft of programming if the machines start writing most of the code? Dave Copeland talks about the moment he realized the ground might be shifting under the entire profession.

You can build three “well-designed” subsystems and still end up with a disaster. Sean Goedecke talks about how smart engineers create Frankenstein codebases when they optimize locally instead of matching existing patterns. Great reminder that coherence is a feature.

In large codebases, “perfect design” matters less than consistency. Sean Goedecke argues that once a system is huge, nobody can keep it all in their head, so teams survive on patterns, prior art, and “looks like the other things.” It might annoy purists. It will save your team.

Most “design advice” is just vibes unless you’ve lived in the codebase. Sean Goedecke breaks down the gap between generic principles and real design decisions shaped by actual constraints. If “just refactor it” came from someone who’s never opened the repo, this one’s for you.

The best design conversations sound like: “pull up the file.” Sean Goedecke describes a GitHub offsite where the discussion was painfully code-specific, and that’s exactly why it worked. No philosophy, no framework worship, just the actual system and what it can handle.

Russ Olsen drops the thesis every doc writer and teacher needs tattooed on their brain: the subject of your work is the reader. The tool does not change. The human does. If you write docs, teach, or lead devs, this clip hits.

Russ Olsen gives a sharp, practical critique of gradual typing in Ruby. Not anti-types, not anti-safety, just brutally honest about the tradeoffs when the type system is optional, and the annotations start getting more complex than the code.