The Curious Engineer

All blogs / Software / engineering practice

Software Design: Tidy First?

newsletter.kentbeck.com

Software design is an exercise in human relationships. So are all the other techniques we use to develop software. How can we geeks get better at technique as one way of getting better at relationships? Click to read "Software Design: Tidy First?", by Kent Beck, a Substack publication with hundreds

Software / engineering practiceTesting / QAAI / ML

’21’22’23’24’25’26
Posts
455 from 7 Jan 2021 to 30 Oct 2026
Posting
weekly (68 in the last year)
Kind
personal blog
Feed
https://newsletter.kentbeck.com/feed

2026 57

  1. Trust Is the Binding Constraint
  2. We're Renaming This Newsletter (and You Get First Word)
  3. Take My Toil, Leave Me My Struggle
  4. Decompose Run-On Tests
  5. Thinkie: Fix Time, Flex Scope
  6. Tools Aren’t Here to Make Us Feel Good
  7. Mathematicians, Here’s a Way To Think About Your Existential Crisis
  8. Formal Methods Pay Off
  9. Reject Change, Sometimes
  10. Baking a Model
  11. Busy is Short Volatility
  12. Speculative Short Volatility & Neglectful Short Volatility
  13. Canon 3X: Explore/Expand/Extract
  14. How Do You Know That?
  15. Long Vol: What is Volatility?
  16. Long Volatility Development
  17. The Beginnings of an Idea: XP is Long Volatility
  18. When Complaints Are Good News
  19. How Kent Beck shapes the software engineering industry
  20. Air Traffic Control
  21. The Cost YAGNI Was Never About
  22. Why So Literal?
  23. Smalltalk Genie
  24. Trust Factory
  25. Genie Lessons from Genie Sessions: Prose as a Programming Language
  26. Scope Is The Steering Wheel
  27. Hey, N00b, We Didn't Hire You to Complete Tasks
  28. Thoughts, Not Thinking?
  29. Adaptive Radix Tree
  30. Genie Sessions: Run, Right, and Fast for the Adaptive Radix Tree
  31. Genie Tarpit
  32. Genie Lessons: Nobody Wants Agents
  33. Passing Tests Bore Me
  34. Extreme Time Value of Money: Late-stage Career Planning
  35. Parkinson's
  36. The Bridge: Too Far
  37. Potpourri: Lessons from an AI Leadership Conference
  38. Starving Genies
  39. Genie Sessions: TCR Skill
  40. Tremors
  41. Why Your Progress Is About The Same As Everyone Else's
  42. Forest Thinning
  43. A few questions about what you're working on...
  44. Genie: Death of the Iron Triangle?
  45. Don't Accomplish Everything
  46. Earn *And* Learn
  47. Genie Session: Codex for Mac/GPUSortedMap
  48. Generation Gap or Just Rude?
  49. Labor Replacement is a Poison Pill
  50. Is Source Code Going Away?
  51. The Pinhole View of AI Value
  52. Can Genies Break Down Silos?
  53. Genie Sessions: Optionality
  54. Tidy Together Reboot
  55. Taming the Genie: "Like Kent Beck"
  56. Bridges
  57. My Fitbit Buzzed and I Understood Enshittification

