willgarrett.iowillgarrett.io — ~/notes/008-shorten-the-feedback-loop.md
~ ❯ cat notes/008-shorten-the-feedback-loop.md

008-shorten-the-feedback-loop.md

The wait between writing code and knowing

Development gets harder when a small change takes too long to check.

When I think about what makes development feel slow, I keep coming back to the wait after a change. You edit a few lines, start a check, and lose the thread before the result arrives. By the time you know whether the change worked, you may already be considering something else.

Some waits are unavoidable. I still want to understand how much work an engineer has to do before they can answer a small question. Can they run the relevant behaviour locally? Do they need a shared environment? Does a failure point back to their change, or send them searching through unrelated setup problems?

Pick one change and follow it

A useful way to examine the workflow is to take a modest task and follow it from checkout to a visible result. The task might be changing a validation rule. I want to see what is needed to supply an input, observe the response, and confirm that an existing case still works.

That exercise makes the obstacles concrete. If the rule can only be exercised through the whole application, a smaller test may help. If local setup depends on an explanation in chat, the setup instructions need attention. If the check passes but the deployed behaviour differs, we need to understand the difference between the environments.

Each of those calls for different work. I would avoid opening with a broad tooling replacement when the immediate obstacle might be a missing command or a piece of business logic that needs a clearer boundary.

Keep a route to a fuller check

A quick check needs a clear scope. A test of a calculation tells me about that calculation. It leaves open whether the application passes it the right inputs. I want a way to move from a narrow check to exercising the behaviour through the running system.

The feedback should also explain failures. Saving a minute on a test run helps less if an engineer then spends twenty minutes working out which condition failed. A useful failure message and reproducible input can make the next edit much more focused.

This work competes with visible features, so I prefer to attach it to a task the team already needs to complete. Improve the way we check that change, then have another engineer use it. Their attempt will show whether the improvement survives outside the machine and habits of the person who made it.