In software development, the temptation to let artificial intelligence handle quick fixes can backfire spectacularly. Consider the case of a mid-year trainer replacement for an already-booked course. The apparent solution—a simple database update—seemed straightforward. Yet, the real challenge lay hidden in workflow dependencies, access controls, and audit trails. Without pausing to explore multiple structural alternatives, developers risk creating technical debt that surfaces months later.
The hidden costs of solo AI decisions
When AI generates code without sufficient context, three deceptive forces push developers toward premature execution. First, the pride of immediate context convinces engineers that their situational awareness eliminates the need for broader consultation. Second, speed metrics often prioritize lines of code written over long-term maintainability, obscuring the true cost of rework. Third, cognitive amortization—a misplaced belief that delegating decisions erodes expertise—overvalues solo execution.
These forces create a dangerous illusion. Contextual awareness often blinds developers to blind spots they haven’t considered. Speed metrics ignore the hidden rework cycle. Cognitive amortization confuses execution with decision-making—the AI suggests options, but humans still choose. The real risk lies in assuming AI alone can navigate complex business logic, permissions, and audit requirements.
A three-option framework for better AI collaboration
The solution involves flipping the script before any change that impacts audit trails, permissions, or workflows. Instead of letting AI generate a single solution, engineers should request three structurally distinct options. Each option must explicitly address three critical dimensions: business impact, code surface area, and operational overhead.
For example, a trainer replacement in an education management system might yield these three approaches:
- Option A: Direct database update with minimal traceability, suitable for low-risk changes but prone to later reconstruction efforts.
- Option B: Full workflow closure with explicit motives, creating a new registration record linked to the updated trainer. This provides robust audit trails but increases code complexity.
- Option C: Hybrid approach using status flags and manual notes, balancing traceability with development effort.
The key isn’t selecting the fastest option—it’s eliminating the option that would later require three hours of forensic debugging. In this case, Option B prevented weeks of potential parent inquiries by ensuring every change left an immutable record.
When to apply the three-option rule
This framework only applies to decisions that leave business-side traces: audit entries, permission modifications, or workflow transitions. Low-stakes technical choices—like selecting a database index or choosing a TypeScript function signature—don’t require this deliberation. The rule measures success not in lines of code written, but in lines never rewritten.
The three-option pattern forces developers to confront the full lifecycle of their changes. It transforms AI from a shortcut tool into a collaborative partner that surfaces blind spots before they become production fires. The investment of thirty seconds upfront saves hours of rework down the line, proving that the smartest decisions aren’t made alone—even with AI assistance.
The pattern originates from ask-3-options-before-code/SKILL.md in the github.com/michelfaure/doctrine-counterpart repository, demonstrating how structured collaboration can outperform solo AI execution in complex systems.
AI summary
Yapay zeka destekli kodlama sırasında acele kararlar vermek ileride saatlerce sürecek yeniden düzenlemelere yol açabilir. Üç seçenek kuralıyla daha akıllı, yapısal ve sürdürülebilir kararlar alın.