2025 82

  1. The Precious Eyeblink
  2. Party of One for Code Review!
  3. The Bet On Juniors Just Got Better
  4. Explore *Then* Expand *Then* Extract
  5. Monday - Last Call on $180/Year
  6. Tidying: Canonical Order
  7. If You've Been Thinking About Subscribing to Premium...
  8. Why Does Development Slow?
  9. Intentions & Actions
  10. Composable Tests
  11. Pitching Hackathon Ideas: Oxymoron
  12. Getting Ready to Launch
  13. First Principles First
  14. Separate Failed Assertions from Unexpected Exceptions?
  15. Teaching Augmented Coding
  16. Programming Deflation
  17. Genie Fight
  18. Switching Scale
  19. Beyond the IDE
  20. Genies Getting Stuck
  21. Leaving the Nest
  22. Genie Fight
  23. New Is The New Black
  24. Cloud Development Environments Tame Complexity By Reducing State
  25. Match The Pipes
  26. Kent's Going Home
  27. Conclusion: Final section intro from Tidy Together
  28. Theory
  29. Management Section Intro: Tidy Together Chapter
  30. Tokens: The New Oil
  31. Preface to Tidy Together
  32. The First Feedback Filter
  33. Survival, Cash Flow, & Options
  34. Augmented Coding: Beyond the Vibes
  35. Return of Multi-tasking?
  36. Features & Options Revisited
  37. Augmented Coding: Coached by the Genie
  38. Me an' Algernon
  39. Augmented Coding: Copy/Paste Detector
  40. Functional Genie
  41. The Generalize Step In TDD
  42. Augmented Coding Technique: Copy From Simpler Language
  43. Copy From a Simpler Language
  44. Legitimate Peripheral Participation
  45. Free Idea: Train on Changes, Not on Code
  46. My Augmented Coding Tools As Of 16 May 2025
  47. Thinkie World Congress 1
  48. Persistent Prompting
  49. Genie Wants to Leap
  50. Augmented Coding is Good For Exploration
  51. The Platonic Database
  52. Augmented Coding & Design
  53. Why TDD Doesn't Lead to Dumb Code
  54. Design in TDD
  55. Augmented Coding: Negative Feedback
  56. One Pile
  57. Social AI Adoption: Lessons from Hybrid Corn
  58. When Should Visual Design Precede Implementation?
  59. Retrospective Performance Reviews
  60. Tidy Together Scope Trim
  61. Structure Folks & Feature Folks
  62. Hand-Drawn Illustrations
  63. How Long Should Functions Be?
  64. Deadlines in The Forest
  65. Reflecting on FnD: Parallel Universes
  66. The Threat of Incremental Delivery
  67. Caterpillar to Butterfly
  68. Anatomy of Oscillation
  69. How I Will Measure My Life
  70. Chapter Bundles of Options
  71. Options, Financial & Software
  72. Tidy First Example
  73. Developer Productivity Metrics: Education Necessary
  74. Measuring Programmer Influence, Kinda Sorta
  75. Remote Site Growth Is Not A Conquest Game
  76. Personal Site Refresh
  77. Additional Testing After Refactoring
  78. Meeting Prevents Exceeding
  79. Kent Beck: Illuminating the Pattern Language of Modern Life
  80. Moving On
  81. Bugs Optional?
  82. Managing Expand Projects

