Are you brave enough to refactor? That's the question I keep circling back to. Not "can you refactor" or "do you know how to refactor." Brave enough. Because the technical part isn't what stops people. It's the fear. The mess looks load-bearing. Touch it and maybe everything falls over. So you don't touch it. You build around it. And the mess grows.

Been thinking about this in the context of agents. You plan something out—thorough, detailed, the works. Agent goes into execution. And somewhere between your beautifully structured plan and the actual code, the abstraction level shifts. You're operating at a surface now. Approving diffs, scanning outputs, pattern-matching on vibes. Even if you went absurdly deep during planning, the execution isn't a clean handoff. It's a negotiation. And negotiations produce compromises. Pile on three features and suddenly you're staring at something that technically works but structurally? A mess you half-understand.

Two paths, both imperfect. You pick tiny items, ship them one by one—disciplined, clean. Except even before agents existed, PRs were already ballooning to thousands of lines. That discipline was always aspirational for most teams. Or you do what developers actually do: build a bunch of stuff, hit a natural pause, and call that the review checkpoint. With agents accelerating the build phase, the pause comes faster but the mess comes faster too. You're reviewing more code you didn't write, making judgment calls on architecture you didn't choose. Perfection was never on the table. Now it's not even in the building.

So refactoring becomes the skill. Not an afterthought. Not the thing you do when tech debt gets embarrassing. The actual core loop. Build, realize it's wrong, tear it apart, rebuild it better. Repeat. The developers who'll thrive are the ones who can look at working code and say "this needs to change" without flinching. That confidence doesn't come from tooling or process. It comes from understanding the system deeply enough to know what bends and what breaks. Willingness to refactor is a direct signal of how well someone understands what they're working in. No understanding, no confidence. No confidence, no refactor. Just more code piled on top of code nobody wants to touch.