How to Use AI Without Becoming Brain-Dead
Hey, it's been a while since i wrote the last article. In this article i'm going to talk about AI coding tools (Cursor, Claude, Copilot)—and the massive split happening right now between developers who are becoming 10x sharper with AI and developers whose brains are slowly turning into mush.
It's not an anti-AI rant. I use AI every single day. It's about how you hold the tool so you stay the architect instead of becoming a glorified copy-paste intern for a chatbot.
Let's look at the conventional trap people are falling into right now.
The problem with "Vibe Coding" Everything
Conventionally, when people discover how good modern coding models are, their workflow turns into this:
Paste ticket into prompt -> Hit "Accept All" on 400 lines of generated code -> Code throws an error -> Paste error back into prompt -> Hit "Accept All" again -> Repeat until error stops showing up
There are massive problems with this approach:
- You don't actually know how your own codebase works anymore.
- When an LLM gets stuck in a hallucination loop on a subtle architectural bug, you are completely helpless because you lost the context 10 prompts ago.
- Your own problem-solving muscles atrophy. Six months later, if you have to write a basic data transformation or debug a race condition without autocomplete, you freeze.
In short, the problem is outsourcing your mental model. You can outsource typing boilerplate all day long, but the moment you outsource understanding, you accumulate "cognitive debt" that will bankrupt your project the second it hits real complexity.
It happened with me multiple times actually.
The 1,200-Line Hallucination Trap
A couple of months ago, i needed to build a custom parser and state-syncing engine for a side project. I was tired, so i got lazy.
Instead of mapping out the state machine myself, i opened my AI editor and kept prompting:
- "Build a sync engine that handles retries and out-of-order events."
- "Wait, it failed on duplicate timestamps, fix that."
- "Now add optimistic rollback if the webhook times out."
In two hours, the AI had generated 1,200 lines of code across 6 files. It looked super clean. TypeScript compiled with zero errors!
Then i actually tested it with real out-of-order packets. Everything broke silently.
When i opened the 1,200 lines to fix it myself, i realized a terrifying truth: i was a stranger in my own repo. The AI had invented three layers of over-engineered wrapper classes, circular callbacks, and band-aid if statements from my follow-up prompts.
I spent 3 hours trying to untangle it, got disgusted, ran git reset --hard, drew a 4-box state diagram on Excalidraw in 15 minutes, and rewrote the entire engine in 180 lines of code.
What messed me up was letting the AI design the architecture when LLMs are trained to add more code, not to simplify your mental model.
- Bad AI workflow: "AI designs the system -> Human fixes the syntax errors."
- Cracked AI workflow: "Human designs the architecture and boundaries -> AI fills in the tedious implementation inside strict constraints."
Other issues with blind AI reliance
There are a few other issues when you never turn off autocomplete:
- You accept subtle security flaws (like missing ownership checks in smart contracts or SQL/command injection in backends) because the code looks professional.
- You stop learning new APIs deeply because you never read the docs or trace the types yourself.
- Every feature balloons to 3x the code size because LLMs love verbose abstractions and rarely say "hey, let's delete 50 lines instead."
The unconventional way: AI as Sparring Partner + Junior Intern
In the unconventional way of using AI, you split your brain into two distinct modes: Learning/Architecting Mode and Execution/Shipping Mode.
Human Maps Architecture -> Interrogate AI to Challenge Edge Cases -> Define Strict Function Signatures -> Let AI Write the Boilerplate -> Human Reviews & Breaks It
Here is the Information Map of how to keep your brain sharp while still moving at AI speed:
[ New Problem / Feature ]
|
v
[ Do I already understand how to build this from scratch? ]
/ \
NO (Learning Mode) YES (Shipping Mode)
/ \
v v
[ Turn OFF Autocomplete! ] [ Human Draws Architecture & Types ]
| |
v v
[ Use AI as a Socratic Tutor ] [ Prompt AI for Scoped 50-Line Chunks ]
"Don't write code. Explain the "Implement ONLY this interface using
mental model & quiz me on edge cases." this exact approach."
| |
+-----------------------+-----------------------+
|
v
[ Human Reads Every Line & Runs Adversarial Tests ]
The Anti-Brain-Rot AI Workflow.
Notice the branch right at the top: Do i already know how to build this? If i'm learning a new concept (like Zero-Knowledge proofs or Rust lifetimes), i forbid the AI from writing code for me. I use it as a senior engineer to answer my "why" and "how" questions while i write the code by hand. If i'm writing my 50th CRUD endpoint, Zod schema, or React table that i already understand backwards and forwards? Let the AI blast it out in 5 seconds!
Benefits of this Dual-Mode approach
Now i don't think i need to tell you the benefits of this approach. But still:
- You ship boring boilerplate 10x faster without losing your core engineering sharpness.
- You never end up with a 1,000-line codebase you don't understand.
- Using AI as a Socratic sparring partner ("roast my architecture diagram and tell me 3 ways this breaks under load") makes you learn 5x faster than reading static blogs.
- Your code stays tight, minimal, and intentional.
- In live interviews or production emergencies where AI can't save you, you are still dangerous on your own.
A foolproof framework (The High-Agency AI Loop)
If you feel like you've gotten a bit too dependent on hitting Tab and Accept, run this protocol:
The core loop
- Draw before prompting: Never write a code-generation prompt until you can sketch the data structures and flow in 4 boxes on paper/Excalidraw.
- Write the types and signatures yourself: Define the TypeScript
interface, the Ruststruct, or the Solidityfunctionsignature by hand. That locks the AI into your architecture. - Never accept code you can't explain line-by-line: If the AI uses a flag, a regex, or a method you don't recognize, stop and ask what it does before merging.
- Use the "Roast My Plan" prompt: Before coding, tell the LLM: "Here is how I plan to build X. Do not write code. Act as a ruthless staff engineer and point out race conditions, security flaws, or simpler alternatives."
- No-AI Fridays (or Learning Blocks): Whenever you are learning a brand new language or core algorithm, turn off inline ghost-text completions completely so your brain feels the friction of recalling syntax and logic.
Tools
Cursor / Claude Code (with strict .cursorrules telling it to prefer minimal code and ask before making architectural jumps), Excalidraw for pre-prompt architecture design, and git diff to ruthlessly audit every line before committing.
When "Vibe Coding" still makes sense
If you need a one-off Python script to convert 50 CSV files, a throwaway hackathon prototype you will delete on Monday, or a quick visualization tool to inspect some data—vibe code away! Not every script needs to be handcrafted art. Just know the difference between a throwaway script and core infrastructure.
Final Words
That's it for the blog. Next time you sit down to build a complex feature, close the chat sidebar for the first 15 minutes, draw the state transitions yourself, write the function signatures by hand, and then let the AI fill in the bricks. You stays the architect; the machine stays the power tool.
see you in the next one.
Responses (0)
Share your thoughts, critique, or questions
No responses yet
Be the first to share your perspective or critique.