DEV Community: Tyooughtul

When Full Autopilot Goes Wrong: How I Let AI Turn a 2K Line Feature into 8.5K Lines of Technical Debt

Tyooughtul — Fri, 06 Mar 2026 01:53:40 +0000

I recently handed an entire feature to AI—zero review, full trust, "you got this" energy.

Three days later, I had 8,500 lines of code that technically worked, architecturally "made sense" when read file-by-file, and collectively formed a system I no longer understood.

Here's what went wrong.

The Scope Creep Was Silent

The task was straightforward: add an audit log for user permission changes. In my head, that's a controller, a service, a DB table, some frontend forms—maybe 2,000 lines total.

I used Cursor in agent mode. I watched it scaffold. I watched it "think" about edge cases. I watched it create an AbstractPermissionAuditEventStrategyFactory and a PermissionAuditOrchestrator and something called a LogCompactionPipeline.

I didn't stop it because, individually, each file looked correct. Good separation of concerns. SOLID principles. Nice docstrings.

What I missed: No human was balancing completeness against necessity. AI doesn't feel cognitive load. It doesn't know that "you could abstract this" doesn't mean "you should."

By the time I checked wc -l, I had 4x the code with 10x the indirection.

The Testing Mirage

I asked AI to "ensure high test coverage." It delivered 90%+ coverage and a green CI pipeline.

The problem? It tested what passes, not what should pass.

I found tests like this:

describe('AuditService', () => {
  it('should work as expected', () => {
    expect(true).toBe(true);
  });

  it('should handle audit events correctly', () => {
    const mockEvent = { type: 'PERMISSION_CHANGE', userId: 1 };
    // ... 20 lines of setup ...
    expect(service.process).toBeDefined();
  });
});

Coverage: ✅
Confidence: ❌

When I tried to refactor a field name, 40 tests broke—not because they were testing behavior, but because they were testing implementation details that AI copy-pasted from the source code. The tests weren't a safety net; they were a mirror.

The Local Optimum Trap

Here's the strangest part: every single file, in isolation, looked good. Clean code. Proper types. Good naming.

But tracing a single user action through the system required jumping through 6 abstraction layers, 3 adapter patterns, and 2 "middleware pipelines." The AI had optimized each component locally while creating a global mess.

I realized I was reading the output of an entity that doesn't read—it generates. It doesn't understand the codebase; it predicts tokens based on context. When you let it architect, you get maximally "correct" code that minimizes comprehension.

The Reckoning

I spent a day trying to "fix" the 8.5K lines. Then I spent two hours reverting to a clean slate and rewriting it myself—2,100 lines, boring code, works perfectly.

What I Actually Learned

Tab completion was probably the sweet spot.

When AI acts as a pair programmer—suggesting the next line, filling boilerplate, offering alternatives—it augments my decision-making.

When AI acts as the primary author—making architectural choices I don't review—it creates debt at machine speed. Debt that looks deceptively professional.

My new rules:

AI writes functions, not systems. I'll design the architecture; it can implement the utilities.
Review everything. If I can't explain a line in code review, it doesn't ship—even if the AI wrote it.
Write your own tests. Or at least, write the test cases and let AI fill the syntax. AI doesn't know what behavior matters; it knows what syntax compiles.
Complexity budget. If AI generates more than 200 lines I didn't explicitly ask for, that's a red flag, not a feature.

The 8,500-line revert commit is staying in my git history.

It's a reminder that "AI-generated" isn't a synonym for "well-engineered"—it's just fast. And fast technical debt is still debt, just with better syntax highlighting.

Have you hit similar walls with AI autonomy? Or am I just bad at prompting?

I Built a Mac Cleaner That Never Deletes Files Permanently

Tyooughtul — Sat, 28 Feb 2026 12:11:50 +0000

The Problem with "Cleaners"

Last month, I almost lost a week of work. I was using a popular Mac cleaning tool (you know the one) to free up some disk space, clicked "Clean System Cache," and watched as my entire Docker development environment vanished into thin air.

The tool had used rm -rf. No confirmation. No Trash. Just... gone.

