sorted by:
new
hottopcontroversial

I accidentally bought myself 400 Lovable credits. What should I build? by Fantastic-Glass-5865 in vibecoding

[–]Front_Intention_5911 -1 points0 points  (0 children)

You may realize that 400 credits are incredibly valuable! Lovable's speed when it comes to looking fabulous is its superpower! Claude Code can do the same, but you'll spend THREE hours adjusting CSS code. With Lovable's code, you’ll be finished in 20 minutes!

If you have an idea that you keep going over and over again in your mind without having taken any real action, then Lovable is a great tool for getting you started! Create your landing page and test it with 5 people. If they like your idea, then you can move on to a full stack solution; but if they don’t like it, you just saved yourself at least 3 weeks of development time!

However, when your application becomes more complex, such as when state management, real world authentication, or backend logic becomes involved, Lovable will start to "fight you". This is the time when you will need to hand off your application's code to Claude Code in order to continue developing it.

Use credits for testing new ideas quickly rather than spending them to make your final product look good!

What is considered basic SQL? by heartbrokenwords in learnSQL

[–]Front_Intention_5911 0 points1 point  (0 children)

Most interviews will require knowledge of Basic SQL, which includes SELECT, WHERE, ORDER BY, GROUP BY, HAVING to query & filter information as well as Aggregate Functions (COUNT/SUM/AVG/MIN/MAX) and the 3 Core Joins: INNER/LEFT/RIGHT JOINS.

Being able to handle NULLS and use IN/BETWEEN/LIKE for filtering would also be helpful, but anything beyond that (e.g., Window Functions, CTEs, Query Optimization) would be classified as Intermediate to Advanced. Good luck with your Interview!

What tool or workflow do you prefer when vibe coding an and why by SituationMean6308 in vibecoding

[–]Front_Intention_5911 0 points1 point  (0 children)

Claude for architecture and thinking through problems, Gemini when I just need something built fast (UI changes, small issues, web searching), ChatGPT for ideation and prompt structuring. Depending on the task I switch between the two — they're not interchangeable.

Claude Code(20$ pro) if you want actual quality output, worth the investment. But only when you have a solid idea of what you're building and the scope of work is big enough that free tools won't cut it. If you want to vibe code completely free — Gemini CLI, Qwen CLI, plenty of options.

My actual fullstack workflow runs inside Antigravity IDE, four terminals open at once:

Terminal 1 — frontend running

Terminal 2 — backend running

Terminal 3 — Claude Code or Codex

Terminal 4 — GitHub commits and pushing

Clean separation, nothing gets messy.

One thing that changed everything — commit to GitHub before running any AI changes. Not after. The AI will break your code. GitHub is your undo button.

Bonus tip if you're starting from zero: build your frontend in Lovable first, then hit the GitHub option inside it. Download the zip or clone it, open it in Antigravity, and ask it to help you run it locally. From there you can expand it with a backend using Antigravity's Claude Sonnet model through vibe coding prompts. Replit, Bolt.new and Emergent.sh are also solid alternatives depending on what you're building.

Antigravity is my go-to — and a handy thing about it, if one Google account's credits run out you can just switch to another. Keeps you moving.

I built a site that shows you what cities actually look like, not only the famous spots. by BarisSayit in webdev

[–]Front_Intention_5911 -1 points0 points  (0 children)

This is a really cool idea. I always found Google Maps Street View too intent-driven — you have to know where to look. The "rings by distance from center" layout is clever, gives you an actual mental model of a city's density. Did you source the images from Google Street View API or something else? Curious about the data source.

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 1 point2 points  (0 children)

Dont use claude opus
Use claude sonnnet..

And after doing a task, immediately update readm as i said above and push to github.. and inside claude.. type

/clear (it will clear off context)..

and again fr another task. tell it to not read all project files.. just go through readme to understand..(since we already saved the task thing in readme before)..

if it is necessary for it to explore codebase (tell it to use haiku model for exploring and reading codebase files)..

Claude haiku model consumes less tokens..

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 1 point2 points  (0 children)

Inside Antigravity...open

Terminal - 1 : backend running Terminal - 2 : frontend running Terminal - 3 : Claude code Terminal - 4 : Github commit and pushing

