AI-Assisted Development Is Awful — But Also Amazing

Let’s start with the awful.

Not Reddit discourse awful. Actual, lived, 20-minutes-wasted awful.

The AI Spiral

I was implementing URL-driven modal state.

Example:

/project/12345?tab=settings&modal=add-member&type=project&entityId=123ABC

The goal was simple: close the modal, keep tab, remove everything else.

Instead of thinking for two minutes, I prompted.

The AI generated something like this:

function clearModalParams() {
const url = new URL(window.location.href);
const params = url.searchParams;

const keysToRemove = ["modal", "type", "entityId"];

keysToRemove.forEach((key) => {
  if (params.has(key)) {
    params.set(key, ""); // ❌ clears value, doesn't remove param
  }
});

window.history.replaceState({}, "", url.toString());
}

Result:

?tab=settings&modal=&type=&entityId=

The params still existed. State was still weird.

I told it the issue. It regenerated. Still wrong. We entered the loop.

You know the loop.

After 20-30 minutes of wasted time, I got fed up, pumped the breaks and took over.

I thought for a minute:

Just preserve tab and rebuild the URL.

Two minutes. Solved.

The problem wasn’t AI. The problem was that I stopped thinking.

Now The Amazing

I’m building Buggr — a learning platform where users:

• Pull repos
• Get injected bugs
• Solve them (without AI)
• Get scored

I wanted users to fork one of our public repos directly inside the platform.

Before prompting, I wrote a plan.

Prompt Plan (9:29–9:33)

• Add section: “Or — pull one of our repos”
• Fetch public repos from our GitHub account
• Display list
• Show repo details on select
• Add Fork button
• Fork to connected account (OAuth already done)
• Confirm success

Four minutes of thinking.

Started coding at 9:40. Finished at 10:10.

Thirty minutes total.

Here’s the commit trail:

I had limited experience with the GitHub API.

Pre-AI? This was several hours.

With structure? Thirty minutes.

That’s not hype. That’s leverage.

The Other Amazing

In a large Next.js app at work, one tab in a ProjectPage had accumulated dense sorting logic.

Nothing complex. Just mentally heavy. The kind of refactor that takes 1–2 focused hours.

Cursor handled it in minutes. Correctly. First pass.

Was it perfect architecture? No. But real systems aren’t perfect.

Show me a perfectly structured production app and I’ll show you a liar.

AI is very good at:

• Local refactors
• Pattern cleanup
• Deterministic transformations

That’s where it shines.

The Difference Between Slop and Leverage

It’s not “use AI” vs “don’t use AI.”

It’s structure.

Anyone using code-gen tools knows:

The bigger the codebase, the bigger the prompt, the bigger the chance of slop.

Large context increases drift. Implicit coupling gets hallucinated. Confidence stays high.

So you need a system.

The Stop the Slop System

1. Write a Prompt Plan

If you can’t outline the task in bullets, you’re not ready to prompt. Clarity reduces drift.

2. Commit Early and Often

Small steps. Small commits. Clear reasoning trail. The fork feature wasn’t one AI blob. It was controlled increments.

3. Be Ready to Intervene

AI will get stuck.

It will regenerate the same wrong idea in slightly different forms. It will enter error loops.

If you don’t understand the code, you can’t redirect it.

Error loops are killers.

AI doesn’t remove the need to understand code. It increases it.

If you can’t step in, define the boundary, and correct the direction — you’re not building. You’re following.

The Truth

AI for development is:

• Awful when you disengage
• Incredible when structured
• Dangerous when unbounded
• Powerful when constrained

This isn’t about abandoning AI. And it’s not about handing it the wheel.

It’s about building a system around it.

I wrote up our informal internal guide for developers on exactly this — how we use AI in a task-based, structured way without drifting into slop:

👉 Stop the Slop: An Internal Guide for Devs

The skill isn’t “using AI.”

It’s thinking first. Constraining scope. Committing deliberately. And intervening early.

That’s how you stop the slop.