At first, it honestly felt like cheating.
Features appeared instantly.
Backend routes? One prompt away.
React components? Generated in seconds.
But after a couple of days, something weird happened.
I stopped understanding my own project.
Structure of the project
The Rules I Set
Before starting, I needed rules.
Otherwise I would just fall back to writing code myself.
So I created four:
i. Let AI write first
Don't type code until Copilot or ChatGPT generates it.
ii. Only debug using AI
No Stack Overflow or documentation unless AI suggested it.
iii. No outside help
No classmates.
No tutorials.
iv. Don't refactor working code
If it works, move on — even if it's ugly.
The goal was simple:
Can AI carry a beginner — with just HTML and CSS — through a full-stack MERN project?
At first it looked like the answer was yes.
But the more I followed these rules, the more I noticed something strange.
The less I thought about the code...
The more problems started appearing.
Day 1: The Magic Phase
Day 1 felt like magic.
Instead of writing code, I started writing prompts.
Example:
"Create an Express server with MongoDB connection."
A few seconds later — done.
Next prompt:
"Write an Express route to add and fetch users."
Done again.
Copilot generating a large chunk of code
When I switched to the frontend, AI started generating entire React components before I finished typing.
For someone who only knew HTML and CSS, this felt unreal.
Within a few hours I had:
- a running Express server
- a working MongoDB connection
- multiple API routes
- React components displaying data
Normally learning all this would take days.
AI made it feel effortless.
For a moment, I genuinely thought:
"Why do people even struggle with full-stack development anymore?"
Unfortunately...
That confidence didn’t last long.
Day 4: Debugging AI Code Is Painful
By Day 4, something interesting happened.
Writing code wasn’t the problem anymore.
Debugging it was.
Small issues started appearing:
- API responses returning wrong data
- React state not updating correctly
- MongoDB queries behaving strangely
But most of the code was written by AI.
Which meant something uncomfortable:
I didn’t fully understand the logic anymore.
So I followed my experiment rule — ask AI to fix it.
That’s when the real problem started.
The AI would suggest a fix.
Sometimes it worked.
Other times it introduced a new bug somewhere else.
Which created a loop:
- Ask AI for a fix
- Apply the solution
- Something else breaks
- Ask AI again
Instead of debugging my project...
I was debugging the AI's suggestions.
The Biggest Mistakes Developers Make With AI
After a week of letting AI write most of my code, I noticed a few patterns.
These mistakes weren't just mine.
A lot of developers are probably making them.
Mistake #1 — Copy-Paste Programming
When AI generates working code, it's tempting to paste it and move on.
But if you don't understand it, debugging later becomes extremely difficult.
Working code without understanding is just delayed confusion.
Mistake #2 — Trusting AI Explanations Too Much
AI rarely says "I don't know."
Instead, it gives confident explanations.
Even when they aren't completely correct.
Sometimes ChatGPT and Gemini even gave different explanations for the same bug.
Both sounded convincing.
Only one could be right.
Real Example from the Experiment
Prompt I used:
Fix this React state bug where the component doesn't re-render
after updating MongoDB data.
AI suggestion:
Use useEffect to re-fetch data whenever state changes.
Result:
Infinite re-render loop.
Mistake #3 — Letting AI Design Your Code
AI is good at generating pieces of code.
But it's not great at designing clean architecture.
Over time this can lead to:
- messy logic
- redundant functions
- inconsistent patterns
Mistake #4 — Losing the Learning Opportunity
Debugging, reading documentation, and experimenting are how developers learn.
AI removes a lot of that struggle.
Which sounds great.
Until you realize you finished the project without fully understanding the stack.
When AI Actually Helps 🌟
Despite the problems, AI was still extremely useful.
The key realization:
AI works best as a productivity tool, not a decision-maker.
AI helped most with:
Boilerplate
- Express server setup
- MongoDB connections
- React component templates
Explaining Errors
Instead of decoding long stack traces, I could ask:
Explain this error and possible causes.
Even if the answer wasn't perfect, it often pointed me in the right direction.
Learning Syntax
AI helped explain:
- React hooks
- Express middleware
- MongoDB queries
Which made learning new concepts faster.
My New Rules for Using AI
After this experiment, I didn't stop using AI.
But I changed how I use it.
Rule #1 — AI Writes Boilerplate, Not Architecture
AI can generate repetitive code.
But developers should design the system.
Rule #2 — Never Run Code You Don't Understand
If you can't explain it, don't run it.
Rule #3 — Debug Yourself First
Try solving the problem manually before asking AI.
Rule #4 — Use AI to Learn, Not Skip Learning
Instead of asking AI to solve everything, ask it to explain.
Example:
Explain how Express middleware works.
Final Thoughts — AI Should Amplify You, Not Replace You
This experiment started with a simple question:
What happens if AI writes most of the code?
After one week, the answer was clear.
AI can speed up development dramatically.
But relying on it too heavily creates new problems:
- harder debugging
- less understanding of your code
- weaker learning of new technologies
AI is an incredible tool.
But it should amplify developers, not replace their thinking.
Demo:
Frontend UI
Discussion
Have you ever relied too much on AI while coding?
What was the weirdest bug AI helped (or failed) to fix?
Curious to hear other developers’ experiences.