When AI Is More "Skilled" Than You: Where Do You Draw the Line on Control?
During the Q&A for my Geekbang course AI Coding in Practice Bootcamp, a student posed this question:
Now that AI can outperform humans on isolated problems — appearing more “skilled” than we are — how do we, as developers, decide: is this a module that should keep being auto-generated by AI, or is it a “critical decision point” that humans must control? Is there an operable boundary?
This is an extremely profound question that lands squarely on the pain point of deploying AI today. I mulled it over, distilled it from my own practice and my fuzzy heuristics, and after answering, felt it was worth expanding into an essay to share. Here it is.
To do good work, first sharpen your tools. Yet with a sharp tool in hand, one must know when to advance and when to retreat, what to take and what to leave. The adept user is like Cook Ding carving an ox — the blade glides with effortless grace; the clumsy one apes the walk of Handan and loses his own gait. — Adapted from The Analects and Zhuangzi
In the AI era, we hold an unprecedented “sharp tool.” It writes in three seconds the regex that would have taken you half an hour. It instantly produces the multi-table SQL join you spent ages digging through docs to assemble. You hit Tab and perfect code appears on screen. You run it, and it works.
The experience is intoxicating — and extremely dangerous. We are living through a rare period in the history of technology: a “capability inversion.” In concrete techniques — syntax conversion, boilerplate generation, data cleaning — AI often appears more “skilled” than mid-level and even senior engineers. It’s like hiring a hustle-king intern: writes code faster than you, looks up docs more accurately than you, debugs more ruthlessly than you.
But there’s a fatal bug here: AI has astonishing tactical ability and almost no strategic intuition. It can write a flawless recursive function without knowing why this particular business scenario calls for iteration. It can generate smooth, polished customer replies without sensing that one sentence might trigger a PR disaster. It’s that legendary “god-tier move” — the code flies, but the business logic is completely off the rails.
As developers and technical decision-makers, the ultimate question is no longer “what can AI do,” but: for this module, when do I let go and let AI generate, and when do I grip the wheel with both hands?
You can’t go on gut feeling, and you certainly can’t just lie down and hand it all to AI. We need a quantifiable risk assessment framework — one with a checklist and red lines, just like code review.
The R-C-V Model: Drawing Red Lines for AI
Before you “fully delegate” a module to AI, I suggest subjecting it to an R-C-V interrogation. The three dimensions are Risk (asymmetry of consequences), Context (closure of the problem space), and Verification (cost of checking the answer).
Risk Asymmetry: If It Goes Wrong, Do We Crash and Burn?
The core question: If AI screws up, is the consequence linear or exponential?
Linear consequences (low stakes): The AI-generated unit test misses a case, or the generated CSS is slightly off. The cost is “redo it” — a few minutes of your time. This is reversible; worst case you roll back and regenerate. It’s a typo in a line of code, not a car wreck.
Exponential consequences (high stakes): The AI-generated DELETE statement is missing a WHERE clause. Or a medical triage bot gives the wrong dosage advice. The consequence is lost data, a lawsuit, or a life. This is irreversible — one wrong move and the ship goes down, not just the car. In these scenarios, no matter how “god-tier” the AI is, you don’t let it run free.
The principle: reversibility is the precondition for automation. Even if AI is 99.99% accurate, if the remaining 0.01% can blow up the system, control must stay in human hands. This isn’t involution — it’s survival.
Context Closure: Is There Enough Information?
The core question: Is all the information needed to solve this problem inside the prompt window?
Closed loop: “Translate this Java code into Kotlin.” A perfectly closed task: logic begins in code and ends in code, dependent on nothing external. It’s the tool-drone’s job, with crisp boundaries and a clear goal — AI is the GOAT here.
Open loop: “Optimize our pricing strategy based on recent customer complaints.” That’s not a computation; it involves market sentiment, competitor moves, long-term company strategy — most of that lives outside the AI’s context window. It’s like being asked to make a strategic decision while you’re slacking off: not enough information, so AI just coasts too.
The principle: AI is locally optimal; humans are globally optimal. When a task requires thinking “outside the current window,” humans must not leave the room. That’s not giving up — it’s the last line of defense before you lose it.
Verification Cost vs. Generation Cost: Is Checking Harder Than Writing?
The core question: Is checking AI’s answer harder than doing it myself?
This is the classic P vs. NP question, and the ultimate test of any “cut costs, boost efficiency” pitch.
Hard to generate, easy to verify: “Generate a complex React component skeleton.” Writing it by hand is tedious, but a human can glance at the rendered UI and know if it’s right. Ideal for AI: it grinds, you accept delivery — winning without lifting a finger.
Easy to generate, hard to verify: “Generate a high-strength cryptographic algorithm implementation.” AI produces it in seconds — but does it contain a subtle mathematical flaw? Verifying that takes deep expertise, and may be more work than writing it yourself. Here AI’s fancy moves can turn into smooth talk, and you won’t even notice you can’t hold it together.
The principle: if the cost of verifying AI’s output (including hidden risk costs) exceeds the cost of writing it from scratch, then the “automation” is a false premise. That’s not involution — it’s technical debt in another form.
The Decision Matrix: Your Action Guide
Based on R-C-V, we can draw a 2x2 decision matrix that sorts everyday development tasks into four quadrants:
🟢 Copilot Zone (Low Risk + Closed Context): AI’s Comfort Zone
Typical cases: regular expressions, SQL query optimization, boilerplate code, JSON formatting, log-cleaning scripts.
Strategy: Default AI.
Mindset: Here AI is your outsourced contractor, your worker drone. You only care about the result (pass/fail); don’t agonize over the process. This is where the productivity gains are greatest and where AI wins without lifting a finger. Let AI grind; you slack off and sign off.
🟡 Gatekeeper Zone (High Risk + Closed Context): AI’s Beta-Test Zone
Typical cases: core payment logic, concurrency locking mechanisms, a self-driving object-detection algorithm, first-pass medical imaging screening.
Strategy: AI suggests, human approves.
Mindset: Here AI is your super-intern, but it must go through a canary release. It proposes, and a mandatory Human-in-the-loop (HITL) stage follows. For example: AI writes the code, but it must pass a rigorous human code review before merging. The human’s role is goalkeeper — and the last line of defense for taking the blame. AI can pull god-tier moves; you can’t lie down. You review 996-style.
🔵 Inspiration Zone (Low Risk + Open Context): AI’s Public-Beta Zone
Typical cases: product brainstorming, UI design sketches, first drafts of copy, edge-case divergence for test cases.
Strategy: Co-creation.
Mindset: Here AI is your muse, your inspiration drone. Its value is divergence and breaking mental ruts, not accuracy. The human’s role is curator, picking the gold out of a pile of gold and garbage. AI can run free; you can coast while filtering — but don’t expect brilliance. Most of the output will be emotional-damage tier.
🔴 No-Go Zone (High Risk + Open Context): AI’s No-Fly Zone
Typical cases: deciding layoff lists, ethical decisions, corporate strategic pivots, complex legal and compliance judgments.
Strategy: Human owned.
Mindset: Here AI can only be a search engine or a data-organizing tool — never part of the reasoning and decision chain. Because what’s needed here isn’t intelligence; it’s accountability and values. AI has no bank balance and no freedom of person; it cannot pay for mistakes and cannot take the blame. In these scenarios, you’re the hustle king and AI lies down — it’s just a tool.
The Developer’s Checklist: The Final Death-Sentence Review
When you’re staring at a specific module, unsure whether to hand it to AI, run these four questions as the final review. If any answer is NO, take back control — don’t let AI crash the car.
Explainability: If the system fails, can I immediately reproduce the execution path from the logs? Or is it a total black box? A black box is like slacking off without knowing what you’re doing — when it crashes, you won’t even know whom to blame.
Edge cases: Can I (or the AI) enumerate all the important boundary conditions and encode them in test cases? If the real world is too chaotic to enumerate, a human must be present to handle the unknown. In 996 mode there are always “surprises”; AI can’t handle surprises — you lose it and then patch it by hand.
Statelessness: Is this operation free of side effects? Read operations suit AI; write, update, and delete operations demand extreme caution. A worker drone can slack off reading docs, but must not slack off editing code — one slip and it’s a wreck.
Liability: If this module gets the company sued or causes enormous losses, am I willing to stand up and say “that was my call” and own the consequences? If you daren’t take the blame, don’t let AI run free — review 996-style and make sure the ship doesn’t sink.
From Craftsman to Architect: Reinventing Value
AI won’t replace developers, but it is redefining what a “developer” is.
In the past, our value lay in handiness — the ability to quickly write code free of syntax errors. The worker drone proved worth through 996 and won by grinding.
In the future, our value lies in judgment — precisely identifying where AI can accelerate and where humans must go deep. The architect no longer grinds on tool-drone work; instead they curate the whole project, letting AI drones grind while they hold the last line of defense before things fall apart.
Don’t be fooled by AI’s “skill” at local techniques. Remember: AI gives you the highest-probability answer; what we need is the logically correct one. AI’s god-tier move may be a slick trick — or the prelude to a crash.
Next time you’re about to hit Tab and accept AI’s completion, take a second to ask: am I in the Copilot Zone, or have I wandered into the No-Go Zone?
That one second of thought is the difference between being ruled by tools and ruling them. It’s also the difference between a worker drone and an architect.
