There is a comfortable story we tell ourselves about automation. You set the machine loose, it does the work, and you reclaim your calendar. The more you automate, the less you do. That story is wrong.
Dan Shipper, CEO of Lex, laid out the counterintuitive reality in Lenny’s Newsletter: as AI automation increases, the amount of human work required to manage and review that automation also increases. More automation does not mean less human involvement. It means more of it, just in a different form. The bottleneck shifts from doing the work to checking the work.
This is not a bug. It is the shape of a well-designed growth system. The teams that get this right do not try to eliminate the human. They design a loop where the human sits at exactly the right decision points, reviewing, overriding, and escalating. Here is how to build that loop without turning it into a bottleneck.
The Automation Trap
The trap is seductive because it works, at first. You plug in an AI cold outreach tool, it drafts a batch of emails, and you send them. The first few rounds look fine. Then the context errors start.
The Lenny’s Newsletter community roundup on AI cold outreach tools collected exactly this pattern. Contributors reported that the most effective setups all included a human review step before sending. Without it, the tools produced personalization failures that made the outreach feel generic or, worse, actively wrong. A prospect’s name might be correct, but the context around it, the industry reference, the recent company news, would be subtly off in a way that killed the response rate.
This is the automation trap. The tool handles volume, but it cannot handle the judgment call. It cannot know whether the tone is right for this specific buyer, whether the reference it pulled from a company blog post is actually the right one to lead with, or whether the email it just drafted accidentally contradicts something the sales team said in a previous conversation. Those are human decisions.
Three Signals That You Need a Human Checkpoint
Not every step needs a human. The trick is knowing which ones do. Real operator stories from growth teams point to three clear signals.
Signal one: when personalization fails. The cold outreach example is the cleanest case. If your automated system is generating content that references a specific person, company, or context, and you cannot afford to get that reference wrong, you need a human before send. The cost of a context error in an outbound email is not just the lost lead. It is the reputational damage that follows when the recipient forwards the email to their network with a note about how lazy your outreach is.
Signal two: when code changes risk production. The engineer behind Claude Cowork described using Claude to automate repetitive coding tasks in Lenny’s Newsletter, but emphasized that every piece of generated code required human review before deployment. The AI could draft the function, but it could not verify that the function did not introduce a subtle regression or security hole. The human check was not optional. It was the step that kept the system safe.
Signal three: when overnight tasks produce ambiguous results. Lenny’s Newsletter covered a Codex feature that runs automated tasks overnight, processing data and generating outputs while the team sleeps. The system works, but it requires a human to review the results and make final decisions in the morning. The automation handles the grunt work. The human handles the judgment. The overnight batch pattern is powerful precisely because it separates the two cleanly: the machine does the volume work, the human does the decision work, and they never have to wait on each other.
The bottleneck shifts from doing the work to checking the work. That is not a bug. It is the shape of a well-designed growth system.
Designing the Loop
The human-in-the-loop pattern is not new. It is a well-established concept in machine learning operations, or MLOps. Google’s MLOps documentation describes it as a standard design pattern: a human reviews model outputs before they are used in production. The same pattern applies directly to growth stacks.
The loop has three components. Review, override, escalation.
Review. Before any automated output goes live, it passes through a human. This is the checkpoint for context errors, tone mismatches, and outright mistakes. The review step does not need to be slow. It can be a quick scan of a generated email, a glance at a code diff, or a morning check of overnight results. The key is that it exists and that it happens before the output reaches a customer.
Override. Some outputs will be wrong in ways the system cannot fix. The human needs the ability to override the automation entirely, to write a custom response, to reject a batch, to pause a campaign. This is not a failure of the system. It is the system working as designed. The override is the escape hatch that keeps the automation from doing damage when it encounters an edge case it was not trained on.
Escalation. Some outputs will be ambiguous. The system produces a result that might be right, but the reviewer is not sure. The escalation step routes that output to someone with more context or authority to make the call. This is the safety net for the hardest cases.
Many payments companies leaned on manual review before automating. The human check was not a bottleneck. It was the thing that let them automate safely. They reviewed every edge case manually, learned from it, and then automated the patterns they could trust. The loop was not a cost. It was the engine that made the automation possible.
Measuring Success: Throughput vs. Quality
The obvious objection is that human review slows things down. It does, in the narrow sense that a machine can process more tasks per hour than a human can review. But that framing misses the point.
The tradeoff is not throughput versus quality. It is throughput of correct outputs versus throughput of outputs that need to be fixed later. A system that sends a thousand emails with a ten percent context error rate generates a hundred fixes, a hundred apologies, and a hundred lost leads. A system that sends five hundred reviewed emails with a one percent error rate generates five fixes and five hundred leads that actually work.
The paradox Shipper identified applies here too. The more you automate, the more human work you need to manage the automation. But that human work is not waste. It is the quality gate that makes the automation valuable. Without it, the automation produces volume without effect.
Practical Patterns from Teams Doing It Right
Teams using AI agents and CLI tools for growth tasks have developed patterns that embed human oversight without slowing velocity.
The overnight batch with morning review. This is the Codex pattern. Let the automation run overnight, processing data and generating outputs. The human reviews the results first thing in the morning, makes the final decisions, and the system proceeds. The automation never waits on the human. The human never waits on the automation. The two operate in parallel, separated by time.
The code generation loop with pre-deployment checks. This is the Claude Cowork pattern. The AI generates code. The human reviews it before deployment. The review is fast because the AI handles the boilerplate and the human focuses on the logic and safety. The loop is tight enough that velocity stays high, but the quality gate is real.
The cold outreach queue with human send approval. This is the community pattern from the Lenny’s Newsletter roundup. The AI drafts the emails. The human approves each batch before it goes out. The human check catches the context errors and personalization failures that the AI cannot see. The send rate drops slightly, but the response rate climbs.
These patterns share a common structure. The automation handles the volume. The human handles the judgment. The two are separated in time or in scope so that neither becomes a bottleneck for the other.
The honest summary is this. You cannot automate your way out of human judgment. You can only automate the work that surrounds it. The teams that build the best growth stacks understand that the human is not a limitation to be worked around. The human is the point. The automation is just the tool that lets them spend their attention where it matters.