The problem with flexibility
AI agents are useful because they're flexible. Give one a vague task and it will figure out an approach. Give it constraints and it will usually respect them. Usually.
That "usually" is the whole problem.
You can give an agent a checklist, a set of constraints, a detailed procedure. It will often follow them. But it will also improvise, skip steps, take shortcuts, or misinterpret your intent. Not maliciously — flexibility is the feature. An agent that rigidly followed every instruction character-by-character wouldn't be useful. But an agent that sometimes follows instructions isn't reliable either.
The math makes this concrete. A 95%-accurate agent on a 20-step task succeeds only 36% of the time. At 90% per step, you're at 12%. At 85%, 4%. This isn't a bug to be fixed. It's a structural property of how these systems work. Even on simple, verifiable format instructions like "write exactly 3 paragraphs," no model surpasses 80% accuracy — and performance drops up to 62% when prompts are rephrased with slight variations.
This is where the human comes in. Not to do the work — the agent handles that. The human exists because someone has to know the domain well enough to catch when the agent drifts and pull it back.
Organizations are investing heavily in AI tooling. 92% of executives plan to increase AI spending. But only 28% plan to invest in upskilling the people using these tools — even though Gartner says 80% of engineers will need to upskill through 2027. That's optimizing the wrong side of the equation.
The bottleneck isn't AI capability. It's human capability. Here are seven habits that close the gap.
Observing
1. Know what right looks like
You can't catch an agent drifting if you don't know the destination.
A 2023 Harvard/BCG study tested 758 consultants using GPT-4. On tasks inside AI's capability frontier, they completed 12% more work, 25% faster, at 40% higher quality. On tasks outside that frontier, AI users performed worse than those working without AI. They trusted the output without recognizing it was wrong.
Ethan Mollick calls this the "jagged frontier" — AI is excellent at some tasks and terrible at others, and the boundary is irregular and unintuitive. The only way to navigate it is domain expertise. You have to know the work well enough to evaluate whether the output is correct, not just whether it looks correct.
For leaders, the question isn't "are our people using AI?" It's "do our people know the work well enough to judge AI's output?"
2. Stay in the loop — detect when you've fallen out
Agents produce confident, fluent output. It reads well. It looks right. It's easy to stop checking.
This is a well-studied problem. In 1983, Lisanne Bainbridge published "Ironies of Automation" — arguing that the most automated systems require the most investment in operator training, not the least. When automation handles the routine work, operators lose the practice and situational awareness needed to intervene when it fails.
Parasuraman and Manzey extended this in 2010, finding that higher automation reliability paradoxically increases complacency. The better a system works most of the time, the worse humans become at catching the cases where it fails. A system that's right 95% of the time is harder to oversee than one that's right 70% of the time, because the 95% system trains you to stop looking.
The habit is metacognitive. Regularly ask yourself: "Did I actually verify that, or did I just accept it?" If you can't remember the last time you caught the agent making a mistake, you've probably stopped checking.
Intervening
3. Interrupt early
When the agent is heading the wrong direction, stop it. Don't wait for it to finish a long chain of work before correcting course. The longer it runs unchecked, the more you have to undo.
Aviation learned this the hard way. After a series of fatal accidents caused by hierarchical cockpit culture — where junior officers didn't speak up about problems the captain was causing — the industry developed Crew Resource Management. The core principle: anyone who sees a problem has the responsibility to flag it immediately. Waiting is not deference. Waiting is risk.
NASA later extended CRM to cover human-automation teams, asking: how do you ensure the human actually listens when the automation flags an issue? The same question applies in reverse. When you see the agent going wrong, the instinct is to let it finish — it feels inefficient or rude to interrupt. Override that instinct. Early correction is cheap. Late correction is expensive.
4. Ask, don't assume
When an agent does something wrong, the natural response is to write more detailed instructions. Add more constraints. Be more specific.
This usually doesn't work. The problem often isn't ambiguity in your instructions — it's that the agent interpreted them differently than you intended. More words don't fix a misalignment in understanding.
Instead, ask the agent to explain its reasoning. "Why did you do X instead of Y?" Often the answer reveals a misunderstanding you can address directly. Better yet, teach the agent to ask you for clarification before guessing. Configure your system prompts to encourage the agent to flag uncertainty rather than plowing through it.
The best collaborations have two-way uncertainty signaling. You flag when the output looks wrong. The agent flags when the instructions are ambiguous. Neither side guesses silently.
5. Reinforce the boundaries
When an agent skips a step or ignores a constraint, don't just fix the output. Restate the boundary explicitly.
Agents don't learn from silent corrections within a session the way you might expect. If you quietly fix a mistake without mentioning it, the agent has no signal that something went wrong. It will make the same mistake again. If you want a procedure followed, you need to actively enforce it — every time, within the conversation context.
Dario Amodei frames this well: powerful AI is "not humans out of the loop" but "humans with access to unlimited genius labor" operating within constraints that humans define and enforce. The defining and enforcing part is the job. The agent provides the labor. You provide the standards.
Systematizing
6. Graduate to scripts
If you're repeatedly asking an agent to do the same transformation — reformatting data, running the same checks, generating the same boilerplate — stop. Have the agent write a script instead.
You get the determinism and reproducibility of code with the flexibility of the agent that produced it. The agent was useful for figuring out the solution. Once it's figured out, lock it down. Scripts don't skip steps. Scripts don't improvise. Scripts don't need oversight.
Keep agents for the parts that require judgment — novel problems, ambiguous inputs, tasks where flexibility is actually the point. Use scripts for everything else. Know when to graduate from ad-hoc to formalized.
7. Build the feedback loop
These habits aren't one-time setup. They're an ongoing practice.
Effective teams build lightweight processes around their AI usage:
- Review where agents drifted. After a task, note what went wrong and why. Was it a missing constraint? A domain knowledge gap? An ambiguous instruction?
- Share patterns that worked. If someone finds a system prompt or workflow that reliably produces good results, make it available to the team.
- Update instructions based on what you learn. Your system prompts and procedures should evolve as you learn where the agents fail.
The human in the loop improves over time, same as the tools. But only if you treat AI collaboration as a skill to develop, not a tool to deploy and forget.
The seven habits at a glance
- Know what right looks like — Domain expertise is the prerequisite. You can't catch drift you can't recognize.
- Stay in the loop — Monitor actively. If you can't remember the last time you caught a mistake, you've stopped checking.
- Interrupt early — Don't wait for the agent to finish going the wrong direction. Early correction is cheap.
- Ask, don't assume — When something goes wrong, ask the agent why before rewriting instructions.
- Reinforce the boundaries — Silent fixes teach nothing. Restate constraints explicitly every time.
- Graduate to scripts — Once you've solved a problem with an agent, lock it down in code.
- Build the feedback loop — Treat AI collaboration as a skill. Review, share, and iterate.
The real bottleneck
46% of executives cite talent skill gaps as the main reason for slow AI tool adoption. Not the technology. Not the cost. The people.
The seven habits aren't about controlling the agent. They're about being good enough at your job to know when the agent isn't good enough at it. Observe the output. Intervene when it drifts. Systematize what works.
The best AI collaborators aren't the ones who write the best prompts. They're the ones who know the work.