As a Software Crafter, I have two interesting parts in my brain.
One is the compiler. I use it to read code, interpret it, and infer what it’s doing. It’s important for reviewing, for identifying bugs, but also for writing it.
The other one is the designer. It scans the structure of the code without caring about what it’s doing. No need to understand the names or the algorithm. It just scans for structural patterns and suggests known ways to improve them. It has experience and taste, what to care about and when.
When someone gives me a complicated piece of code, and most of the time that’s the case, my designer takes over. It blocks my compiler from even starting. Those structural issues cannot be unseen. So I’ll insist on using the designer first, to refactor the code. And while doing that, I don’t care about what the code does, I don’t need my compiler brain, I only focus on structure. I do that until it’s easy to read, until it says what it’s doing in small portions, until it’s literate.
And only then will the designer brain allow me to use the compiler brain again, and it will have an easy time. That way I don’t have to suffer through compiling a mess. I can’t help but use this strategy to save my own mental energy. This is my brain making me follow the principle of least effort. Evolution has taught it.
The AI does not have this luxury. It will compile whatever code you throw at it. It is relentless. And its compiler is much better than any of ours. The AI is extremely good at compiling. Until it hits a wall, and it can’t anymore. This is when the code is so complex, that it can’t take all the pieces into consideration anymore. Too many things to hold together. And so it fails to compile, it fails to understand. I call this point the complexity wall. Funny thing is, when you let AI code a project long enough, it will produce messy code, and it will eventually hit this wall.
But at the same time we trained it so hard to please us, it so desperately wants to give us the answer we want to hear. That it can’t help but give the answer that’s most plausible to it. Even if it’s wrong. And then it will confidently say, that it did understand, that it did solve it, that it has the solution. Except it hasn’t. And when it hits that wall, it has no fallback. No designer to step in and say: stop, clean this up first. We’ve been training it to lie to us.
I have the luxury to say, “this is too complicated, I don’t understand, I actually don’t want to understand, I have to refactor it first”. AI doesn’t.
Software Craft has always been about the principle of least effort. The paradox is, that craft takes effort, takes deliberateness. But we do it to save effort. We do it to go further. Craft makes sure what goes into your mind is worth the space. Smaller, clearer, simpler. Your context window stays the same. You go beyond the complexity wall, by improving what you fit inside it.
And take care, Software Craft is not AI’s default. Craft still matters. And AI still needs someone to teach it. Over and over again, because it doesn’t learn.