Own the Output: The Thin Line Between 10x Output and Workslop

I help engineers and leaders at every level make AI a native part of how they work. Lately I see a shift: the problem of people not adopting AI is fading. A new problem is taking its place.

Engineers now use AI at every step. They generate, ship, and move to the next task, and everything gets faster: the code, the responses, the things marked done. But as organizations lean into that speed, they slowly lose their grip on what is actually being produced.

The new problem is not AI generating your content. It is engineers handing AI the task when they should be handing it their decisions. The goal all along was to use AI to build output as good as what you would have written yourself.

Hand AI the decisions, not the task.

Your name is on everything

The engineers around me are strong: they solve hard problems, their docs convince, their talks land. They were good long before AI, and with AI they build more than ever. But across the board I see the same thing: how AI output gets handled is becoming its own area of concern. Managing it is a skill that has to be learned like any other, and not many treat it that way.

At a company, you are accountable for everything you produce, not just the code you write. The status updates you give your leaders. The documents you write. The review comments you leave. The analysis you deliver. All of it carries your name, whether AI touched it or not.

This holds at every scale. PwC learned it publicly when analysts flagged one of its published reports as almost certainly AI-generated, with made-up footnotes. The firm's name was on the cover.

The skim is not a review

Losing control happens on a slippery slope, and it starts small. Hand the task to AI. Get the full output. Read it at a high level. It makes sense. Send it. More than a third of workers say they rarely or only sometimes review AI output before using it.

The skim feels like review, but it is not. You gave up three things without noticing: whether the output fits who it is for, the flow of thought, and how the thinking is presented. Using AI does not mean handing over the task. But that is exactly what skim-and-send does, and strong engineers are sliding into it in the name of adopting AI.

Why do even strong engineers fall for this? Because AI reliably produces good enough output that looks great: polished structure, confident tone, more than you asked for. For strong engineers, this is a trap: stop paying attention and good enough quietly becomes the level they ship at. Sending it gives you an immediate hit of completion, and the extra volume creates a quiet assumption that because it did more, the person on the other end will value it more. Neither holds. Looking great is not the same as being right for them, and more is not better when nobody decided what the more is for.

How it shows up

A big refactoring is coming, and the task is to scan the code and analyze the impact. Before AI, the engineer would decide the output form first and work backwards from it: pick the search patterns, break down the results, bucket them, derive the insights. Every step is a decision they own. Now the AI gets a one-line ask and the engineer forwards its summary, without knowing what was covered, what was skipped, or whether the process was sound.

A project needs a technical overview, and the engineer who led it is the one giving it, as a document or a presentation. They used to settle the audience, the questions to answer, the understanding people should leave with, and the flow that gets them there, all without thinking about it, because that is their craft, plus everything they picked up from stakeholders along the way in direct conversations, Zoom calls, email threads, and coffee chats. Now the AI gets "write a technical overview of X" from the person holding the most context, and generic defaults decide everything their judgment used to decide. Even the diagrams and slides that used to be their signature give way to the model's defaults: good enough, and indistinguishable from every other AI-generated deck their audience sat through that month.

A long, polished status update lands in leadership inboxes, and it sounds like nobody in particular. The leader asked for that update with specific concerns in mind, concerns the engineer knows from months of conversations and never put in the prompt. They used to answer exactly those in a few tight paragraphs, in a voice their leaders have read for years. Now the update says more and lands worse: the voice is gone, the leader gets slop they did not ask for, and the thing they actually cared about moves slower. People know your voice. When your output stops sounding like you, they notice, and what they conclude is not flattering.

A new component needs an approach. The old answer was a path the engineer could defend at every fork. The new answer is "the agent suggested it." There is no decision left to defend.

Your audience is going AI-blind

There is a second cost, and it is growing. Rafal Cymerys wrote about becoming AI-blind. After enough exposure to low-effort AI content, his brain now skips anything that carries the signs. The wordiness. The big claims for small points. The familiar phrasing.

Research says this reflex is spreading, and it lands on the sender. Stanford and BetterUp researchers coined "workslop": AI content that looks like good work but does not move the task forward. Forty percent of US desk workers received some in the past month, and the part that should worry you is what it did to the senders. Recipients rated them as less capable and less trustworthy, and a third became less willing to work with them again.

The hiring market previews the end state. AI auto-appliers are flooding job openings with generated applications, and recruiters describe giving cold applications less and less of their attention in response. When unowned output takes over a channel, receivers start giving up on the channel itself.

So bad AI output does something worse than fail: it stops getting read, and credibility erodes quietly, one skipped document at a time.

Awareness of AI slop in your own output is the new grammar correctness. A generation ago, a document full of typos marked the sender as careless, so everyone learned to proofread. Slop is the new typo, and your audience runs the check automatically.

Underneath the erosion, a sorting is happening. Your output is quietly deciding which kind of worker your audience takes you for: an operator who runs prompts and forwards whatever comes out, or someone who brings context, judgment, and craft the model lacks and uses AI to produce more of it at the same bar. Operators are interchangeable with anyone holding the same subscription. The industry has already coined a name for them: don't be a meat proxy, the person who pipes AI output to colleagues without reading, understanding, or validating it. That verdict gets written whether you participate in it or not.

Know both sides of the partnership

None of this points to using less AI. The fix starts with a clear view of what LLMs are actually good at, which comes down to two jobs. They level knowledge: an LLM instantly raises the average quality of almost any thinking task. And they execute: give one a computer and a well-defined task, and it runs that task forever without getting tired.

Put your own skill next to that, and AI's role changes with the task:

