During a routine code review, a new "Skill" file was discovered, automating configuration variable synchronization across disparate locations. While impressive with its AI hooks and automation scripts, this solution was a questionable use of engineering effort. The problem wasn't poor code, but that the code shouldn't have existed. Had the project followed the DRY principle, there would be a single source of truth for configuration. This highlights a trend where powerful tools address problems stemming from avoidable design decisions, perceived as progress. This "illusion of productivity" confuses doing more with doing better, masking structural issues with advanced automation. It's a modern form of over-engineering, using high-tech solutions for problems that shouldn't exist. Technical debt, once expensive to fix, is now cheaper with AI, paradoxically leading to its deferral as developers opt for complex AI-driven workarounds instead of architectural fixes. The core issue is how problems are framed; developers may not understand the value of principles like a Single Source of Truth, leading AI to optimize suboptimal approaches. This pattern is driven by visible automation appearing as progress, incentives for features over design quality, and short-term optimization. While some automation is necessary in complex distributed systems, the distinction lies in whether it addresses inherent constraints or avoidable design gaps. Developers should pause before using AI for repetitive tasks and ask if the task stems from genuine complexity or preventable design flaws. AI should explore new frontiers and optimize where complexity is unavoidable, not compensate for weak foundations. The goal is to solve problems with minimal complexity, not to automate inefficiency.