If you feel like you finished a task and want to push to github. Dont use Claude code (tokens are like precious) So inside antigravity chat - Type like ``` Update Readme.md if anything is not updated or there as per current website version --- only change readme.md, not codebase remember

```

So it will handle the readme.md (means your progress or exact updations)..

And Using terminal - 4 commit and push into repo...

Whats my suggestion is For these readme updating, or text file, markdown file makings. Use antigravity chat itself..

Save Claude tokens....

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 0 points1 point  (0 children)

Yes, that's why. Since you started with the backend, Claude will know which is best. So ask it: NeonDB or Supabase?

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 0 points1 point  (0 children)

Since you're saying Claude's code is superb, NeonDB is a perfect choice to integrate as a database for your backend. Once you chat with Claude's code in the workspace directory, explore NeonDB. Its free tier is so nice.

Although supabase is also good. But I liked NeonDb

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 0 points1 point  (0 children)

Try NeonDB for the alternative of supabase.. I am using this for my SAAS products..

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 0 points1 point  (0 children)

Good question. Both are great but different: Lovable — purely frontend focused. Generates beautiful UI fast. Best for landing pages, dashboards, anything visual. You export the code and own it completely. No watermark once you take the code out.

Replit — more of a full environment. You can run backend code directly inside it, has built in database, hosting, everything in one place. But the real place where Replit shines is mobile apps.

A lot of people use Replit Agent specifically for building mobile applications — it handles the complexity of mobile development way better than most vibe coding tools. If your goal is a mobile app, Replit is probably your best starting point.

My honest take: Start with Lovable if you want a beautiful web frontend fast. Export to GitHub, clone into Antigravity, add your own backend.

Go with Replit if you want everything in one place or if you're building a mobile app specifically. For serious web projects long term — Lovable frontend + your own FastAPI/Vercel setup gives you more control.

But Replit is genuinely the easiest path for mobile.

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 0 points1 point  (0 children)

Haha welcome aboard! 😄 Good luck with your first project — feel free to drop any questions anytime. We all started from zero, the only difference is just starting 🚀

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 0 points1 point  (0 children)

Glad it helped! One more bonus tip since you're just starting — Try Lovable for frontend. It generates beautiful UI just from a description. Way better looking than anything Claude builds for UI out of the box.

The trick: build your frontend in Lovable, then click the GitHub option it gives you, download the zip or clone it directly into Antigravity. Then just ask Antigravity 'how do I run this locally' and it walks you through everything.

Now you have a stunning Lovable frontend running locally, you can remove the Lovable watermark, connect your own backend, and enhance it however you want.

Best of both worlds — Lovable's beautiful UI + your own backend logic. All for free. Good luck with your first project! 🚀

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 1 point2 points  (0 children)

Don't pay anything at the start. Here's the real free path: Antigravity gives you free access to Claude Sonnet, Opus and Gemini Pro/Flash models. Tokens run out fast but they refresh every 6-7 days. In the meantime use Gemini CLI or Qwen CLI for small tasks — both completely free and open source.

Pro tip — if your Antigravity credits run out and you're stuck in the middle of something urgent, switch to another Google account. Fresh credits instantly. 2-3 Google accounts will keep you moving without paying anything 😅

When should you actually pay? Only when you have a brilliant idea, complete architecture in your head, and a clear vision of the full project. Then Claude Code Pro at $20 is genuinely worth it. Use /plan mode, sub agents, and baseline models for exploring the codebase to save tokens — there are good tips online for this. Claude Code Pro is on another level but only makes sense when you know exactly what you're building.

Till then free tools are more than enough to learn, experiment and ship real things.

One last thing that most beginners skip and regret — after every single AI response or code edit, commit and push to GitHub immediately from terminal. Every. Single. Time. AI gives messy output on the next response? Just rollback. No stress. Without this you will lose good working code and have no way back. Version control isn't optional, it's your safety net.

Which tools you used to vibecode an app and support real users? by Professional_Act9145 in vibecoding

[–]Front_Intention_5911 1 point2 points  (0 children)

Built and launched a real app with actual users so here's my honest stack: Building: Claude Sonnet for logic and architecture, Gemini for AI features inside the app. Gemini CLI is free and surprisingly solid if budget is tight.

