Contents
Mindset (Part 2 of 2): Two Principles, One Reminder, and the Complete Spiral
In the previous three articles we built out the five stages of the workflow mindset: chaining your workflow, designing Context handoffs, the diagnosis-and-refinement cycle plus platform thinking, evolving to an Agent Team, and expanding your scope while discovering where human value lives.
But I mentioned at the end of the last article: if you start building right now, there are two pitfalls that are almost impossible to avoid. These aren’t pitfalls from carelessness — they come from fundamental limitations of AI itself. The good news is that there are clear countermeasures. Let’s cover those first, then close with one overarching reminder.
Principle 1: Use a Different Agent to Cross-Audit
The first pitfall: Agents have a fundamental limitation — they have a very hard time spotting their own blind spots.
This isn’t just intuition — academic research has confirmed it. A systematic survey published by MIT Press in TACL [2] states directly: no major study has shown that LLMs can successfully self-correct through self-prompting under fair conditions. In some cases, self-correction actually degrades performance.
Why? Nova Spivack’s analysis [19] explains the root cause: LLM-generated content has a high degree of internal self-consistency. The model uses the same reasoning process to generate content, and then uses that same reasoning process to check it — so errors look perfectly reasonable to itself. Tests on GPT-4o showed an accuracy rate of 49.71%, but an overconfidence rate of 39.25%.
The CRITIC framework paper on arXiv [3] proposes a solution: effective self-correction requires external feedback — search engines, code executors, knowledge bases — rather than relying purely on internal evaluation.
This is why cross-auditing isn’t a “nice-to-have.” It’s a “must-have.”
(You might be thinking: didn’t the last article say “don’t create new Agents carelessly”? That’s right — but review and audit are exactly the kinds of scenarios that legitimately require an independent Context. The point isn’t “you can’t use multiple Agents” — it’s “every Agent needs a clear reason to exist.”)
Method 1: Have the Agent write up its design, then hand it to a different Agent for review. Because the new Agent has a clean Context, it doesn’t inherit the previous Agent’s assumptions and biases.
Method 2: Use a Multi-Agent setup where an Agent invokes a Skill that calls another Agent to do the audit. Architecturally, this is the Subagent isolation from article 5 — you’re isolating not just Tokens, but thinking patterns.
This principle applies at every stage of the workflow:
- Stage 1: A newly chained workflow — have another Agent check for logical gaps
- Stage 3:
/insightsuggestions — have another Agent evaluate whether they’re sound - Stage 4: Agent Team design — have an independent Agent do an architecture review
Principle 2: Verify Timeliness — Ask the AI to Search for Current Information
The second pitfall: solutions proposed by an Agent are typically based on the most common practices in its training data, not the most current ones.
This isn’t a guess — a paper from ICSE 2025 (a top software engineering conference) [4] verified this directly: researchers evaluated 7 mainstream LLMs, and every single model used deprecated APIs in code completion tasks. The root cause is that training data contains both old and new APIs simultaneously, so models “memorize” outdated usage. Another arXiv study [8] is even more specific — a developer reported wasting an entire day because GPT-4 recommended a feature that had been removed two versions prior.
Worse still, some practices become outdated without the AI ever telling you. It doesn’t know that a library has been deprecated, that an API has a new version, or that a design pattern has been abandoned by the community.
The fix: proactively ask the AI to search the web for current information to validate its own proposals.
After an Agent completes a design document, you can instruct it like this:
“Search for the methods and technologies used in this design document, and confirm whether there are newer alternatives or known issues. Flag anything that appears to be outdated.”
You’ll be surprised to find that when prompted to search, the Agent becomes noticeably more careful. It will proactively use current data to re-examine its own design, and will sometimes even reverse its original recommendations.
Lakera’s research [20] supports this approach: RAG (Retrieval-Augmented Generation) can reduce hallucination rates by 40–71%. What we’re describing here isn’t a traditional RAG pipeline, but the core mechanism is the same — introducing external information to correct the model’s internal biases.
This principle is essentially the same as cross-auditing — bringing in external information to break the closed-loop nature of the Context. Cross-auditing uses another Agent’s perspective; timeliness verification uses the latest data from the web.
One Reminder: Seven Articles Worth of Actionable Principles, Not Just Knowledge
The two principles above address specific pitfalls. But there’s one more thing to cover — not a countermeasure, but the foundation that runs through the entire mindset.
Those seven technical articles cover techniques, not mindset. They don’t have a direct relationship with “building a workflow.” But they provide a set of principles that AI can follow.
Here’s how to use them:
- Skim through them once to build a conceptual understanding
- Hand them to an AI so it can read them and use them as working principles
- Use those principles to guide the AI in building your workflow
You don’t need to fully understand every technical detail. But you do need to understand the concepts — Context flow, Token budgets, Progressive Disclosure, Subagent Return Contract. These concepts are your debugging tools.
When something goes wrong with an AI — response quality degrades, the workflow breaks, costs spiral out of control — you need these concepts to diagnose:
- Did the Context overflow? → Check Token budgets
- Did the handoff break? → Check the Subagent Return Contract
- Was the knowledge never loaded? → Check the JIT strategy
- Is the Agent too cluttered? → Check the tool count and Skill layering
Concepts let you diagnose problems; mindset lets you design processes. The two together form a complete way of working with AI.
An Honest Footnote: This Closed Loop Is Still Maturing
Before we close, I want to be honest about something.
The five-stage spiral described across these four articles is a direction, not a fully validated, mature methodology. A systematic literature review in Frontiers in Computer Science [9] puts it plainly: “Human-AI collaboration is not very collaborative yet” — most existing systems are still one-directional, and lack genuine iterative feedback loops.
Additionally, an arXiv paper on automating AI R&D [30] raises a warning: 20 out of 25 surveyed researchers believe that unconstrained automated iteration increases risk in safety-sensitive environments.
That said, I believe this limitation will be overcome in a relatively short timeframe — my expectation is 3 to 6 months.
The reason is simple: AI capabilities are evolving extremely fast. Six months ago, Agent Teams were still an experimental feature; now teams are using them in production. Six months ago, Skills were still a Claude Code-exclusive format; now other platforms are starting to adopt them. The infrastructure for iterative collaboration is maturing quickly.
But at this stage, what does that mean in practice?
It means you shouldn’t hold off on using the iterative loop just because it hasn’t fully matured — but you should build sufficient monitoring mechanisms while you use it:
- Bound the iteration scope — Don’t let AI iterate freely without boundaries. Every iteration loop needs a clear scope and exit condition
- Human-in-the-loop checkpoints — Set up human review at critical junctures, especially at cross-Agent handoffs and final outputs
- Health metrics — Design observable metrics so that if quality degrades, complexity inflates, or failure drift appears during iteration, a human can step in and correct course in time
- Fallback mechanisms — If automated iteration goes sideways, you need to be able to quickly revert to human-in-the-loop mode, not have the entire system come to a halt
Parseur’s 2026 analysis [26] supports this approach: human approval gates serve as quality control points, and human business judgment adds genuine value to automated decisions. The key question isn’t “can AI run the entire loop on its own” — it’s “have you designed good interfaces for human intervention.”
This isn’t a problem with iteration itself; it’s a monitoring problem. With good monitoring in place, you can use this closed loop safely even while the underlying AI collaboration infrastructure is still maturing.
The Complete Closed Loop
Put the five stages together, and what you get is a spiral:
┌─────────────────────────────────────────────────────────────┐
│ │
│ ① Chain the Workflow (A→B→C) │
│ ↓ ← Small steps, validate fast │
│ ② Design Context Handoffs │
│ ↓ ← Watch for Context blind spots │
│ ③ Diagnose → Refine → Classify (/insight loop) │
│ ↓ ← Iteration's double edge + │
│ platform thinking │
│ ④ Evolve to Agent Team │
│ ↓ ← Cost awareness: do you need it? │
│ ⑤ Expand → Discover New Human Work │
│ │ ← Simplicity first + │
│ │ watch for illusion of │
│ │ completeness │
│ └──→ New work returns to ① ──→ spiral upward │
│ │
│ Running through every stage: │
│ ✦ Cross-audit (different Agents review each other — │
│ academically confirmed as necessary) [2][3] │
│ ✦ Timeliness verification (search for current data — │
│ ICSE confirms the staleness risk) [4] │
│ ✦ Concepts as debugging tools (the 7 technical articles │
│ as a basis for judgment) │
│ │
│ Safety nets: │
│ ✦ Iteration ceiling (2 rounds general / 3-5 critical) [18]│
│ ✦ Human-in-the-loop checkpoints [26] │
│ ✦ Simplicity first: exhaust adjustments before adding │
│ a new Agent [31] │
│ ✦ Health metrics and fallback mechanisms │
│ │
└─────────────────────────────────────────────────────────────┘This spiral has no endpoint. With every turn, your workflow becomes more refined, your understanding of where human value lies grows clearer, and the range of what AI can handle expands.
And the most important thing throughout this entire process isn’t any single technical decision — it’s:
Are you willing to keep observing, diagnosing, and adjusting?
AI doesn’t improve on its own. Workflows don’t evolve on their own. You are the one driving this spiral forward.
Technique is the foundation; mindset is the direction. The foundation determines how high you can build; the direction determines where you go. The first seven articles gave you the foundation. These four gave you the direction.
Everything else is just getting started.
References
[2] Huang et al., “When Can LLMs Actually Correct Their Own Mistakes?” (MIT Press/TACL) https://direct.mit.edu/tacl/article/doi/10.1162/tacl_a_00713/125177
[3] “CRITIC: Tool-Interactive Critiquing” (arXiv) — effective self-correction requires external feedback https://arxiv.org/abs/2305.11738
[4] “LLMs Meet Library Evolution” (ICSE 2025) — all tested LLMs used deprecated APIs https://dl.acm.org/doi/10.1109/ICSE55347.2025.00245
[8] “Deprecated API Usage in LLM Code Completion” (arXiv) — knowledge cutoff leads to outdated recommendations https://arxiv.org/html/2406.09834v1
[9] “Human-AI Collaboration: Not Very Collaborative Yet” (Frontiers in Computer Science) https://www.frontiersin.org/journals/computer-science/articles/10.3389/fcomp.2024.1521066/full
[18] DEV Community, “Iterative Review-Fix Loops Formula” — mathematical analysis of iteration’s precision ceiling https://dev.to/yannick555/iterative-review-fix-loops-remove-llm-hallucinations-and-there-is-a-formula-for-it-4ee8
[19] Nova Spivack, “Why AI Can’t Catch Their Own Mistakes” — analysis of LLM internal self-consistency https://www.novaspivack.com/technology/ai-technology/why-ai-systems-cant-catch-their-own-mistakes-and-what-to-do-about-it
[20] Lakera, “LLM Hallucinations Guide 2026” — RAG reduces hallucination rates by 40–71% https://www.lakera.ai/blog/guide-to-hallucinations-in-large-language-models
[26] Parseur, “Future of Human-in-the-Loop AI 2026” — human approval gates as quality control https://parseur.com/blog/future-of-hitl-ai
[30] “AI Researchers on Automating AI R&D” (arXiv) — risks of unconstrained automated iteration https://arxiv.org/html/2603.03338v2
[31] Anthropic, “Building Effective Agents” (2024) — official guide: exhaust simple solutions first, add complexity only when necessary https://www.anthropic.com/research/building-effective-agents
Support This Series
If these articles have been helpful, consider buying me a coffee