2024 127

  1. Complain & Propose
  2. Far Behind The Eyes
  3. Different Bests in Different Contexts
  4. The Explore That Cannot Fail Is Not An Explore
  5. Intentions & Actions
  6. “Best” Practices Ain’t...
  7. The Product Development Triathlon
  8. Measuring Lines/Function
  9. Refactoring: Narrow ↔ Widen Parameter
  10. Learning in the Forest
  11. One Hand On The Yoke
  12. Fruits & Roots
  13. Flying Solo
  14. Attracted To The Desert (Or The Forest)
  15. Forest & Desert
  16. In Praise of the Desert
  17. TT Chapter: Fat-Tailed Distributions
  18. The Captain Class
  19. Tidy Together Chapter: Long-Running Design Changes
  20. Moving Mental Mountains
  21. Background Work
  22. Why Insurance Companies Are Rationally Failing Their Social Purpose
  23. Safety & Freedom
  24. Profiting From (Some) Failure
  25. Which System?
  26. Constraints on Software Design
  27. Live Drawing
  28. Empirical Software Design Q/A
  29. Slow Deployment Causes Meetings
  30. Authority & Responsibility
  31. Mixing Design & Features—Experiment, Initiate, Sustain, Abandon, & Finish
  32. Old & Single & Unready to Mingle
  33. Chapter: Make It Run, Make It Right, Make It Fast
  34. Product is a Party, Not Chess
  35. The Life-Changing Magic of Tidying Up Code
  36. Scope Management 101
  37. Private Reflections on Founder Mode
  38. The Impossibility of Making an Elite Engineer
  39. The Founder Mode Tradeoff
  40. Example of Thinkie: Laughter
  41. Ad Hoc Infrastructure
  42. Corner Meet Paint
  43. Scrape Then Paint
  44. Enthusiasm: Managing Our Most Precious Resource
  45. Big Feet In Small Shoes
  46. No "We" in IC
  47. Humans >> Data
  48. Refactoring Catalog
  49. Software Is Bananas
  50. Refactoring: Constructor <-> Builder
  51. Game Over Absorbs Future Winnings
  52. Responsible Slack
  53. Refactoring: Boolean In Constructor <-> Subclasses
  54. Boolean Parameter To Switches
  55. A Loaf of Roadmap
  56. July Founders' Call: Monday, July 15
  57. The Economic Case for JUnit Max
  58. Standups: Individual → Teammate
  59. TDD is Not Hill Climbing
  60. Hinge
  61. Minimum Viable Product revisited
  62. "Good" Design
  63. The Trough of Despair
  64. TT? Chapter: Fields Object
  65. Start Presentations on the Second Slide
  66. The Documentation Tradeoff
  67. New Tidying: Reconcile Parameter Order
  68. TT? Chapter: Parameters Object
  69. Present Factory Chapter: The Incentive Paradox in Software Design
  70. Interceptors in JUnit
  71. TT? Section Intro for Refactorings
  72. Founder Call Friday, 7 June 2024, 0830 PDT
  73. Best Standalone Tidy First? Chapter?
  74. Coupling and Cohesion
  75. Why I Wasn’t Writing Tidy Together
  76. TT? Chapter: One Principle, One Technique
  77. Tidy Together? Outline
  78. Why Accelerate Deployment?
  79. Surprise Factory: Cohesion: Coupling’s B Side
  80. Sales Happen When Buyers Fear Missing Out
  81. (Revised Surprise Factory Chapter) Coupling: Why Software Costs So Damn Much
  82. Stretching Your TDD Skills
  83. The Saff Squeeze
  84. One At A Time
  85. Untangling Spaghetti: Debugging Non-Terminating Object Programs
  86. AI & Software Development 2
  87. AI & Software Development
  88. To Test or Not to Test? That’s a Good Question
  89. Getting There From Here
  90. TDD's Missing Skill: Behavioral Composition
  91. Surprise Factory--Coupling: Why Software Costs So Damn Much
  92. Design is an Island
  93. Features & Design: Both Essential & Yet Mutually Exclusive
  94. The Open/Closed/Open Principle
  95. Features & Design: A Dance of Contrasts
  96. Money Shapes Design: The Economic Drivers of Software Development
  97. Productive Compliments: Giving, Receiving, Connecting
  98. The 3X Model - The Sensible Path to Chaos The Genesis of the 3X Model
  99. The Tale of Two Teams
  100. Tidy First? in One Page
  101. Crazy Idea: Tidying Wrasse
  102. Rent-a-Kent for "The Pleasure of Pattern"
  103. The Pleasure of Pattern
  104. Rent-a-Kent for Mastering Programming
  105. Mastering Programming
  106. Rent-a-Kent for Front-End Vs Back-End Post
  107. Front-end Versus Back-end
  108. Dissecting a Case of Imposter Syndrome
  109. It Didn't Happen, It's Not That Bad, It's Your Fault Anyway
  110. Exploring AI
  111. ChatGPT's Second Derivative
  112. Inserting Logic: Improving My Problematic Behavior Starting at the Roots
  113. Your Outcomes From Tidy First?
  114. History of This Newsletter In One Chart
  115. Tradeoff Booklet: Example Potpourri
  116. My Sustainable Newsletter
  117. Free Idea: Analyze Test Runs
  118. I Learn a Surprising Lesson About Human Motivation
  119. A New Literature
  120. Debut of Rent-a-Kent
  121. Productivity Measurement as a Tradeoff
  122. Gathering Twigs for My Nest
  123. January Founder's Call
  124. Niklaus Wirth: 1934-2024
  125. The Book is Now the Vinyl of the Intellectual Life
  126. Request for Examples: Pass-Through Interface
  127. Professional Pricing

