Fear not the rebase. Steve Klabnik explains jj's “keep going, resolve later” approach to conflicts which saves time and let's you deal with what matters, when it matters.

Clean, review-friendly history shouldn’t require five different rituals and incantations. Steve Klabnik breaks down how jj makes common Git workflows feel simpler and more natural.

Version control can get better without forcing your whole team to switch tools. Steve Klabnik explains why jj is clicking for Git power users and Git skeptics.

We talk a lot about the beauty of open source. We don’t talk enough about the fragility. There's human factors, the burnout, the life cycles that end quietly. Joel Hawksley's perspective here is brutally true and rarely said out loud.

The real reason companies choose React? It’s not just tech. It’s people. Culture. Hiring. Sustainability. Joel Hawksley gives the most honest breakdown we’ve heard of how those decisions actually get made inside big engineering orgs.

Accessibility isn’t a checkbox. It’s leverage. Joel Hawksley shares how accessibility work at GitHub became the engine behind cleaner UI, smarter abstractions, and better architecture. If you care about scaling UI in the real world, this part hits hard.

You might’ve tried it years ago. You might’ve bounced off ReasonML. But everything you thought was hard about ReScript? It’s gone. Josh Vlk explains why 2025 is the year to revisit one of the most underrated languages on the web.

GitHub didn’t adopt ViewComponent because it was flashy. They adopted it for fit. It fit into a massive Rails monolith, a legacy team, and into years of product history. Joel Hawksley breaks down how you ship architectural change in a company where you can’t just “rewrite it.”

Ever look at the frontend wars & think, “We’re all arguing about the wrong things”? Joel Hawksley joined us to dig into the deeper ideas behind UI architecture — the ones that outlive frameworks, trends, & hot takes. One of the most grounded, clarifying conversations we’ve had.

ReScript doesn’t just help you write better code—it changes how you think about it. Josh Vlk joined Dead Code to talk about how it pushes developers toward cleaner logic, safer state management, and refactoring without fear.

Forget the old names. No more OCaml baggage, no ReasonML confusion, no Belt.Array2 nightmares. ReScript has finally stepped into its own—and it’s smoother, faster, and way more familiar than you think.

This was a thoughtful interview about an ML with great dev experience on the JS ecosystem, which is a compelling combination. I found a nice 3rd party writeup of its current state: lobste.rs/c/pqdn4v

In JavaScript, there are a hundred ways to solve the same problem. In ReScript, there’s one—and it actually makes your life easier. Josh Vlk explains why enforced consistency might just be the future of clean code.

JavaScript’s grown-up sibling just entered the chat. Strongly typed, zero config, and built for people who want their code to just work. Josh Vlk joined Jared to explain why ReScript isn’t just another TypeScript flavor—it’s a full rethink of how we build for the web.

“Sometimes you need null database columns — but only if you’ve thought through why.” David Bryant Copeland talks about building frameworks that guide developers toward better decisions by default.

What’s the bane of David Bryant Copeland’s existence in Rails? Those endless params hashes. In this clip, he explains how Brut gets rid of them for good.

“Rails is easy… but it’s not simple.” David Bryant Copeland unpacks why simple code often takes more effort — and why he designed Brut around that philosophy.

Sometimes fewer knobs make better music. David Bryant Copeland shares why he loves the limitations of his DAWless Looptober setup — and how constraints fuel creativity.

Rails makes it easy to build fast. But do you ever feel like you’re learning everything twice? David Bryant Copeland breaks down why abstractions can get in the way of real understanding.

The hardest problem in computer science? Naming things. Adam Tornhill explains why *good names* don’t just help humans, they also help your AI assistants write and reason better code.

Healthy code isn’t just aesthetic. It’s measurably faster. Adam Tornhill’s research shows teams working in clean codebases ship 10× faster with 15× fewer defects. That’s the real business case for code quality.

Our brains weren’t designed to juggle thousands of lines of code. Adam Tornhill explains the cognitive bottleneck behind bad abstractions…and how chunking helps us think like computers without becoming them.

“Beauty is the absence of ugliness.” That’s how Adam Tornhill defines clean code — not as clever, but as *unsurprising*. This perspective might change how you see your own work.

Ever wonder why so many software projects fail, even with smart people and good tools? Adam Tornhill’s answer started outside of tech. 🎙️ Hear how psychology helped him see the real reasons we struggle to build successful software.

