Skip to main content
The Bike Shed

446: All about rewrites

35 min episode · 2 min read
·

Episode

35 min

Read time

2 min

AI-Generated Summary

Key Takeaways

  • Scope rewrites as refactors: Instead of rewriting entire applications, bound changes to specific subsystems, modules, or classes. This transforms risky rewrites into manageable refactoring work that maintains existing behavior while improving internals, allowing teams to continue shipping features without disruption.
  • The 90% done trap: Development work represents roughly 30% of total effort, while 70% involves handling real user interactions, fixing unexpected bugs, and addressing edge cases discovered in production. Avoid demoing unmerged work or mocked features that create false impressions of progress.
  • Prototype window opportunity: Rewrites make sense for prototypes or proof-of-concept code with no test coverage, corrupted data models, or fundamental architectural flaws. Once real users depend on the application, rewrite costs increase exponentially while business justification decreases proportionally with user base growth.
  • Change in place incrementally: Introduce new architectural components gradually rather than stopping all development for a complete rewrite. Structure changes so each piece delivers immediate value—like making one section faster this week, another next week—rather than requiring full completion before seeing benefits.

What It Covers

Joel and Stephanie examine software rewrite projects, exploring when rewrites make sense versus incremental refactoring, the hidden costs of starting fresh, and strategies for modernizing legacy applications without stopping active development.

Key Questions Answered

  • Scope rewrites as refactors: Instead of rewriting entire applications, bound changes to specific subsystems, modules, or classes. This transforms risky rewrites into manageable refactoring work that maintains existing behavior while improving internals, allowing teams to continue shipping features without disruption.
  • The 90% done trap: Development work represents roughly 30% of total effort, while 70% involves handling real user interactions, fixing unexpected bugs, and addressing edge cases discovered in production. Avoid demoing unmerged work or mocked features that create false impressions of progress.
  • Prototype window opportunity: Rewrites make sense for prototypes or proof-of-concept code with no test coverage, corrupted data models, or fundamental architectural flaws. Once real users depend on the application, rewrite costs increase exponentially while business justification decreases proportionally with user base growth.
  • Change in place incrementally: Introduce new architectural components gradually rather than stopping all development for a complete rewrite. Structure changes so each piece delivers immediate value—like making one section faster this week, another next week—rather than requiring full completion before seeing benefits.

Notable Moment

Joel shares his one regret about arguing against rewriting a prototype with corrupted database triggers and zero test coverage, realizing afterward that the two-week timeline would have delivered more value by rebuilding correctly in Rails from the start.

Know someone who'd find this useful?

You just read a 3-minute summary of a 32-minute episode.

Get The Bike Shed summarized like this every Monday — plus up to 2 more podcasts, free.

Pick Your Podcasts — Free

Keep Reading

More from The Bike Shed

We summarize every new episode. Want them in your inbox?

Similar Episodes

Related episodes from other podcasts

This podcast is featured in Best Cybersecurity Podcasts (2026) — ranked and reviewed with AI summaries.

You're clearly into The Bike Shed.

Every Monday, we deliver AI summaries of the latest episodes from The Bike Shed and 192+ other podcasts. Free for up to 3 shows.

Start My Monday Digest

No credit card · Unsubscribe anytime