Sure, I should have had backups. But here's the thing: why do cleaning apps treat user files like they're disposable? macOS has a perfectly good Trash system. Why not use it?

Introducing Lume

So I built Lume — a macOS cleanup tool with one simple rule: Move, don't remove.

Every file Lume "deletes" actually gets moved to your Trash first. You can open Trash, verify what was removed, and restore anything you need. If Lume's cleanup fails for any reason, your files stay exactly where they are. We never, ever fall back to rm -rf.

Here's what that looks like in practice:

Scanning for junk files, selecting targets, and cleaning — all with the safety net of Trash.

Built for Developers

Most Mac cleaners are designed for "general users," which means they miss the caches that actually eat up developers' disk space. Lume recognizes 55+ scan targets, including:

IDEs: JetBrains family (IntelliJ, PyCharm, GoLand, etc.), VS Code, Android Studio — auto-discovered
Build tools: Gradle, Maven, npm, yarn, pnpm, Cargo, Go modules
Containers: Docker, Kubernetes
Virtual environments: Conda, virtualenv
Browsers: Safari, Chrome, Firefox, Edge, plus dynamic detection of Brave, Arc, Opera
Electron apps: Spotify, Discord, Slack, Teams, Zoom, Notion, Postman, and more

And it scans concurrently using NumCPU workers (max 8), so it finishes in seconds, not minutes.

It Looks Good, Too

I spend a lot of time in the terminal. Why shouldn't my tools look nice?

Lume uses Bubble Tea for its TUI and supports 8 color themes out of the box:

modern (default) — Neon cyberpunk vibes
retro — Matrix terminal green
amber — Vintage CRT warmth
ocean — Deep sea blue
dracula, solarized, monokai, highcontrast

Press t to cycle through them instantly.

Diagnose Mode for Automation

Sometimes you just want a quick report without the interactive UI — maybe for CI/CD, or a daily cron job:

lume -diagnose

This gives you a terminal report of disk usage and reclaimable space, no interaction required.

How the Safety Mechanism Works

I want to emphasize this because it's the whole reason Lume exists. When you delete something:

Delete request
  ├─ Tier 1: osascript → Finder moves to Trash     ← Native macOS
  ├─ Tier 2: os.Rename → ~/.Trash/                 ← Same filesystem
  ├─ Tier 3: Copy to ~/.Trash/ → remove source     ← Cross filesystem
  └─ All tiers fail? → ERROR. File untouched.
                        ↑
                We NEVER fall back to rm.

Three tiers of safety. And if all three somehow fail, we report an error and leave your file alone. There's no "force delete" button. There's no hidden preference to bypass Trash.

Duplicate Detection That Doesn't Lie

Lume uses a 3-stage SHA-256 pipeline to find actual duplicates (not just files with the same name):

100,000 files
  → Stage 1: Group by size              [instant]         → 5,000
  → Stage 2: Quick hash (16KB samples)  [parallel]        → 200
  → Stage 3: Full SHA-256               [parallel]        → 50 true duplicates

100GB scanned in ~10 seconds on Apple Silicon. Zero false positives.

Get Started

One binary, zero dependencies, no sudo required:

curl -fsSL https://raw.githubusercontent.com/Tyooughtul/lume/main/install.sh | bash

lume              # Interactive TUI
lume -diagnose    # Quick report

Or grab a release from GitHub.

Why Not Just Use CleanMyMac?

Feature	Lume	CleanMyMac
Price	Free, MIT licensed	$35+/year
Deletion method	Moves to Trash (undoable)	`rm` (permanent)
Scan targets	55+ (developer-focused)	~10-20
Duplicate detection	SHA-256, 3-stage	Single-pass
Source code	Open	Closed

The Bottom Line

Disk cleaners shouldn't make you anxious. You shouldn't have to triple-check what you're about to delete, or maintain a manual backup "just in case" the cleaner makes a mistake.

Lume treats your files with respect. If you remove something by accident, it's in Trash. Go get it back.

If Lume saves you from one "oh no" moment, I've done my job.

Star Lume on GitHub →

Have you had a close call with a cleaning tool? Horror stories welcome in the comments.