Amy upgraded my @deadcode.website shirts by tie-dying them.

⚠️ “When it becomes a problem, it’s a huge problem.” Matt Schwager on why Marshal exploits are always critical severity — and why they deserve outsized attention in Ruby security.

📖 The first line of the Marshal docs warns: “This is extremely dangerous to use.” So why do vulnerabilities still happen? Matt Schwager explains why documentation isn’t enough.

😬 “Oftentimes, developers don’t even know they’re using Marshal.” Rails caching defaults, hidden dependencies, and how vulnerabilities creep into production. Matt Schwager dives into why this class of bugs won’t go away.

💡 Simplicity vs. security. One line of Ruby code can serialize anything — which is both the appeal and the problem. Matt Schwager talks about the fundamental tradeoff at the heart of Marshal vulnerabilities.

👉 “We think if we just add enough if statements, we can make this thing safe…” Matt Schwager explains why Ruby deserialization bugs keep resurfacing — even after more than a decade of patches.

Perfection isn’t the point. Kasper Timm Hansen shows how riffing invites developers to throw ideas on the table, refine them, and learn as they go. The result? Better design, less pressure, and a mindset shift that feels surprisingly fresh.

Coding doesn’t always have to feel heavy. Kasper Timm Hansen talks about riffing as a process that makes room for fun, creativity, and experimentation — without losing sight of the end goal. Why being “wrong” for a moment can actually speed you up.

What if the best path forward in your code isn’t a giant leap, but a series of small, playful steps? Kasper Timm Hansen describes how riffing lets you hop between possibilities, uncover hidden insights, and arrive somewhere you never expected.

Big ideas don’t have to live rent-free in your head. Kasper Timm Hansen explains how his riffing files free up mental space while capturing complexity in a way that’s quick, flexible, and surprisingly lightweight. Find out why this makes exploring solutions so much easier.

Ever started a feature and felt paralyzed by not knowing where to begin? Kasper Timm Hansen shares how a simple scratch file technique can turn that overwhelm into clarity. 🎧 Tune in to hear how “riffing” reshapes the way developers explore problems.

AI coding tools can churn out code endlessly, but without checks in place, the results quickly collapse. Justin Searls explains the principle he applies to both AI and his own workflow to keep things real and verifiable.

How do you decide what to work on next? Justin Searls’ approach flips the usual “start with the easy tasks” advice and instead begins with the riskiest unknowns.

We don’t need more order-takers. We need programmers who can think critically, adapt to context, and shape the processes themselves. Justin Searls shares why clinging too tightly to prescribed methodologies can limit real progress.

Everyone knows the term “full-stack developer,” but Justin Searls argues today’s environment calls for something more. He makes the case for developers who own not just the code but also the product vision and decisions behind it.

We often treat code like a static artifact, but what if the real story is how it moves through your head and shapes your workflow? Justin Searls unpacks why execution, tempo, and order of thought matter more than the code itself.

Should executives be the least busy people in a company? The Dead Code team tore into that idea and asked: Why does rest only seem to apply to those at the top?

What makes a good code review? Hint: it’s not nitpicking. The Dead Code crew unpacked how kindness, empathy, and speed can turn reviews from a blocker into one of the healthiest parts of engineering culture.

Big pull requests, slow reviews, and endless pushback…sound familiar? This episode dives into how company culture shapes the way we collaborate and why even a two-commit PR can change everything.

What happens when tech monopolies stop caring about product quality—because they know people will buy anyway? The Dead Code podcast didn’t hold back on what this means for the industry.

When CEOs brag about cutting staff in favor of AI, who really benefits? The Dead Code crew had a lot to say about finance-first leadership and why “number go up” isn’t a strategy for humans.

You might never hear back. You might get silence. But you also might help someone more than you’ll ever know.

Not everything needs to be serious. Sometimes, a silly drawing or a little joke is what makes someone feel like they belong in tech. Approachability matters more than intimidation.

Think it’s all been written already? That no one needs your voice? Think again. You might be the only person someone else finally understands.

You don’t have to understand everything. But sometimes, finding the thing you can understand fully is the most empowering feeling in the world. Retro tech. Simplicity. Total comprehension.

What happens when you build a tutorial for a language you don’t even know yet? Spoiler: You don’t need to be an expert to make something valuable. You just need to start. This is how Ziglings was born.