Domain Knowledge Is the Leverage

It's becoming very clear now that the things that make code easier for humans to work with are almost exactly the same things that make code easier for agents to work with. Modular boundaries, clear interfaces, good tests, and detailed domain language. If you have well-modularized code, an agent can work on one piece without needing the entire codebase in context. If you have good tests, you can verify that what the agent produced actually does what you intended.

Most programmers felt the satisfaction of getting a single function just right. You take a messy file, make tiny safe steps, and eventually the way it should be written becomes clear. That kind of micro-level work doesn't have the same leverage anymore. An agent can produce a reasonable implementation faster than you can refactor one. The thing that is becoming more apparent as more valuable now is understanding the domain and how it connects to the program. It's somewhat similar to the shift you'd feel moving into more and more senior roles on a team, you'll have to maintain the overall shape of the system and the contracts between its components.

This is why specs are becoming interesting. Many are talking about spec-driven development now, and there's a lot of warrented (and some unwarrented) pushback. Obviously specs are not supposed to be 10k lines of documentation that nobody reads, they should act as a way of capturing decisions. What are the interfaces? What are the dependencies? What constraints do they need to hold? Right now, if you can express those clearly, you have something an agent can work from and something you can verify against.

Another thing that's becoming more obvious now is that nobody really has all the answers, we're all experimenting⊕ I've been running my own experiment with Ossature, where the spec is the source of truth and each task gets only the context it needs.. The tools change week to week. Something that failed last month might work this month. The insights that matter are coming from running small experiments to validate whether some claim is true. Not taking anyone's word for it, including AI's.

And tests matter more than ever. When you have a powerful tool generating code for you, you need a way to check that it did the right thing. Seems like 25 years of people pushing test-driven development was good preparation for what's coming.