2023 83

  1. Maybe Accumulating Employees is a Core Competency
  2. The Surprise Factory
  3. Tradeoff Booklet: Tradeoff Decisions
  4. Not My Money Any More: Lessons from Poker 4
  5. Canon TDD
  6. Recommending Kent Beck: 2011
  7. December Founders' Call
  8. TDD Isn't Design
  9. Expanding Myself to Nothing
  10. TDD is Kanban for Code
  11. Just Ship, Baby
  12. Taming Complexity with Reversibility
  13. Business Evolution
  14. TDD Outcomes
  15. Idea: CodeFeed
  16. Pulling Practice, Not Pushing
  17. "Testing" Structure Changes
  18. Idea: LayoutFeed
  19. TDD Prerequisites
  20. Founder call details
  21. Private Estimates, Public Progress
  22. Founder Call: Book Launch Party!
  23. Idea Portfolio
  24. To Design or Not To Design?
  25. Why Software Design Matters
  26. First One, Then Many
  27. Book 2 Topics?
  28. Coding in the Debugger
  29. Timing
  30. Helping Geeks Feel Safe in the World
  31. Don’t Cross the Beams
  32. September 2023 Founders Call
  33. Dimensions of Power
  34. Incentives: The Hits
  35. A Career Accounting
  36. Measuring developer productivity? A response to McKinsey 2
  37. Kent Beck: Business
  38. Measuring developer productivity? A response to McKinsey
  39. Founders' Call
  40. Effort/Output/Outcome/Impact, Take 2
  41. Ergodic Development
  42. Design Intuition
  43. Book Editing
  44. Publish Everything (Pretty Much)
  45. Idea To Impact
  46. Eventual Business Consistency
  47. Ergodic: Good Thinkie, Awful Name
  48. State of Tidy First?
  49. Emotions: A Code Book
  50. Envy Brings a Lesson
  51. Fresh Work 80/15/5
  52. Accounts & Transactions
  53. Snapshot Testing
  54. Paint Drip People
  55. Code “Smells”?
  56. When Did It Happen? When Did We Find Out?
  57. Invite your friends to read Software Design: Tidy First?
  58. Never Forget
  59. What If You *Are* Going To Need It?
  60. Confusion to Sense to Boundaries to Leverage
  61. Two More Implementation Patterns
  62. Barry "Prof Barry" Dwolatzky, April 29, 1952-May 16, 2023
  63. Abstract vs. Concrete Parameters
  64. Appreciating Your Way to XP
  65. Bet On Growth
  66. More What, Less How
  67. 90% of My Skills Are Now Worth $0
  68. Why "Empirical"?
  69. Examples Needed: Reading Order & Cohesion Order
  70. Thinking About Code Review
  71. Why Write "Tidy First?": Personal Coda
  72. Why I Came to Write "Tidy First?"
  73. How I Came To Write "Tidy First?"
  74. Fool Proof Design
  75. Accountability is Not Blame
  76. Boss/Employee is not Exactly a Prisoners' Dilemma
  77. Scaling Extreme Programming: Dependencies
  78. Signaling Cooperation: Employee's Dilemma
  79. Responsibility
  80. Delay Versus Friction
  81. Design Play at Work
  82. Sign-up Versus Assignment
  83. Design Play

