The "Lights-Off" Trap: Why Automation Without Oversight Destroys Codebases

The main point here is that while AI agents can generate code quickly, they do not have the architectural intuition needed to keep software healthy. When you use "lights-off" automation, where agents ship code without human review, you build up technical debt. Eventually, the codebase becomes so messy that it is easier to rewrite than to fix. For engineering leaders, the real advantage is not in using as many tokens as possible, but in building "token-smart" systems that use AI to help humans make better decisions. Understanding this is necessary for any team that wants to scale without ruining their long-term progress.

The Hidden Cost of "Lights-Off" Automation

The idea of a "lights-off" software factory, where agents write, test, and ship code on their own, is appealing. It promises infinite scale and removes human bottlenecks. However, Dex Horthy found a major flaw: when developers stop reading the code, they lose their grasp on the system architecture.

"We built a lights off software factory in July of 2025 and by November we had shut it down. I think it takes about three to six months of you shipping all the time with nobody reading the code before you realize like wow this is getting way worse and it's easier to start over than it is to fix it."

-- Dex Horthy

This creates a dangerous cycle. Agents are trained on benchmarks like SWE-bench, which focus on passing tests rather than long-term design. Because these models do not have a sense of maintainability, they produce code that works for the moment but creates a tangled mess over time. The system feels productive at first, but it becomes a liability later.

Why "Token-Smarter" Beats "Token-Harder"

There is a divide between teams playing "token-harder" and those playing "token-smarter." The first group treats AI as a resource to be maxed out, trying to force productivity by pushing every task into an agent loop. The second group treats AI as a tool to amplify human effort.

The systems-thinking approach is to realize that human effort is a limited, expensive resource. A modern software factory should move that effort to the planning phase. By spending an hour on high-level architecture and specs, a team can save four hours of debugging later.

"If you wanna actually move faster and maintain quality then like you should have these checkpoints before you go to actually write the code and you should use AI to help with that."

-- Dex Horthy

When teams skip planning to let agents "just build," they create a "dumb zone" in their context window. As the context grows, the model struggles to handle architectural constraints, leading to erratic behavior and "slop," which is code that passes tests but is logically unsound.

The Power of the "Slow Loop"

The most durable way to use AI is not through massive, autonomous factories, but through "slow loops." Horthy describes a system where a cron job runs nightly to perform one specific, deterministic task, such as fixing an anti-pattern or narrowing a prop.

This creates a lasting advantage: the codebase improves a little bit every day. Because these changes are small and human-reviewed, they do not carry the risk of a "lights-off" factory. It is a form of continuous, automated gardening. This approach is less popular because it lacks the hype of a fully autonomous agent, but that lack of flash is what makes it durable. It requires the patience to accept 30-50 percent productivity gains today, rather than chasing a 10x "lights-off" fantasy that will likely collapse within a few months.

Key Action Items

• Implement "Slow Loops" immediately: Replace large-scale agentic refactors with nightly cron jobs that fix one specific anti-pattern or linting issue. This creates a compounding quality advantage over 12-18 months.
• Audit your "Smart Zone": Limit your agentic context windows to the first 100k-200k tokens. If your agent begins to hallucinate or try extreme solutions, such as deleting configuration files, treat this as a signal to perform "intentional compaction" by summarizing the state into a new, clean artifact.
• Shift human effort to the planning phase: Over the next quarter, experiment with "spec-first" development. Use AI to generate architectural plans, but require human sign-off on the design before the agent writes the implementation code.
• Kill the "Lights-Off" mindset: If you have an agentic system that no human has read in over 90 days, schedule an audit immediately. The cost of re-onboarding into an agent-written codebase is a hidden tax that will eventually stall your feature velocity.
• Treat "You're absolutely right" as a red flag: If an LLM agrees with your frustration or continues to make the same mistake after being corrected, stop the session. The model has entered a degraded trajectory; start a fresh conversation with a compressed context.