Seu manual de programação por descrição

You've learned when to trust AI, how to dodge its pitfalls, and how to keep growing. Now let's turn all of that into a repeatable playbook, a set of habits and a checklist you can run on every single build.

Great builders aren't great because they're geniuses. They're great because they follow a process that catches mistakes before users do. This lesson gives you that process.

The biggest quality boost happens before any code: describe what you want clearly. Vague prompts get vague apps. A good spec names the goal, the inputs, the outputs, and what "done" looks like.

Don't ask for the whole app in one shot. Break it into small, testable pieces and verify each before moving on.

One feature, run it, confirm it works, then the next. Small steps mean that when something breaks, you know exactly which change caused it. Big-bang prompts create big-bang bugs that are miserable to untangle.

Running code is how you turn invisible assumptions into visible facts. After every meaningful change, run it. Tools like Replit, Bolt, and v0 give you instant previews, use them obsessively.

Here's a tiny piece of a tip calculator. Run it to confirm the math before building the UI around it. Verify the core, then expand.

You can't read everything, and you don't need to. But always read the lines that touch money, data, access, or deletion. That's where silent bugs become real damage.

Skim the layout and copy; scrutinize the logic that matters. This is the green/red zone judgment from earlier, applied as a routine.

Happy-path testing is easy and misleading. Real reliability comes from edge cases. Make the AI generate them for you so you don't have to think of them all.

When the AI hands you something complex, push back. Ask: is there a simpler way? Simpler code has fewer places to hide bugs and is easier for both you and the AI to change later.

Simplicity is a discipline you enforce on every prompt, not a one-time choice. "Make it simpler" is one of the most valuable instructions you can give.

Before any big change, make sure you can undo it. Save your work, commit to version control, or at least keep a copy. AI can rewrite half your app in seconds, you want an escape hatch when it goes sideways.

Carry forward the growth mindset: every build should teach you at least one thing. Ask the AI to explain one concept it used, and add it to your learning trail.

This keeps the playbook from making you mechanical. You're not just shipping, you're compounding your skill with every project. Over a year, that's a transformation.

Before you call any build "done," run this checklist, you can even hand it to the AI as a final audit (see the prompt below):

• Did I write a clear spec?
• Did I build and test in small steps?
• Did I run it after every change?
• Did I read the lines touching money, data, and access?
• Did I test empty, zero, and weird inputs?
• Is it as simple as it can be?
• Do I have a way to undo this?
• What's one thing I learned?

Anyone can type a prompt and get code. What makes you reliable is the process around the prompt: clear specs, small steps, constant running, targeted review, edge testing, simplicity, safety, and learning.

Run this playbook on every build and you'll ship apps that actually work, while quietly becoming a genuinely skilled developer. That's vibe coding, done wisely.

You now have a complete vibe coding playbook:

• Clear spec, small steps, run constantly.
• Review risky lines, test the edges, keep it simple.
• Always have a way back, and learn one thing per build.
• Finish with the pre-ship checklist, even hand it to the AI to audit.

This is the habit set of an effective AI builder: fast, reliable, and always growing. You've completed Limits & Best Practices, now go build wisely.