1. Describing Everything at Once
You have a great idea for an app. You write a long, detailed description — every feature, every screen, every interaction — and send it to AI in one message. The result: a mess. Some parts work, some don't, and you can't tell which piece caused the problem.
This is the most common mistake and the most costly. When AI generates an entire application at once, the pieces don't always fit together. A bug in the login screen affects the dashboard, the dashboard affects the settings page, and suddenly nothing works.
What to Do Instead
Build one feature at a time. Start with the most important screen. Get it working. Test it. Then add the next feature. If something breaks, you know it was the last thing you added.
"Build me a complete project management app with user accounts, team workspaces, task boards, due dates, file attachments, commenting, notifications, and a mobile-responsive design."
"Build a task board with three columns: To Do, In Progress, Done. I can add tasks with a title. I can click a task to move it to the next column. Clean, simple design."
Once that works, you add the next feature: "Now add due dates to each task. Show overdue tasks in red." One step at a time.
2. Not Testing What AI Built
The app looks great. The design is polished. The buttons are all there. So you share it with someone — and they immediately find that the signup form doesn't actually create an account, the search bar doesn't search anything, and the "Save" button saves nothing.
AI is very good at making things that look right. It generates professional layouts, proper labels, and realistic placeholder data. But looking right and working right are completely different things.
What to Do Instead
After AI generates anything interactive, test every piece:
- Fill out every form. Does the data actually go somewhere? Refresh the page — is it still there?
- Click every button. Does it do what the label says? Or does nothing happen?
- Try wrong inputs. Leave a required field empty. Enter letters in a number field. Use a very long name. What happens?
- Test on your phone. Does the layout still work on a small screen?
Five minutes of testing saves hours of embarrassment later.
3. Being Too Vague
"Make it look better." "Add some features." "Make the design more modern." These are instructions that mean nothing specific — and AI will interpret them unpredictably. "Better" according to whom? "Modern" in what way?
Vague descriptions produce vague results. Then you send another vague correction, get another unpredictable result, and the back-and-forth drags on.
What to Do Instead
Be specific about what you want changed. Name the element, the change, and the reason if it helps:
"Make the page look better."
"Add more space between the cards. Make the headings larger. Change the background to dark gray (#1a1a1a) and the text to off-white. Remove the border around each card and add a subtle shadow instead."
You don't need to know CSS to be specific. Describing what you see and what you want it to look like is enough — as long as you describe the actual visual change, not just a feeling.
4. Not Saving Working Versions
Your app works perfectly. You ask AI for one small change — "move the navigation to the left side" — and suddenly the entire layout is broken. The page that worked five minutes ago is now a jumbled mess, and you can't get back to the version that worked.
This happens constantly. AI sometimes regenerates large sections of code to make a small change, and the new version breaks things the old version handled correctly.
What to Do Instead
Before every significant change, save what you have:
- In Claude: Your working version is in the conversation history. You can always scroll back. But for extra safety, copy the working code to a text file on your computer.
- In Bolt or Replit: Look for version history or snapshot features. Take a snapshot before making changes.
- General rule: If you're about to say "Now change..." to something that already works, save it first.
If it works, save it. If you're about to change something that works, save it first. This takes 10 seconds and can save you an hour of trying to recreate something you already had.
5. Letting AI Add Things You Didn't Ask For
You ask AI to add a search bar. It adds the search bar — plus a filter dropdown, a sort button, a "clear all" link, and a results counter. You didn't ask for any of that. Some of it works, some doesn't, and now your simple page has features you didn't want and may not work correctly.
AI tends to over-build. It adds features because it's seen them in similar projects in its training data, not because you need them.
What to Do Instead
End your requests with: "Only make this change. Don't add anything else."
Add a search bar above the list that filters items by title as I type. Only make this change. Don't add anything else or modify other parts of the page.
This constraint is surprisingly effective. Without it, AI defaults to "helpful" by adding related features. With it, AI focuses on exactly what you asked for.
6. Ignoring What Happens to Your Data
You build a to-do app. You add 20 tasks. You close the browser and come back the next day — all your tasks are gone. Or worse: you share the app with a friend, and they can see and delete your data.
Data is the part of an app that most people don't think about until it's too late. Where is your data stored? Who can see it? What happens if you clear your browser? These questions matter, and AI won't always bring them up on its own.
What to Do Instead
When describing your project, always address data storage explicitly:
- "Save data in the browser" (localStorage) — Good for personal tools only you use. Data stays on your device. Disappears if you clear browser data.
- "Save data in a database" — Needed if multiple people use the app, if data can't be lost, or if you access it from different devices. More complex to set up.
- "Don't save anything" — Fine for calculators, converters, and tools that don't need to remember anything.
Ask AI directly: "Where is the data being stored? What happens to it if I close the browser? Can other people see it?" If you don't like the answers, ask AI to change the approach before you build further.
7. Going in Circles Instead of Starting Over
You've been trying to fix the same problem for an hour. Each fix introduces a new bug. Each new bug requires another fix. The conversation with AI is 40 messages long and nothing works properly anymore.
This is the sunk cost trap. You've invested time, so you keep trying to fix the existing version instead of starting fresh. But after a certain point, the accumulated fixes have made the code so tangled that every new change breaks something else.
What to Do Instead
Recognize the signs that a fresh start is faster:
- You've tried to fix the same issue three or more times
- Fixing one thing keeps breaking something else
- The conversation is so long that AI seems to have forgotten what you built earlier
- You can't describe what the app is supposed to do anymore because of all the changes
When you hit this point: start a new conversation. Describe what you want from scratch — but this time, your description will be much better because you learned from the first attempt what works and what doesn't. The second version almost always comes together faster than the first.
Pro Tip: Write Your Description Before Starting Over
Before starting fresh, write down a clear description of what you want — including the lessons from the failed attempt. "Last time, the search feature broke the layout. This time, add the search bar inside the header area, not as a separate section." Your second attempt benefits from everything you learned in the first.
Seven Mistakes — Quick Reference
- Describing everything at once — Build one feature at a time. Test before adding the next.
- Not testing — Click every button, fill every form, try wrong inputs. Looking right isn't working right.
- Being too vague — Name the element, describe the specific change. "Better" means nothing.
- Not saving working versions — If it works, save it before changing anything.
- Letting AI add extras — End requests with "Only make this change. Don't add anything else."
- Ignoring data storage — Ask where data is saved, who can see it, and what happens when you close the browser.
- Going in circles — If fixing one thing keeps breaking another, start fresh with a better description.