The "Slopification" Of Software Engineering

I'm deeply concerned that, with each passing day, there is a major push to convince software engineers that GenAI agents can create better software than they can.

Even more concerning is that an incredible number of software engineers are buying into this narrative - a narrative that is not only dangerous but also false.

While it is true that these agents can often generate code faster than we can, the quality of that code is rarely good. In my own experience, I frequently end up spending more time reviewing, correcting, or - in many cases - completely rewriting the code myself.

The agents often fail to produce work that meets my standards for quality and readability; in fact, they sometimes cannot even solve the problems I assign them. And the problems I give them are extremely simple - the kind of tasks I would assign to an intern during their first few weeks on the job.

When Simple Tasks Go Wrong

These agents have deleted unit tests I asked them to address, and they have even introduced bugs into the code just to force a unit test to pass - all when I had simply asked them to finish implementing a mock object to be passed as a function parameter.

On another occasion, I asked an agent to dynamically load a JavaScript file in Node.js. This should have required only a single line of code using the import() function; instead, it ended up being implemented in about 20 lines, utilizing a native Node.js module that few people are even aware of (node:vm).

The tasks I'm describing are well-defined, extremely simple, and require only one or, at most, a couple of lines of code.

Another case - as recent as today - involved issues with some generic types that an agent had implemented, because this is one of the few ways I actually use GenAI agents: to generate types or resolve type-related problems in my TypeScript code.

The Agent had added generic types to several classes and some of their methods, but these generics were causing various issues. I asked the agent to fix the problem, and once again, its solution was to generate two assertion functions and add several more lines of code - 34 new lines in total.

Naturally, I found this unacceptable. I rejected the changes and analyzed the issue myself, which ultimately led me to remove all the generic types the agent had added to those classes and methods - as they were completely unnecessary. The type-related problem disappeared, and the code is now shorter, more readable, and easier to maintain.

More Than Code Generation

Another major concern of mine is that software engineering is being reduced to mere code generation. Code generation was never the goal; it is, at best, an optional, secondary byproduct of the software engineering process.

On several occasions, following a meeting to analyze a problem - prior to beginning the development of a feature or product - we concluded that building anything at all was unnecessary; simply implementing a process was enough to satisfy the requirement. Yet, now that producing code has become so fast and inexpensive, it seems acceptable to discard all our past experience in software engineering.

Cognitive Degradation and Lost Fundamentals

Worst of all is the cognitive degradation caused by the constant, excessive use of GenAI tools - a phenomenon many seem unaware of, or worse, simply do not care about.

I've heard firsthand from a technical interviewer evaluating candidates for a Senior Software Engineer position: the vast majority of applicants couldn't solve algorithmic problems without GenAI. They had become so dependent on these tools that they were no longer capable of working with the fundamentals on their own:

• programming languages
• unit testing frameworks
• data structures
• memory optimization
• runtime efficiency

Furthermore, they struggled to answer questions regarding the time complexity of the algorithms they were asked to implement (let alone optimize them).

If someone were to argue that such knowledge is irrelevant in the age of GenAI agents, I would be even more concerned. After all, how on earth are they supposed to verify whether a solution provided by a GenAI agent is optimal?, by simply telling it, "Don't make any mistakes, implement the most efficient option"?

I don't know whether to laugh or cry; perhaps a nervous laugh - a sad, nervous laugh - is the most appropriate response.

The Cost of AI Slop

Or perhaps the future for people like me lies in initiatives like this: https://odra.dev/slopfix/.

This team offers the following:

• One week.
• Three senior engineers.
• $10,000.
• We commit to a reduction target upfront, and you pay in proportion to how much of that target we actually hit.
• Promised 50% but only delivered 20%? That's 40% of the target, so you pay $4,000.
• Hit the target or beat it, you pay full price.

For what it's worth, some reports estimate the cost of "AI slop" in software development at $1.17 trillion - yes, trillion with a capital T.