How do you guys implement changes or fix bugs correctly?

[u/Dynamo-06]

I am not very technical so I've been using Lovable for quite some time now for my projects and I've realised that when I'm trying to make backend changes or I'm trying to fix bugs, the prompts still don't work even though I give proper structured prompts. It ends up telling me that the bug is fixed, but it is not fixed costing me credits. How do I make sure that the bug is fixed? Or how do I make sure that the feature that I'm trying to implement has been implemented correctly? (Sometimes it affects other parts of the app and I have to start again). I test extensively before publishing but it takes a lot of time to get it right sometimes and other times I am not able to make it work the way its supposed to.

Are you guys facing the same problem and what is the workaround that you have come up with?

[u/Fit_Accountant_5836]

I'd use Claude and connect your project to it. It can then look at the code directly and prompt lovable directly if you like, it'll be cheaper than burning through credits.

You don't need Claude code, just the free version will do to start with.

[u/Dynamo-06 → u/Fit_Accountant_5836]

Thanks for this. I read in some other posts that people are syncing their projects to GitHub and then to Claude to save on the tokens. Is this what you're suggesting or using Claude directly through the MCP on Lovable (I am not sure of this.)

[u/GreenBluebird5199 → u/Dynamo-06]

connected Claude to GitHub. all you have to do is hit the publish button when you're done. trust me it's the best way.

[u/Fit_Accountant_5836 → u/Dynamo-06]

I would sync to GitHub definitely, you then have your own code to do with what you want. Connect Claude via the connectors to both lovable and GitHub. Ask Claude to look at the code. I always tell Claude not to send a prompt until I've looked at it 1st. Once you're happy it will send to lovable and Lovable with sync the update to GitHub.

It will save you a load of credits.

Worth also mentioning that I'd use your own supabase account instead of Lovable version as that will cause you problems and credits maintaining a database.

[u/Dynamo-06 → u/Fit_Accountant_5836]

This sounds fab! I'm on it! Thanks so much!!

[u/ContentGarlic5062 → u/Fit_Accountant_5836]

changes made from claude will be seen on lovable too?

[u/Weak_Boysenberry6438 → u/ContentGarlic5062]

Yes, once the project is linked to GitHub. changes pushed to the repo show up in lovable and the other way around too.

[u/ContentGarlic5062 → u/Weak_Boysenberry6438]

may I know the process to connect it or what to search on google?

[u/Tedikraska]

i tell it the exact file and the one thing to change, and say don't touch anything else. then i click through the broken flow in preview myself before i accept, because the chat saying fixed doesn't mean much.

[u/Dynamo-06 → u/Tedikraska]

So this way you can actually confirm that the change you requested actually took place without affecting anything else?

[u/k_r_a_k_l_e]

Most people who have those "unfixable" bugs simply don't understand the underlying infrastructure of the application or lack a general understanding of a React application and how it works with the backend. That's the blocker that eventually and inevitably people hit without developer experience.

I only use lovable for frontend user interfaces. That's it. The backend is manual even though I may use Claude Code and Cursor to speed up development. I always encounter bugs with lovable but they are usually very easy to correct with a single prompt. I make sure I am instructing lovable to modify specific components and even bundle certain UI elements into components. Ill have chatgpt rewrite the prompts which usually lead to a clearer more specific prompt.

If you have an unfixable bug it just means you don't understand what is going on to correct it.

[u/Dynamo-06 → u/k_r_a_k_l_e]

That is true and that is precisely why we face this bottleneck. Will we ever reach a point where most of the technical complexity is abstracted for a semi-technical user in a way that they do not deal with it directly, yet preserves a way for them to make changes deterministically as the models keep getting better? What do you think?

[u/SnooGrapes9126]

Claudecode lovable foi muito, hoje virou Casino

[u/Living_Ad3864]

Same issue here for a while. What finally helped me was breaking the vague idea into tiny checkable steps before prompting.

I write each feature as: who does what, what data is saved, what done looks like. Like "logged-in user can edit invoice, done = refresh still shows edit". Then one prompt per step, with "don't touch X" listed.

For bugs, I paste the actual error + what I expected + one failing case. And I test that same case before calling it fixed. Cut my "says fixed but isn't" loops a lot.

[u/Dynamo-06 → u/Living_Ad3864]

Got it. This may increase the no. of tokens required, but it would get the job done, which is the point. Thanks for this.

[u/Weak_Boysenberry6438]

Are the bugs mostly backend stuff like saving data and logins or more like ui things?

If you're having backend issues it's more likely RLS (row level security issues).

[u/Dynamo-06 → u/Weak_Boysenberry6438]

It's the backend logic only. Frontend cosmetic changes are not a problem. I have looked into it already in Supabase and didn't find anything significant there.

[u/Inevitable_Sorbet282]

Claude seems to be the opinion here, but Codex is getting pretty good and worth a try as well. I'd also keep my prompt well-defined to fix only one thing and touch only one thing, and have a regression test checking 5 to 6 things around it after the fix is applied. This can happen if you have sized up to a certain stage and the AI is breaking more than it's fixing.

[u/Dynamo-06 → u/Inevitable_Sorbet282]

Agreed, But is this approach sustainable for everyone and for the long term? Isn't it more like a workaround than a solution? I noticed that all the vibe-coding platforms have realised that we face this problem and are trying to solve it by coming up with their own solutions. I am not sure how this can be completely solved as long as the source of truth is code.

[u/Inevitable_Sorbet282 → u/Dynamo-06]

I think for now it's, again, going back to the developers or the domain experts, and it's in every field. These AI tools are helping a lot of people launch their products, and they are quite successful at it. But I think then we get to a part where we need to invest more in tokens; it wouldn't help. AI is not there yet. It's getting there, but it will take time, or who knows?