A nice example of multiple Software Craft tactics :

• Test Driven Development
• Refactoring
• Always Green Refactoring
• Micro commits
• Baby steps
• Intentional commit naming

emilybache added 30 commits 2 years ago

1. Extract method 'findChild'

2. replace loop with pipeline

3. create ChildrenRepository and use in parallel with old soln

4. remove unused children repository

5. Rename field 'childRepo' to 'childrenRepository'

6. replace constructor with factory method

7. introduce class ChildName to wrap name

8. Extract method 'childMatches' 

9. Remove unused method 'getName' and unused field

10. Extract method 'matchesName' 

11. introduce new enum ChildBehaviour

12. Extract variable 'wishlist' 

13. replace multiple returns with returns at the end

14. Revert "replace multiple returns with returns at the end" 

15. replace if with switch

16. move null return statement

17. Extract method 'chooseToyFor' 

18. start using childBehaviour instead of old behaviour string

19. Remove unused method 'getBehavior'

20. new class WishList

21. Inline method 'getWishlist' 

22. Extract method 'getLastChoiceGift' 

23. Introduce parameter 

24. cut over to start using new wishlist class

25. Change method signature of 'getLastChoiceToy' 

26. start using new parameter for wishlist

27. Remove unused parameter 'wishlist1' 

28. move methods to WishList

29. remove unused code

30. Rename method 'chooseToyFor' to 'chooseToy'

During his Codecamp Romania 2025 Masterclass, J. B. Rainsberger answered some questions about software design.

Here are four lightning talks in which he addresses these topics:

1. When not to do TDD and one surprising disadvantage for experienced TDD practitioners.
2. How Client-First Design addresses one of the common shortcomings of naively allowing designs to evolve from the ground up.
3. Adding safety to refactoring without assuming that adding tests is enough or indeed the best choice.
4. Two kinds of refactoring activities and how to communicate the need for each of these to non-programmer members of your project community.

After 25 years with TDD, we are now parting ways. The incremental TDD steps were great for human cognition, but didn't survive the transition to agentic coding.

Test-Driven Development (TDD) has been my default programming mode for 25 years. TDD simply made me a better developer. It’s been invaluable.

However, the time has come to bid farewell to my old companion. Agentic coding is sufficiently different from manual coding, meaning we need to question existing development principles and practices. And TDD didn’t survive my transition into AI-native development: forcing an agent through increments optimized for human cognition negates many of the benefits.

This article reflects on my decades as a TDD practitioner as well as the agentic characteristics that made me abandon the technique. As customary, we’ll start from the beginning.