Bullsh*t Engineers Say Tier List (Lost Episode) | Standup #57

Overview

The video is a stand-up style “tier list” ranking thought-terminating software engineering clichés—phrases people use to shut down discussion rather than reason through architecture, performance, or tradeoffs. The panel frames the task as ranking which phrases are:

• F-tier: most harmful
• S-tier: least harmful

Core discussion themes

• Clichés often block thinking by encoding a false “default answer.” The hosts argue many phrases are either:

  • Non-informative (e.g., “it depends”), or
  • Incorrectly universal (e.g., “premature optimization…”).

• Context and incentives matter. Several clichés are debated as dependent on the environment, such as:

  • startup vs. monopoly settings
  • production constraints
  • team maturity
  • UI vs. backend work

• Some phrases are “honest tradeoffs,” not always mental shutdowns. For example, “programmer time is worth more than CPU time” is criticized less when it reflects a transparent business choice rather than self-congratulation.

Key tier-list arguments highlighted

Worst / highly harmful

• “Premature optimization is the root of all evil” Argued as basically meaningless and misleading, because:

  • “premature” has no clear point in time, and
  • it discourages optimization by implying it’s never the right move.

• “Make it work / make it right / make it fast” Criticized as often used to justify deferring hard parts. The panel notes this can lead to teams shipping a version that later becomes the foundation—creating user/management lock-in that makes refactoring and optimization harder.

High harm

• “Programmer time is worth more than CPU time” Debated as situational:

  • sometimes it’s a blunt “we’ll pay for compute” tradeoff
  • but it can also normalize endlessly slow software in ways that prevent real quality work

Lower harm / situational

• “Never do a full rewrite” Strongly disliked as a universal rule, but not considered maximally harmful because full rewrites are often “rarely do a full rewrite.” The panel stresses rewrites may be correct when:

  • legacy code lacks knowledge, or
  • constraints require a reset Otherwise, rewrites can lose “baked-in” operational complexity and increase risk.

• “DRY / Don’t repeat yourself” Treated as ambiguous:

  • thought-terminating when used to force abstractions prematurely
  • useful for preventing duplication in your own work
  • can be misused via “util libraries that no one uses”

• “YAGNI (You aren’t going to need it)” Discussed as self-terminating in principle—it discourages building features based on future uncertainty. The panel also jokes about whether they’ve all heard it equally.

• “It depends” Considered potentially thought-terminating when used to avoid actionable answers (especially in senior-junior dynamics), but also framed as sometimes reasonable when tradeoffs are genuinely real.

Least harmful / more pragmatic

• “Fast, cheap, good—pick any two” Mostly agreed as hardware-derived but still useful. The panel lands it as relatively less harmful because it reflects real constraints—while acknowledging software delivery complicates the meaning of “cheap” and “good” cost models.

• “Use the right tool for the job” Argued as highly harmful (S-tier worst) when interpreted as:

  • “pick whichever stack is fashionable,” or
  • “default to your preferred tech” rather than making an evidence-based choice. One contributor defends it as a strategic framing to introduce better tools or “sneak in” new languages/services.

Closing remarks

The group ends by confirming they already produced the ranked list and encouraging viewers to screenshot it and argue about it on social media.

Presenters / contributors

• Biggin
• Bot
• Trash Dev
• Casey Muratori (computerandhands.com)
• After Midnight Prime
• Wally (mentioned/called out during the “next one” bit)