Skip to content
Stop Approving Every AI Action: Build a 3-Phase Human-in-the-Loop Workflow

Stop Approving Every AI Action: Build a 3-Phase Human-in-the-Loop Workflow

Anthropic's data reveals 93% approval rates cause 'approval fatigue'; this article presents a three-phase human-in-the-loop workflow—structured input, plan-level steering, and output review—that shifts human effort from micromanaging actions to strategic guidance, demonstrated via a payment module refactoring case study showing 25 vs 90 minutes.

ThinkInAI Community
ThinkInAI Community
ThinkInAI Community

What Human-in-the-Loop Really Means

Anthropic analyzed roughly 400,000 Claude Code sessions between October 2025 and April 2026. A single pattern appeared in almost every session: humans make planning decisions, AI makes execution decisions. The more domain expertise a person brings to a session, the more work each AI instruction completes and the higher the success rate. This is not a safety concept; it is a workflow architecture that can be split into three phases.

Input covers everything before AI starts working: your task description, constraints, context, and examples. People almost always under-invest here, then spend twice as long correcting output that went off track from the first prompt.

Steering happens while AI works: monitoring its direction, intervening when it drifts, reviewing plans instead of approving every single action. Anthropic's data shows experienced users auto-approve individual actions at twice the rate of new users, yet they interrupt the agent far more often during execution. They watch the trajectory, not the steps.

Output Review is the final gate: what you accept, what you reject, and the criteria you use to judge. It sounds obvious, yet almost everyone skips it and ships the first version they receive.

Every effective human-in-the-loop workflow is some combination of these three.

文章图片 1
文章图片 1

Start with Output Review

This is the simplest entry point and the fastest win. At the Code with Claude event, Anthropic shipped a feature called Outcomes. It adds a scoring loop: you define what "good enough" looks like, and the system evaluates its own output against those criteria before delivery. The model itself did not change. The same AI ran the same prompt with only an added scoring checkpoint.

Result: slide generation quality rose 10.1%, document generation quality rose 8.4%.

That number matters because it proves a significant chunk of bad AI output is not a model problem—it's an evaluation problem. No one checked whether the output was actually good enough before handing it over.

You don't need a platform feature to do this. The practice is simpler than the tool. Before any AI task, write down in concrete language what a good result looks like. Then, before using the output, compare it against your own standard. One deliberate review against preset criteria catches most of the errors that make AI output feel unreliable.

Don't rebuild your whole workflow on day one. Pick one repetitive AI task you already do—emails, drafts, summaries, code—and add a review checkpoint. That alone puts you closer to true human-in-the-loop than almost anyone else.

文章图片 2
文章图片 2

Add the Steering Layer

Output review catches problems after they happen. Steering stops them before they happen.

The old steering mode was per-action approval: AI proposes an action, you approve or reject, then AI proposes the next. Anthropic's 93% approval rate proves this method fails at scale. When a session has hundreds of actions, people stop reading what they're approving. Ilya Kabanov's analysis of Anthropic's own research describes the reality bluntly: what actually happens is incident response, not oversight.

Anthropic's alternative is a mode they call Plan Mode. Instead of asking you to approve each action, the AI shows you the entire sequence of actions it intends to take up front. You review, edit, and approve the whole plan before anything executes. You can still intervene during execution, but the cognitive load shifts from "evaluate 200 micro-decisions" to "review one plan and watch for drift."

This pattern transfers directly to any AI workflow, regardless of tool. Give the AI a structured task. Have it outline its approach before executing. Review that outline, then let it run and check back at natural breakpoints instead of hovering over every step.

In daily practice this takes the form of a steering document: a CLAUDE.md file, a set of custom instructions, or a system prompt that encodes your standards, constraints, and recurring preferences. A well-maintained steering document replaces hundreds of ad-hoc corrections across sessions because the AI knows your rules before you start typing.

文章图片 3
文章图片 3

Build the Input Layer

This phase separates people who get reliable results from those who keep wrestling with AI tools.

