Using Lovable professionally for client work requires a structured workflow: create separate workspaces per client, connect GitHub early for version control, document your architecture in AGENTS.md, and plan your handoff before building. Use Plan Mode for scoping and Visual Edits for polish to minimize credit burn during the final 20% of the project.
Why Lovable projects need structure for professional client work
Lovable is excellent at getting a project to 60-80% completion quickly. The challenge for professional use is the last 20-30%, which requires careful prompt management, version control discipline, and a clear handoff plan. Without structure, you end up burning credits on debugging loops, losing track of what changed, and delivering a project the client cannot maintain. The biggest risk is the 'looping problem' — Lovable's AI gets stuck trying to fix a bug, reintroduces old errors, and consumes dozens of credits. In a client project, this means blowing through budget and deadline. The solution is to commit working versions frequently, use Plan Mode before complex changes, and know when to switch to manual editing in Dev Mode. Client handoff is another overlooked area. If the client wants to continue developing after you deliver, they need a GitHub repo, documented environment variables, and an AGENTS.md that explains the project architecture. Without these, the client cannot use Lovable effectively or hand the project to another developer.
- No version control — changes cannot be tracked or reverted when something breaks during development
- No workspace isolation — client projects mixed with personal projects in the same workspace
- Credit burn during debugging — complex features consume credits without a Plan Mode review first
- No handoff documentation — client receives a project they cannot maintain or continue developing
- No AGENTS.md — each new Lovable session starts from scratch without project context
Error messages you might see
Credit usage exceeded monthly allocationComplex projects, especially during debugging phases, can consume credits rapidly. Use Plan Mode for scoping, Visual Edits for styling (no credit cost), and Dev Mode for small code changes to conserve credits.
Lovable keeps reverting my changes after each promptWithout AGENTS.md preservation rules, the AI may overwrite your careful edits. Document protected files and patterns in AGENTS.md before starting client work.
Client cannot access the project after handoffThe client needs to be invited to the workspace or receive the GitHub repo. Transfer workspace ownership or share the repo — project URLs alone do not grant editor access.
Before you start
- A Lovable account on a Pro or Business plan for private projects and Dev Mode access
- A GitHub account for version control (recommended for all client work)
- A clear scope document or requirements list from the client
- Understanding of how Lovable credits work and a budget estimate for the project
How to fix it
Set up a dedicated workspace and connect GitHub from day one
Workspace isolation keeps client data separate, and GitHub creates a safety net for every change
Set up a dedicated workspace and connect GitHub from day one
Workspace isolation keeps client data separate, and GitHub creates a safety net for every change
Create a new workspace for each client (or major client project) to isolate billing, secrets, and member access. In the new workspace, create the project and immediately connect it to GitHub via Settings then Connectors then GitHub. Choose the client's GitHub organization if they have one, or your own organization with a clear naming convention (client-name-project-name). This gives you version history, rollback capability, and a clean repo to hand off.
Expected result: A dedicated workspace with GitHub connected. Every Lovable change creates a Git commit you can track and revert.
Create an AGENTS.md with project architecture and rules
AGENTS.md ensures every AI session has context about the project structure, technology choices, and protected code
Create an AGENTS.md with project architecture and rules
AGENTS.md ensures every AI session has context about the project structure, technology choices, and protected code
Before building features, create an AGENTS.md file in the project root. Document: the tech stack decisions (which libraries to use and avoid), the database schema design, protected files that should not be modified, and coding conventions. This saves time because you do not have to repeat context in every prompt. It also helps the client or future developers understand the project.
1# AGENTS.md — Client Project: [Client Name]23## Project Overview4SaaS dashboard for [client's business]. Users sign up, manage their account, and view analytics.56## Tech Stack7- Data fetching: @tanstack/react-query8- Forms: react-hook-form + zod9- State: zustand for global state10- Charts: recharts11- Auth: Supabase email + Google OAuth1213## Database Schema14- profiles: user profile data (linked to auth.users)15- organizations: multi-tenant org data16- analytics_events: event tracking1718## Protected Files19- src/lib/billing.ts — Stripe integration logic20- src/lib/permissions.ts — RBAC logic21- supabase/migrations/ — do not modify existing migrations2223## Conventions24- Named exports only25- Use @/ import alias26- All components in src/components/27- All pages in src/pages/Expected result: Every Lovable session reads AGENTS.md and follows the project conventions automatically.
Use Plan Mode for scoping before building complex features
Plan Mode costs one credit but prevents multi-credit debugging loops by planning changes before executing them
Use Plan Mode for scoping before building complex features
Plan Mode costs one credit but prevents multi-credit debugging loops by planning changes before executing them
Before asking Lovable to build a complex feature, switch to Plan Mode and describe what you need. Lovable will analyze the codebase and create a detailed implementation plan listing which files to create or modify, what the component structure looks like, and what database changes are needed. Review the plan, adjust it if needed, then click 'Implement the plan' to execute. This prevents the AI from going down a wrong path that costs many credits to undo.
Expected result: A formal plan you can review before execution. Complex features are built correctly on the first attempt more often.
Prepare the handoff package for the client
A professional handoff ensures the client can maintain, update, and continue developing the project after delivery
Prepare the handoff package for the client
A professional handoff ensures the client can maintain, update, and continue developing the project after delivery
Before delivering the project, prepare: the GitHub repository with clean commit history, a README documenting setup steps, a list of all environment variables the project needs (without actual secret values), the Supabase project credentials or instructions to set up their own, and instructions for the client to accept workspace ownership in Lovable. Transfer workspace ownership to the client's Lovable account so they control billing going forward. If the client needs ongoing support with maintaining or extending the project, RapidDev's engineers provide managed Lovable development services for exactly this use case.
Expected result: The client has a complete project with documentation, version control, and the ability to continue development.
Complete code example
1# Project Instructions23## Client: Acme Corp4## Project: Customer Analytics Dashboard56## Architecture7- Frontend: React + TypeScript + Tailwind + shadcn/ui8- Backend: Supabase (auth, database, storage, edge functions)9- Hosting: Lovable Cloud (lovable.app)10- Repo: github.com/acme-corp/analytics-dashboard1112## Key Decisions13- Multi-tenant: each user belongs to one organization14- RBAC: admin, manager, viewer roles stored in org_members table15- Charts: recharts with custom theme colors matching Acme brand16- Auth: email + Google OAuth, redirect to /dashboard after login1718## Database Tables19- profiles (extends auth.users with display_name, avatar_url)20- organizations (id, name, plan, created_at)21- org_members (org_id, user_id, role)22- events (id, org_id, event_type, metadata, created_at)2324## Protected Code (do not modify)25- src/lib/rbac.ts — role-based access control functions26- src/lib/stripe-webhooks.ts — Stripe webhook handlers27- supabase/migrations/*.sql — existing migration files2829## Coding Conventions30- Named exports for all components and functions31- Use @/ import alias (never relative paths)32- Zod schemas in src/schemas/ for all form validation33- TanStack Query hooks in src/hooks/ for all data fetching34- Do not use Redux, Axios, or moment.jsBest practices to prevent this
- Create a separate workspace for each client to isolate billing, secrets, and member access
- Connect GitHub on day one — version control is non-negotiable for professional work
- Write AGENTS.md before building the first feature to establish conventions and protect key decisions
- Use Plan Mode before every complex feature to avoid credit-burning debugging loops
- Use Visual Edits (no credit cost) and Dev Mode for styling and small code changes during the polish phase
- Commit working versions in GitHub before making risky changes so you can always revert
- Budget 30-50% more credits than you estimate for the build phase — debugging and iteration always consume more than planned
- Prepare a handoff package including the GitHub repo, environment variable list, and project documentation
Still stuck?
Copy one of these prompts to get a personalized, step-by-step explanation.
I am using Lovable.dev to build a project for a client. I need help planning my workflow. Here is the project scope: - [describe the app and key features] - [describe the client's technical level] - Timeline: [weeks/months] - Budget: [credit estimate] Please help me: 1. Create a project structure and workspace setup plan 2. Write an AGENTS.md file for this project 3. Break the features into phases with credit estimates per phase 4. Create a handoff checklist for delivering to the client
Create an AGENTS.md file for this client project. The project is a [describe the app]. Document the architecture decisions, database schema, protected files, and coding conventions. Also create a README.md with setup instructions for a developer who needs to work on this project after handoff.
Frequently asked questions
What are the best practices for using Lovable for client work?
Create a separate workspace per client, connect GitHub from day one, write AGENTS.md before building features, use Plan Mode for complex changes, and prepare a handoff package. Budget 30-50% extra credits for debugging and iteration.
How many credits does a typical client project need?
A simple landing page or form-based app might need 50-100 credits. A full SaaS dashboard with auth, database, and multiple pages typically needs 200-500 credits. Complex projects with custom integrations can exceed 1000 credits. Use Plan Mode and Visual Edits to conserve credits.
How do I hand off a Lovable project to a client?
Transfer workspace ownership to the client's Lovable account, share the GitHub repository, document all environment variables, and provide setup instructions. If the client is not technical, consider providing a brief walkthrough of the Lovable editor.
Should I use Lovable's hosting or deploy to Vercel for client projects?
Lovable's hosting at lovable.app is the simplest option and includes custom domains on paid plans. Deploy to Vercel or Netlify if the client needs specific hosting features, CI/CD pipelines, or wants to host on their own infrastructure.
How do I prevent the AI looping problem during client work?
Commit to GitHub before every complex prompt. Use Plan Mode to review changes before execution. If Lovable enters a debugging loop, stop and revert to the last working version instead of letting it continue burning credits. Break complex features into smaller, sequential prompts.
Can I use Lovable for projects I charge clients for?
Yes. Lovable's terms allow commercial use. You build the project in your workspace, deliver it to the client via GitHub or workspace transfer, and charge whatever your agreement specifies. Many agencies and freelancers use Lovable for client work.
What if I can't fix this myself?
If you need help scoping a client project, building complex features, or handling the handoff, RapidDev's engineers work as an extension of your team. They have delivered 600+ client projects on Lovable and can handle the technical heavy lifting.
Talk to an Expert
Our team has built 600+ apps. Get personalized help with your issue.
Book a free consultation