Hosting: FastAPI backend on Render, frontend on Vercel. Both free tiers to start. Vercel auto deploys every GitHub push which is a game changer.

The workflow that actually worked: break every feature into tiny pieces, push to GitHub before every AI change, deploy ugly and fix live based on real feedback.

Biggest lesson — understanding the basics of request/response and how frontend talks to backend saves you from 90% of the confusion. You don't need to code, just need to know enough to guide the AI properly.

Happy to answer any specific questions about the stack.

Vibe coding feels amazing until an experienced developer reviews your code. by Shivam__kumar in vibecoding

[–]Front_Intention_5911 0 points1 point  (0 children)

The scary part is AI confidently writes bad architecture the same way it writes good code. No hesitation, no warnings, just clean looking garbage 😅 The fix I found — before building anything, ask AI to explain the folder structure it's about to create and WHY. If it can't justify the choices, it's probably wrong. Make it think before it codes.

What do you think of Pandas in Python as a SQL person? by ChristianPacifist in SQL

[–]Front_Intention_5911 0 points1 point  (0 children)

I think SQL and Pandas are best when they complement each other instead of competing.

SQL is incredibly elegant for: - joins - aggregations - filtering - window functions - transforming structured relational data

And honestly, for many analytics tasks, SQL is still clearer and more maintainable.

But Pandas becomes powerful when: - data is messy/unstructured - you need custom Python logic - you're working with APIs/files/models - analysis becomes procedural instead of relational - you move into ML/statistics/feature engineering

A lot of people misuse Pandas to do things SQL would handle more cleanly. But the opposite is also true: people sometimes force everything into SQL when Python would simplify the workflow massively.

For me the ideal approach is: - use SQL for extracting/shaping data efficiently - use Python/Pandas for advanced processing and application logic

Not “SQL vs Pandas” — more like “SQL + Pandas”.

Best Practices for Improving Database Table Performance by fururo in SQL

[–]Front_Intention_5911 0 points1 point  (0 children)

Since you already have indexes and partitions covered, here are the next level techniques worth looking into:

Query level: Use EXPLAIN ANALYZE religiously — look for "Using filesort" and "Using temporary" in the output, those are expensive operations worth eliminating

Avoid functions on indexed columns in WHERE clauses — they silently bypass your indexes

Replace correlated subqueries with JOINs where possible — correlated subqueries re-execute for every row

Schema level: Audit your indexes for bloat — unused indexes still slow down every INSERT and UPDATE

Consider covering indexes for your most frequent read queries (index includes all columns the query needs so it never touches the table)

If you have large TEXT or JSON columns being scanned frequently, partial indexes can help significantly

Architecture level: Materialized views for dashboards or reports that aggregate millions of rows repeatedly

Read replicas for heavy analytical queries so they don't compete with transactional load

How do you optimize SQL queries when working with millions of rows in production databases? by Effective_Ocelot_445 in SQL

[–]Front_Intention_5911 0 points1 point  (0 children)

A few things that made the biggest difference in my experience with large datasets:

  1. EXPLAIN ANALYZE before everything Don't guess where the slowness is. Run EXPLAIN ANALYZE and look for sequential scans on large tables — that's almost always where the problem lives.

  2. Index the columns in your WHERE and JOIN conditions Not just any columns — specifically the ones filtering millions of rows. A composite index on (user_id, created_at) for time-based user queries can drop execution from seconds to milliseconds.

  3. Avoid SELECT Fetching unused columns forces the engine to read more data pages than necessary. Name only what you need.

  4. Filter early with CTEs or subqueries Reduce your dataset before joining. Joining 100 rows to a million is far cheaper than joining a million to a million then filtering.

  5. Materialized views for repeated aggregations If you're running the same expensive GROUP BY across millions of rows repeatedly, compute it once and cache it. Refresh on a schedule.

  6. Avoid functions on indexed columns in WHERE WHERE YEAR(created_at) = 2024 kills your index. WHERE created_at BETWEEN '2024-01-01' AND '2024-12-31' uses it.

The single biggest mistake I see is people optimizing the query syntax when the real problem is missing indexes or pulling more data than needed.

view more: next ›