TDD changed how I write software. Agentic engineering is changing it again. I don't think the classic red-green-refactor loop of TDD makes sense when an AI agent is writing the code. I've been a proponent of TDD since I read @KentBeck's XP Explained. I roughly followed what he describes as "Canon TDD": 1. Write a list of the test scenarios you want to cover. 2. Turn exactly one item on the list into an actual, concrete, runnable test. 3. Change the code to make the test (and all previous tests) pass, adding items to the list as you discover them. 4. Optionally refactor to improve the implementation design. 5. Until the list is empty, go back to #2. I say roughly, as I was never good at sticking to #2. I'd turn two or three test scenarios into runnable tests at a time, often using table-driven or parameterised tests. This process adds value when a human is writing code. But when an AI agent is doing the writing, I think Test First Development is currently a better approach. We can define all the test cases, let the AI write all the tests, then let the AI write the code to pass them. Doing each step one at a time would be a much more expensive way of using the agent. There would be far more tool calls, far more roundtrips to the inference engine, and it would consume a lot more tokens. Then there's the difference between the agent and an engineer. The agent isn't necessarily going to refactor like a human engineer would. I don't think we lose much from this change. We can still guide it after each feature to evolve the design. We can still iterate quickly and get fast feedback on the design and functionality. Are you still doing red-green-refactor when the agent is doing the typing?

I've loved AI for a long time. Not the hype cycle version. The real thing. Which is exactly why I can see its flaws. Something strange is happening in tech discourse. If you're not a full believer, you're a skeptic. Point out a limitation and suddenly you "don't get it." We've lost the ability to hold two thoughts at once: this is valuable and this has real problems. That's not nuance. That's tribalism. Here's the irony: we worship innovation. But innovation almost always comes from someone who loved something enough to see what was broken in it. Jobs wasn't anti-computing. The Wright brothers weren't anti-transport. Passion and criticism aren't opposites. They're partners. AI is transformative. It's also improvable. Those two facts coexist just fine. The people who'll actually move it forward aren't the loudest cheerleaders. They're the ones asking uncomfortable questions. That's how progress works.