Slop grenades are a boundary problem

First, using AI became a “baseline expectation.” Now colleagues are making each other’s lives worse by lobbing “slop grenades.”

That is not a contradiction. It is two parts of the same story: we’re figuring out where the new boundary lies between knowledge workers and their ~~tools~~ LLMs and AI agents.

When you ask people to use AI for everything (and change your performance expectations to match), they try to use it for… well, everything. Some time later, you discover which parts of the overall system no longer work.

The phrase comes from Shopify’s CEO in September 2026. He is the same person who made AI use a baseline expectation at the company in April 2025. Plenty of companies are now living through both halves of that story.

The old social contract broke

Before LLMs, communication between humans was mostly recognizable as communication between humans.

Someone wrote the Slack message. Someone wrote the email. Someone wrote the code, the pull request description, and the review comment. The quality varied wildly, of course, but the recipient could make a few reasonable assumptions about the sender’s relationship to the artifact.

They had probably read it. They had probably thought about it. They were willing to put it right beside their name. That is no longer a safe assumption.

An LLM can write all of those artifacts, and it can produce far more of them than the person directing it could have produced alone. When the sender passes along the result without really engaging with it, the work has not disappeared. It has moved to the recipient.

The sender saved ten minutes. Five recipients each spend ten minutes figuring out what the thing means.

That is the slop grenade.

Of course we tried it everywhere

It is tempting to treat slop as evidence that the enthusiasm for AI went too far. First AI was mandatory; now AI output is making everyone’s work harder. Gotcha.

But this looks more like a normal consequence of figuring out a genuinely new technology.

If LLMs can write emails, code, specifications, summaries, and review comments, we should try using them for emails, code, specifications, summaries, and review comments. Some of those experiments will work. Others will expose that the workflow around the artifact depended on a social contract we did not know we had.

With apologies to David Foster Wallace’s “This is Water.”

We are not just learning what LLMs can produce. We are learning where human attention was doing invisible work.

The problem is not simply that the output is “slop.” The problem is that we have not yet agreed on where the tool’s work ends, where the human’s responsibility begins, and who should consume what comes out.

Same channels, different economics

Right now, all of it flows through the same channels.

An AI-generated Slack message appears next to a message someone sat down and wrote. Agent-generated code lands in a pull request shaped for human-written code. A generated review comment asks a human to investigate something another human may never have investigated themselves.

Everything looks familiar, but the economics underneath it have completely changed.

No wonder the boundary between human work and agent work feels warped.

A human should not be the quality gate

If an agent produces a bad pull request, a quality gate should catch it. But that quality gate should not have to be a human reading thousands of lines of generated code.

If an LLM needs to send a large amount of information, perhaps another LLM should receive, filter, and verify it before a human sees anything.

Not always. Human communication still matters, and hiding every interaction behind agents would create its own absurdities. But we need to decide intentionally where humans collaborate, where agents coordinate, and where an agent’s output crosses from one world into the other.

“Use AI” is not enough of an operating model. Neither is “don’t send slop.”

Let agents be agents

This is one reason I am so excited about collaborative cloud coding agents and agents that work directly inside communication tools like Slack and Teams.

In those environments, the agent becomes an identifiable actor in the work. It is not pretending to be a human-written pull request description or borrowing someone’s identity to send an email. It participates in the conversation as a separate entity. Then the question changes.

Instead of asking whether someone threw a slop grenade, we can ask whether the agent did good work. Did it understand the task? Did it involve the right people? Did it run the right checks? Did it respond well? Does it need better tools, instructions, or boundaries?

That is a much more useful problem.

We will still have agents that work well and agents that work badly. But at least we will know who—or what—we are interacting with.

The path out of slop is not less AI. It is a clearer boundary between human work and agent work.