• Where you are great, use AI to challenge you rather than do the work. It becomes the sharpest reviewer you ever had, and tooling like the grill me skill, which interviews you relentlessly about your own plan, already exists for exactly this.
• Where you are decent, let it lift the output past your average, and pay attention so it lifts you too.
• Where you are new, add learning to the loop: Anthropic's engineers run an eli5 skill that turns unfamiliar code into a visual explainer before they touch it.

All three take effort. That is the point.

Make the subconscious explicit

That is AI's side of the partnership. Your side is the craft, and most of it runs without thinking. Before AI, you never wrote a document without an audience in mind. You never ran an analysis without knowing what the output should look like. These decisions were invisible because they were automatic.

AI does not have your instincts. Leave the decisions unstated and it fills them with something generic. So say them out loud, and review becomes simple: compare what came back against what you intended. No more skimming for vibes.

This awareness decides whether AI raises your bar or quietly lowers it.

The practices

No prompting tricks here. This is how you stay the author while AI does the heavy lifting.

Keep your methods, and prompt to their detail. Your way of working is the asset. Brief AI like you would brief someone shadowing you: the output form, the steps, the order, what good looks like at each stage. Vague prompts get the model's defaults. Detailed prompts get your process, faster.

Build the output in your head first. Know what you expect before you read what AI made. In detail: the method, the outcome, the approach, the artifacts. Review is comparing the two. If you cannot picture the output beforehand, you are not reviewing; you are rubber-stamping.

Back every decision. If someone questions any part of the output, the answer is yours. "That's what it generated" is not an answer. When things go wrong, you cannot throw AI under the bus.

Never ship with an "AI did this" disclaimer. "The AI wrote that part and I'm not sure" means you shipped something you don't stand behind. AI is not getting a paycheck. You are, for a reason. Maybe future models earn a different deal. Today they have not.

Hold the bar at what you would build yourself, given days. Not "plausible." The output you would have made by hand, with time you no longer need to spend. AI compresses the timeline, not the standard. And with the time you save, raise the bar organically, each piece a little better than the last.

This is management 101

Now read the list again. Define the outcome. Communicate the method. Delegate the execution. Review against intent. Own the result. If you have led a team, you have done all of this before. Treating AI like a vending machine skips the discipline you would never skip with a person. And it shows.

Why review at all?

The devil's advocate question: why review at all? Let AI do everything. Let leaders review with their own AI. Keep moving. This argument hides two assumptions.

First, it assumes your prompt captured everything you needed. Both the needs you stated and the ones you did not know you had. But the whole point of subconscious craft is that you cannot fully state it. If your prompt were a complete spec of your intent, review would be redundant. It never is.

Second, it assumes AI is like a compiler. Write if true do x else do y and you never worry the compiler will do x when it is false. The contract is absolute, so trust is free. AI offers no contract. Even at the frontier, I have had Claude's latest model apologize for ignoring my instructions after doing the exact opposite. Not subtle drift, the exact opposite.

With a compiler, verification would be paranoia. With AI, verification is the job.

That one difference changes the entire dynamic.

This is a blessing in disguise. If AI offered a compiler's contract, the skim-and-send crowd would be right. It does not, and the gap between what you meant and what the model produced is where your judgment lives. Be glad it exists.

Fast and still in control

The pushback: "if I review everything that deeply, I lose the speed AI gave me." Not if you spend the review where it matters. This works on two tracks: your own output, and others' output with AI blended in.

Ration review by the cost of being wrong. The architecture decision gets your full attention. AI-generated test scaffolding gets a lighter pass. Two questions place any piece of work: what does it cost if it is wrong, and how hard is it to take back once it is out? Uniform shallow review everywhere is the worst split possible.

Depth is a ladder, not a switch:

• Level one: structure. The sections, the flow, the shape of the argument.
• Level two: intent. Does it answer the questions your audience will ask, using the method you chose?
• Level three: spot checks. Sample a few claims and numbers and trace them back to the source.
• Level four: line by line. Every claim verified, every number recomputed, the voice made yours.
• Level five: adversarial. Ask what is missing, and make AI attack its own output.

The bottom-left quadrant earns level one. The amber quadrant earns all five.

Build skills that absorb your review. Turn recurring tasks into reusable skills or prompt assets. Review heavily at first, and feed every gap you catch back into the skill. Over time, the skill becomes an extract of your subconscious, and review load drops because the bar moved upstream into generation. Tooling exists for this too: skills like unlazy turn it into acceptance gates with runnable checks, so "done" means verified, not claimed.

Review like Google Maps. Zoom out first and judge the structure alone. If it does not convince you, reject and regenerate. Do not start reading line by line from the top. That polishes sentences inside a structure that was wrong from the start.

The part that keeps you employed

Why do humans still have jobs while agents improve every quarter? Because humans know how to talk to other humans. And because we decide what to build, how, why, and when, not from conditional logic or a clear spec. We decide with tribal knowledge built over years in a company. Conversations with others who carry the same. Coffee-side discussions. Debates. Colleagues' opinions. The figures who inspire us. What we deeply care about. None of that fits in a prompt.

Now look at those patterns again. The abandoned analysis. The undefined audience. The voice that stopped sounding like you. The approach justified by "the agent suggested it." Each one hands over exactly the thing that makes you hard to replace.

Great builders in the age of AI do not win by generating the most output. They win by putting their name on more work than before, while every piece still deserves the name. The engineers who master this will be the ones others are told to learn from. The ones who do not will discover the slippery slope was never about slop in their documents. It was about what is left when the documents no longer need them.