How I Prevent AI Slop (Simple)

I've been using coding agents for about a year now, and I've experienced some bad side effects from the usage. The worst - lost love for the craft (still loved it, but much less). Recently, I've found a solution that works really well for me - making my coding sessions much more productive, high quality, and enjoyable.

The Bad Side Effects of Agentic Coding

Lost understanding of the codebase

Skimming git diff is not understanding the codebase. I was building whole apps with a very high view of the files structure, the tech stack used, the db schema. But I lost details. I just skimmed the git diffs without paying attention to details.

5 minute skim is not understanding the code.

Huge amounts of AI slop, slipping undetected

A hardcoded value is very damaging to a codebase. So is duplicate code. So is a bad test. And of course auth issues and other business logic problems.

When I used skills and CLAUDE.md rules to harness the slop, it just looked like it's working. But paying close attention to the details now, I know that slop slips - heavily, silently.

Lost enjoyment of the creative process of implementation details decisions

For the 4 years that I coded without agents, I was enjoying the process of making clean code decisions. Building software without code duplications, with generic methods and components, with thought given to each db table column. With clean structure of files, with evolving style. I enjoy this, and when I delegated these decisions to the agent, then I lost this enjoyment. Fortunately, the LLM is not good at such details.

Slop will Slip - and that's where experienced developers shine

LLM-generated code is unfit for serious applications without careful review by experienced eyes.

So when people say that the developer role is dead - they are either not experienced with LLM software development for serious apps, or they are trying to sell this idea.

Read: instruction prompt configs are not even close to eliminating slop. Greptile and other AI code review tools are also not even close to this. This is what I learned in the recent year using these failed techniques.

LLM is useful for boilerplate generation and some basic repetitions.

If you ship a feature without at least 3 review cycles, minimum, then you invite slop to the codebase.

The Solution

Review the git diffs, LINE by LINE, add relevant comment per slop line(s), send the comments to the LLM, iterate until slopless.

The LLM will create slop, 100% of the times. The developer job is to eliminate the slop, and guide the LLM boilerplate repetition machine carefully.

Warning: Don't expect this process to be fast like you're used to as a vibe coder, or as a git diff skimmer. You're going to find a lot of slop, and you're going to make lots of decisions. Creativity will flow again.

Critical warning: If you don't have a strong grounding in Clean Code principles, this won't work — start there.

IDE git diff tools won't do

Reading line by line is HARD, with the GUI IDE git diffs. Typing comments for a substantial amount of lines is exhausting.

I found a tool that makes it easy - https://github.com/agavra/tuicr

This tool allows you to do local code review for git diff, placing comment per line(s), and then copy a review text with these comments and filepaths+lines and paste to the LLM for fixes iteration.

Using this methodology, of reviewing every line of code the LLM generates, with the ease of creating code review comments, will make you skilled at slop elimination, as well as regain your codebase understanding, and reignite the flame of architectural creativity. This is the solution for LLM slop, and skill entropy.

My features ship slower but faster now. The code is reusable, generic, clean. The application is optimized, stable. I know exactly what happens in it. It's a night and day difference from the vibe coding / git diff skimming period, which shall never return. Skills are not effective enough.

My confidence in my architectural skills, and in the relevance of the developer profession, is back. Most importantly, I returned to my original endeavor, after too many months, of enjoying detailed, granular software production.

Unexpected conclusion: Juniors Are Superior to LLM Agents

LLM agents will ALWAYS slop, no matter how many times you review them and edit their skill and rule sets.

Code reviews for a junior human developer will make them not repeat the mistakes. Juniors will evolve into creative, clean coding beings, which will enrich the business and experience of the whole organism.

LLMs will forget. LLMs will try to please you and not generate substance and enrichment. You can never trust an LLM — frame it correctly: a boilerplate repetition machine.