People almost always start a session with a vague instruction, then spend 80% of their time correcting output. That's the loop running backward. Human effort lands at the end, spent on re-prompting and fixing output, when it belongs at the start.

Anthropic's session data shows the pattern directly: the more domain expertise a person brings, the more work each AI instruction completes. Expertise here doesn't mean technical skill—it means knowing what you want and being able to describe it precisely. A senior engineer who writes a clear task description with constraints and context gets far more done per prompt than someone who types "fix this bug" and waits.

文章图片 4
文章图片 4

The input layer is where you encode that precision: your task description, context files, reference examples, boundary conditions. The AI needs to understand not just what to do, but how you want it done and where the boundaries lie.

A reliable structure has three parts. First, state the goal in one sentence. Second, define constraints—what the output must include and must not include. Third, provide an example of a "good result." This triplet gives the AI enough structure to produce something usable on the first pass, which means your output review focuses on improvement rather than starting over.

Building the input layer feels like extra work up front—because it is. But it saves multiples of that time in every subsequent session. People who make the one-time investment in the input layer start improving immediately. People who never build it start from zero every time they open a new chat.

Running the Full Loop

Here's what all three phases look like working together on a single task.

A developer needs to refactor a payment processing module. Without a human-in-the-loop design, the task starts with a prompt like "refactor the payment module" and ends with a 500-line diff that changes the public API, breaks two tests, and uses a naming convention different from the rest of the codebase. The developer spends an hour manually fixing the output. Net time saved: near zero.

With all three phases in place, the same task runs differently.

Input is structured before AI touches anything: "Refactor the payment processing module. Do not change the public API. Maintain backward compatibility with v2 endpoints. Match the naming conventions in /src/auth. Here is the current test suite for context." That takes about five minutes to write and eliminates 80% of the corrections that would have happened later.

Steering happens when the AI outlines its refactoring plan before executing. It proposes extracting three helper functions, consolidating error handling, and rewriting the retry logic. The developer spots that the AI plans to merge two functions that must stay separate for rate-limiting reasons. One redirect, ten seconds. The AI revises the plan and executes.

Output Review takes about ten minutes. The developer checks the diff against the original constraints. Public API unchanged. Tests pass. Naming conventions match. Accept.

The first approach (no loop) took 90 minutes. The second approach (with loop) took roughly 25 minutes. The difference wasn't that the AI got smarter between the two attempts—it was that the human invested time at the front of the process instead of the back.

This pattern holds for any AI-assisted task, not just code: writing, research, analysis, design. Front-load your input, steer the plan, review output against explicit criteria. The loop is the same regardless of domain.

Watch Your Work Transform

When all three phases are truly running, the shape of your daily AI interaction changes completely.

You stop typing vague requests and spending an hour fixing output. You start writing structured inputs, spend five minutes, and get a usable result on the first or second try. Your steering documents accumulate knowledge across sessions, so the AI gets better at your specific work over time even without any model upgrade.

Your to-do list stops being a list of things to produce and becomes a list of things to review. The center of gravity of a workday shifts from production to direction. You don't write the first draft yourself; you define what a good draft looks like, review what comes back, and refine the standard for next time.

This doesn't mean you stop thinking—it means your thinking moves to a different altitude. You stop choosing individual words and start choosing direction. You stop debugging line by line and start reviewing architecture, catching errors before they cascade.

The parts that genuinely need a human—judgment, taste, domain knowledge, strategic decisions—get more of your attention because the parts that don't need a human have been handled.

People who build this workflow once will keep iterating on it for years. People who keep feeding one-shot prompts and hoping for the best will keep zeroing out every session.

The old human-in-the-loop asked you to approve every action. It never scaled, and the data proves it.

The new human-in-the-loop asks you to invest in three things: your input, your steering, and your review standards. Build them once, and the AI handles more in every session while you handle less. Not because you're being replaced, but because you're finally working at the altitude where humans actually make a difference.

Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

AI engineeringAI workflowAnthropichuman-in-the-loopClaude Codeplan-modeapproval fatigueoutput review
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.