Yevhen Bobrov

We need a name for performative agent parallelization I propose: “slop theater”

I’m getting to the point with one of the projects I work on where the complexity of AI slop is becoming a real issue. While I can still happily prompt the agent to add x feature and it will do so and it will likely work perfectly, the code is just getting too complex and fragmented. Agents love to copy and paste and keeping patterns DRY is a real challenge. The agent will start diverging all those copy and pastes until you’ve got loads of similar but slightly different blocks of logic. Again it all still works and solves the problem I’m after. But I just can’t get any kind of consistency anymore, the code is a mess and I just don’t have a handle on it. I want a clean unified architecture but agents just code with tunnel vision. The project is now too big and complex for an agent to fully reason with and too big and complex for me to reason with. The only real solution is a complete rewrite. Maybe this is the way things will go. Code will just become disposable. I don’t really want to care about the code and to be honest I don’t but I do care about consistency and maintainability and the AI slop is hurting those very things I do care about. I know some will say “I’m holding it wrong”, use x,y,z skill, tool whatever and already use tools and anti slop skills, plans, docs, etc but the outcome is the same. Vibe coding something into existence is truly magical. But turning it into a mature product with months of iterations is painful. I can’t even hand code this thing because I don’t understand the code anymore and I’m too lazy to try and code myself because I’m addicted to AI. So what’s the solution, either start again and accept that’s just the way we have to roll, or just carry on fighting the slop and accept each new feature will take longer to implement than the last. I’m tired. I’m addicted.

codex: ``` $​skill-installer frontend-skill $​frontend-skill Create a website introducing yourself. ```

My brain is fried this week from trying to solve some of the complexity LLMs are generating to little success. At this moment in time it definitely feels like writing software is _harder_ in many situations. More taxing mentally.

i can't speak for david. what i see is this: if you let agents build or extend a codebase with only minor or no supervision, you get unmaintainable garbage, because the agent makes terrible decisions that compound, both big and small. those decisions make it hard for both you and the agent to keep modifying the code base, until eventually it's unrecoverable. why does the agent make bad decisions? i can't tell for sure, but my gut tells me that training data can currently not capture the holistic thinking needed to design and evolve complex systems. that's one part of the problem. related to that, and oversimplified: agents output the "mean quality" of the code they saw during training. most of that code is very bad. specifically tests, which humans are terrible at writing at. another part of the problem is that specification via prompt is not precise enough, so the agent has to fill in the blanks, giving it enough rope to hang itself. the more detailed your spec gets, so the agent gets constrained and less likely to produce crap, the closer you are to handwriting the code yourself, as that's the most detailed version of the spec that can exist. so then you gain nothing. back to prompt spec it is, which means the agent fills in blanks, which means we get suboptimal or truely bad results. using agents can still be a net productivity boost (see other posts in my thread), but it is not easy to come up with consistent workflows that produce both production quality maintainable code while retaining the speed advantages agents give you.

I was a 10x engineer. Now I'm useless.