2022 72

  1. The Pie Problem
  2. Team Matching Creates Incentives
  3. The Story of A
  4. Performance Review Incentives
  5. Underpaid Programmers
  6. Distinctions With A Difference
  7. Sources of Friction, Sources of Harmony
  8. Conclusion
  9. Cohesion: ...And Elements That Aren't Coupled Go Elsewhere
  10. Downside of Design as Increasing Cohesion & Reducing Coupling
  11. Next Book Topics?
  12. Push Back, Finally!
  13. Cohesion
  14. Musing: Aligning Authority & Responsibility
  15. Coupling
  16. Beneficially Relating Elements
  17. Final Push To First Draft
  18. Options Versus Cash Flows
  19. Options
  20. Behavior Change = Revenue Versus Structure Change = Option
  21. A Dollar Today > A Dollar Tomorrow
  22. Economics: Time Value & Optionality
  23. Discarded Chapter: Time Value of Money
  24. Constantine's Equivalence
  25. Reversible Structure Changes
  26. Geographic Compensation Will Lose
  27. Tidying Versus Sooner
  28. Better?
  29. Better/Sooner/Cheaper/More
  30. First, After, Later, Never
  31. Rhythm
  32. Sooner Versus Longer
  33. Batch Sizes
  34. Summer Hiatus
  35. Tidying: Move Declaration & Initialization Together
  36. Theory Outline
  37. Structure & Behavior
  38. Section: Theory
  39. Earning to Write, not Writing to Earn
  40. Relationships: Non-geeks, Geeks, & Self
  41. I'm Having Trouble Writing
  42. Getting Untangled
  43. Chaining
  44. Managing
  45. Management: Separate Tidying
  46. Sketching the Management Section
  47. Tidying: One Pile
  48. Tidying: Extract Helper
  49. Perverse Incentives of Retrospective Promotions
  50. Tidying: New Interface, Old Implementation
  51. Tidyings are Almost Done
  52. Tidying: Chunk Statements
  53. Explaining Constant
  54. Explaining Variable
  55. Self, Team, Product
  56. Explicit Parameters
  57. Cohesion Order
  58. Normalize Symmetries
  59. Reading Order
  60. tl;dr Cohesion
  61. tl;dr Coupling (& later Cohesion)
  62. Add Comment
  63. Delete Redundant Comment
  64. Prototype Tidying Example Leaderboard
  65. Tidying Example Bounty
  66. Obligation: Incentive to Write
  67. What to Expect as a Paid Subscriber
  68. Tidying: Dead Code
  69. TF? Book Outline
  70. Book Writing Resumes
  71. Guard Clause
  72. Desirable Unit Tests

2021 34

  1. Fixed Equity Grants Become Toxic
  2. Accountability in Software Development
  3. No-compensation Ratings
  4. Ratings as Incentives
  5. Incentives Change Marginal Behavior
  6. Change
  7. Authority, Responsibility, Blame, Accountability
  8. Make It Run, Make It Right II
  9. Geek Incentives Manifesto Expanded
  10. Jocelyn Goldfein Hits the House
  11. Collaboration Incentives
  12. Make it Run, Make it Right
  13. Lumpers & Splitters
  14. Waze Founder's Comments, Space of All Incentive Systems
  15. Patterns of Performance Review & Compensation
  16. Incentives Not To Invest In Structure
  17. Follow the Incentives, Waze Edition
  18. Incentives >>> Money
  19. Geek Incentives Clubhouse Debut with Keith Adams
  20. Beneficially Relating Teensy-tiny Elements
  21. Mysteries of Geek Incentives
  22. It's Not Programming
  23. The Geek Incentives Manifesto
  24. Structure & Behavior PRs
  25. Structure & Behavior
  26. Beneficial Relationships
  27. Elements All The Way Down
  28. Software Design Dilemmas: A Survey
  29. Chunk Size
  30. Discuss fixed tidying budget
  31. 30% Tidying?
  32. Mind-sized Chunks
  33. Welcome to "Tidy First?"
  34. Software design is an exercise in human relationships.