The Difference Between Delegating Code and Delegating Decisions
In my last post, I talked about why AI has become part of my workforce. I have too many things I want to build and not enough hours to personally implement every little detail. But there's an important distinction I want to explore. Delegating code and delegating decisions are not the same thing. And I think understanding that difference is going to become increasingly important as AI-assisted…
Software development involves both writing code and making decisions about the system's architecture. AI-assisted development is becoming more common, and understanding the distinction between delegating code and delegating decisions is crucial. Writing code alone is not enough; decisions about what belongs in a library, what should be configurable, and how components should interact are also important. These decisions shape the system before any implementation begins and are not meant to be blindly delegated.
KiwiEngine, a project the author is working on, has a clear architectural philosophy. The goal is to avoid recreating CSS and provide a small vocabulary for expressing common design intentions while allowing CSS to remain CSS. When delegating implementation using AI, the author wants to ensure that the implementation adheres to the established architecture and boundaries.
AI can help create tests, identify repetitive work, and point out edge cases, but it should not have the authority to redefine the system or introduce dependencies without approval.
The author emphasizes that AI should not be given independent authority to commit code or rewrite the architecture. Instead, AI should be used to implement established patterns, create tests, and identify repetitive work. The author wants to retain full architectural authority and remain responsible for the work. AI can challenge the author's decisions and provide alternative solutions, but the final decision should be deliberate and not silently implemented.
To effectively use AI in software development, the author believes that engineers need to become better at communicating engineering intent. Clear and specific instructions help reduce assumptions and make it easier to evaluate the work. For example, instead of saying "Add a theme system," the author can provide a detailed explanation of how the theme system works within the existing system.
The author acknowledges that using AI doesn't mean stopping the pursuit of learning. They still want to understand software architecture, improve programming skills, and grasp the technologies behind their projects. AI should extend their capacity, allowing them to spend more time on designing systems and solving problems, rather than performing repetitive tasks.
The distinction between delegating code and delegating decisions matters, as it ensures that the author remains responsible for the system's architecture and maintains control over the development process.
Written by urgent.news from Dev.to's reporting — not their text. Machine-written — may contain errors; check the original before relying on it.
