Deslopifying
Date:
"deslopifying" (verb): the (painful) process of making AI output your own.
"Deslopifying" sounds negative, and it should, because it is primarily a grueling, draining activity.
It comes down to receiving a sub-par piece of work (slop) to review that requires you to dive in deeper and provide more detailed instructions than you would have liked to.
And while you could have easily found yourself in a similar situation before AI, while reviewing somebody else's pull request, the big difference is that you could have chosen not to go deep into it and instead send the work back with general guidelines on what needs to be better, knowing that it's ultimately somebody else's responsibility to find a way to get there.
However, when using generative AI to produce code/content as part of your own work, there is nobody else: the responsibility is yours, not AI's. And there is only so far AI can improve its output without you going deep and providing detailed instructions (or giving up on your standards).
A good rule of thumb for recognizing if you just went through deslopifying is if you asked yourself at some point:
Would I have been better off if I just did this manually?
Better delegation is the key
🔗I am not saying all AI output is bad. Not all AI output requires deslopifying.
You might delegate a bigger piece of work to AI and receive output good enough for what you need at the moment, requiring minimal or no fixing.
Or you might give it such well-defined and scoped pieces of work that you can plug them right into your bigger piece of work while being confident about the quality being maintained.
Using AI successfully is really a problem of delegation, and deslopifying happens when you delegate too much. And then assuming control back, steering the output back on the right track, becomes grueling work.
We shouldn't normalize it
🔗Unless the time saved is significant, deslopifying subjectively feels much worse than doing it on your own, because the whole activity is deconstructive (analyzing someone else's output) instead of constructive (being creative, in the flow, building concepts). It is draining instead of energizing.
Therefore, I believe we should not accept deslopifying as a normal part of our daily work, but look at it as a negative work pattern that is to be recognized and minimized.
I am actively trying to recognize when I get into deslopifying, pull myself out as fast as I can, and adjust my approach to avoid it happening further.
Reviewing AI-generated code feels like deslopifying?
Means I let it generate too much with too little guidance/guardrails. I need to take a step back, plan better, implement higher-level constructs first, more manually, let AI fill in smaller pieces. Maybe put stronger rules/boundaries in place. Maybe not let it generate whole files this time, but define functions and data flow myself and let AI fill in the implementation details.
I prefer being a bit slower in the short term, if it means I will come out of it with more energy, more understanding, and in control.