The High-Level Thinking Lie
Why AI Is Already Doing the Job You Think You Were Promoted To
Today’s Code & Capital is brought to you by… AI Founders Club
AI builders aren’t waiting around, they’re building. If you’re trying to turn an AI idea into something real (and revenue-generating), this is the tribe to be around.
AI Founders Club is a private community of builders (code and no-code) learning how to launch, scale, and monetize AI products fast. You get playbooks, toolkits, actual examples from real startups, and 7-day risk-free access to test it all out.
You also get exclusive discounts on AI tools (Composio alone saves you $274), plus a behind-the-scenes look at what’s actually working.
If you're serious about building in AI, stop lurking and start shipping.
Hi friends 👋,
These days, most of my work starts with a prompt.
Architecture plans. PRDs. UI flows. Homepage copy. Feature breakdowns. Tech stack choices. API ideas. Project planning. Before I touch anything, I ask the AI.
I don’t write everything from scratch.
I delegate the first draft, then shift into review mode.
Sometimes I compare approaches.
Other times, I just want to see how the AI would solve it. But what I really spend time on is asking better follow-up questions.
And I believe that this is where the real leverage is.
My prompts land because they draw on more than code: behavioral science, psychology, design, product management, marketing, sales.
That mix helps me ask questions that guide the AI in ways that are hard to replicate.
Tim Ferriss once said, “If you want to improve your life, improve the questions you ask yourself.”
What stuck with me was this: Better questions, better life.
And in the AI era, I’d update that to:
Better experience → better questions → better output.
That’s what this post is about.
AI can suggest what to do, how to do it, and when to do it. But if you stop asking questions, you give up the one thing that still makes your work valuable.
Let’s get into it.
“AI won’t take your job, but someone using AI will.”
Sounds profound, until you realize AI never needed you in the first place.
In 2024, this phrase became tech’s favorite security blanket.
But as Sangeet Paul Choudary pointed out, the real issue is a framing error.
The question was never who will take your job. It’s how the job itself is being redefined.
Everyone clung to the same hopeful story:
Let AI handle the grunt work, and developers will move up the ladder.
They’ll stop writing boilerplate and start designing systems, making strategic decisions, and doing “high-level” thinking.
If only that were true.
Instead, something weirder happened.
Ask any developer (myself included) using Cursor, Claude Code, or Windsurf daily:
We're not just using AI to autocomplete lines of code.
We're outsourcing entire sequences of thought.
Architecture decisions? Delegated.
Implementation plans? Delegated.
Pull request descriptions? Delegated.
Product requirements? Delegated… and edited after the fact.
AI doesn’t just assist the thinking anymore. In most cases, it thinks first.
We review. We tweak. We approve.
Developers are being told they’re climbing up the value chain.
In reality, they’re often just picking from a menu AI already drafted.
But here’s the nuance:
That menu only works because we understand what’s being served.
The only reason these tools can help plan architectures, refactor systems, or draft PRDs is because real developers shaped the prompt, steered the loop, and caught the hallucinations.
That’s the paradox:
AI feels like it’s doing all the thinking, but without someone steering, you don’t get your vision, you get its version.
As the tools get better, it becomes easier to forget how much thinking still rides on us not to write the code, but to understand what should never be written.
The Real Shift: From Typing to Choosing
You’re Not the Architect. You Asked for the Blueprint, Then Approved it.
In the old software hierarchy, writing engineering design docs and scoping architecture was a senior dev’s rite of passage.
Everyone else wrote what they were told.
Then came AI.
The promise was clear: it would handle the grunt work, and everyone (even junior devs) would finally “think like staff engineers.”
But that’s not what happened.
Instead of elevating everyone, companies just stopped hiring juniors.
AI didn’t raise the floor.
It flattened the org chart and let senior devs do more with fewer people.
It delivered but just not how anyone imagined.
AI now handles the what, the how, and the when.
You're left choosing the why, but most of the time, AI already picked that too.
This flips the whole mental model.
Developers aren’t doing more high-level work.
They’re curating high-level decisions generated by an agent that’s seen more repos, written more PRDs, and absorbed more Stack Overflow than any human ever could.
You're not climbing the value chain.
You're reviewing output from something that’s already done the strategic thinking.
This isn’t augmentation.
It’s delegation with judgment as your last remaining edge.
AI Doesn’t Help You Code. It Codes Without You, Then Asks for Feedback
Let’s set the record straight:
People don’t use Cursor, Windsurf, or Claude just for autocomplete.
They use them to build entire features.
This is how developers write software today.
They delegate.
And when you delegate that much, something changes:
You go from creator to reviewer.
Code review used to be one phase of the workflow.
Now? It is the workflow.
But now AI is not just making you 10x more productive, it’s also generating 10x the amount of code you’re used to review.
And your job is to keep up.
At first, you review everything carefully. Line-by-line. Like a good dev should.
Then you get Code Review fatigue.
You get lazy, and you start trusting the output more.
You trust it just enough. You test the UI. It seems fine.
You skip the fourth function it wrote. You assume it’s solid.
Congrats: you’ve entered the lazy loop.
Welcome to the Cleanup Crew
There’s a new job on Upwork: AI janitor.
These folks don’t write apps from scratch.
They show up with a mop and fix what GPT confidently hallucinated into prod.
Broken auth flows. Nonsensical schemas. Tailwind components with emotional damage.
You name it, they’ve seen it.
And they’re in demand.
Because while AI can build your MVP in a weekend, that MVP often arrives functionally broken but semantically beautiful.
Like IKEA furniture assembled by an alien who speaks JavaScript.
Founders figured this out pretty fast.
And here’s where the trap snaps shut.
You think you're doing high-level work delegating code, reviewing outputs, moving fast.
But you’re really just cleaning up messes you didn’t see coming.
You’ve become the janitor for a system that speaks with confidence, even when it’s completely wrong.
Code Review Fatigue Is Real. So Are AI Bugs You Didn’t Catch.
The problem isn’t just speed. It’s overconfidence.
You want to believe the AI got it right. Because if it didn’t, you’ve got 200 lines of code you didn’t write and barely understand.
So you skim. You trust. You test the UI. Looks fine. You ship.
And just like that, you’ve entered the trap.
It feels like you’re supervising the system. But really, you’re just approving what it gave you.
You’re not leading. You’re reacting.
This is why test-driven development (TDD) still matters.
Not because we’re trying to be good engineers but because we’re flooded.
AI generates so much code, so fast, that testing isn’t a best practice anymore, it’s self-preservation.
But here’s the real problem: AI also writes the tests now.
So you end up trusting the same system to double-check its own logic.
That’s like asking the magician if the trick was real.
You’re still prompting, guiding, choosing but the loop gets tighter.
AI writes the feature. AI writes the test. You skim. You ship.
It feels like high-level thinking. But when both the code and the validation come from the same source, you're not reviewing. You're approving.
And that’s when things slip through.
Remember the Calculator?
I wrote about this in a previous post, but it’s worth repeating.
In 1972, Texas Instruments released the first handheld calculator.
Engineers stopped manually crunching trig and started thinking at a higher level.
The pitch was familiar:
“Let’s remove the grunt work so humans can do more important thinking.”
And it worked. Well…sort of.
Calculators didn’t just help engineers. They also started to redefined what engineering meant.
The tool didn’t just save time. It changed expectations.
We’re watching the same thing happen again.
But this time, the tool isn’t removing arithmetic it’s removing abstraction.
And it doesn’t just automate the low-level stuff.
AI handles planning, scoping, implementation, and now, validation.
The more you rely on it, the less you practice thinking from first principles.
And the more it starts to shape your decisions before you even realize what you're delegating.
Enter AI Test Driven Development (AI TDD)
The way I think about this kind of testing is simple:
TDD That Doesn’t Take AI’s Word for It
This is exactly why I started building Checkmate.
Checkmate is one of the first AI-powered TDD tool designed to question AI’s output before it breaks production.
It understands natural language (No code needed)
It writes and runs AI specs for your code.
It validates every AI-generated change.
It lives in your repo.
It’s built for the Cursor-era workflow:
prompt → generate → review → trust (too much).
And it exists because if AI is doing the “thinking,” then we need something else doing the second-guessing.
Checkmate is that second guess.
I’m not saying developers are obsolete.
Far from it.
But the narrative that we’ll all graduate into “strategic thinking” while AI handles the rest is misleading.
If anything, AI forces us to sharpen our judgment, not abandon it.
Tools like Checkmate help protect the thinking layer that still matters.
Because in the end, AI is only as smart as the questions we ask and the limits or spec we enforce.
Which brings us to the bigger question: where do developers fit on the new ladder?
The High-Level Trap
So how did we get here?
AI promised to remove the grunt work so developers could level up.
But in reality, the more we delegate, the less we engage.
And the higher the abstraction, the easier it is to lose the thread entirely.
At first, AI felt like a productivity boost.
Now it feels like a role shift.
Let’s talk about that infamous developer ladder.
Junior devs used to start with simple tasks: CRUD operations, bug fixes, documentation.
Mid-level engineers handled core modules and integrations.
Seniors made architectural decisions, wrote specs, and mentored teams.
But today?
CRUD is written by AI.
Docs are generated by AI.
Architecture is scaffolded by AI and just reviewed by humans.
So… where exactly are we climbing?
We're not.
The ladder hasn’t been removed.
It’s been compressed by a hydraulic press called LLMs.
“You’ll Just Focus on Strategy” Sounds Familiar
Every wave of automation tells the same story:
“Don’t worry, you’ll just move to higher-value work.”
We’ve heard this before:
Assembly lines got robots. Humans got supervisory roles.
Spreadsheets automated math. Analysts became “strategic partners.”
Photoshop got easier. Designers became art directors… supposedly.
But here’s what actually happens:
Low-level work gets automated.
High-level work becomes the new baseline.
The bar rises, the headcount doesn’t.
In software, it means:
You’re not spending more time “thinking big.”
You’re spending more time reviewing AI outputs, validating code you didn’t write, and jumping between tasks faster than ever.
High‑level thinking was supposed to be the reward.
AI took it.
You’re left proofreading its ideas.
That doesn’t mean there’s no path forward. It just looks nothing like the brochure.
Forget climbing the value chain. That ladder’s gone.
Now it’s about spotting bad logic dressed up in perfect syntax.
Developers who thrive aren’t the fastest typers. They’re the best editors.
The clearest thinkers. The ones who know when the AI is bluffing.
They don’t just prompt. They probe.
They don’t just review. They interrogate.
This isn’t high-level thinking the way we imagined.
It’s critical thinking dressed as code review. And most people miss the difference.
AI Took the Code. What’s Left Is Judgment.
People say: “AI gives you leverage.”"
Here’s the uncomfortable version:
AI does the thinking. You’re just there to catch the mistakes.
And this is where the illusion of progress becomes dangerous.
The job of the modern developer isn’t to think from scratch.
It’s to think after the machine.
And if you don’t understand what it did ( or why ) it won’t just write the code.
It’ll quietly write you out of the loop.
I don’t think AI killed the developer.
I think it changed what being a good developer looks like.
It’s no longer about who types the fastest or memorizes the most syntax.
It’s about who can review, question, and guide machines that speak with confidence but still need constraint.
We don’t need to fear the shift. We need better tools, sharper judgment, and the nerve to step off the old ladder.
