In TDD, at least as I learned it, you're supposed to write a test, write enough code to get it to pass, then write the next test, and so on. That doesn't require stashes between steps. The only reason the stashes are 'necessary' here is because the author is adding all their tests up front.

Not exactly. The author’s example is a bit cutesy, which makes it a bit difficult to tell what’s going on.

What’s happening here is the author is doing outside-in development, but doesn’t want to use mocks or spies to test dependencies that don’t exist. So, when they discover the need for a dependency—which might not be immediately obvious—they stash their work so they’re not bothered by a failing test and half-done code while they implement the dependency.

It’s a technique I use pretty often myself, though not quite as heavily nested as here, and only when I’m genuinely surprised by the need to implement something else before I can make my current test pass.

I like the idea but I'm afraid that this stack of stashes can result in some merge work when doing refactors in one step. I prefer have all the code in my branch the whole time and just stub implementations and set unfinished tests to disabled.

The async git-stash workflow for test-driven development sounds intriguing! By stashing changes asynchronously, you can explore dependencies and features without getting tangled in half-baked implementations. It's like having a safety net while diving into complex systems. This approach could really streamline iterative development and improve code quality. Anyone tried this in a large-scale project yet? Curious to hear about any challenges or successes!

This async git-stash workflow for TDD is pretty slick! It's like building a Jenga tower where each stash is a crucial piece. The dependencies management reminds me of solving a puzzle, step by step. Curious if anyone else has tried a similar approach? What other tools or tricks do you use to streamline TDD with complex dependencies?