In your stack
Client comments on your Lovable app, turned into one prompt for the chat
There is no Writhink plugin for Lovable, and you do not need one. Your published Lovable app has a public URL, so you paste that URL into Writhink and send your client a review link. They pin comments on the real running page, and Writhink turns the whole pile into one prompt you paste into the Lovable chat.
No credit card. Your client doesn’t need an account.
01
Not an integration. A workflow.
Worth being precise about what this is, because the word integration gets thrown around loosely. Writhink does not install into Lovable, has no listing in any Lovable marketplace, and cannot push changes into your project. Lovable is not an MCP client either, so there is no server to connect and no connector to configure.
What links the two is a public URL going in and a block of text coming out. That is enough, because the plumbing was never the hard part. The hard part is getting a client to tell you precisely which element is wrong, at which width, on which page, in words a model can act on.
02
The round trip
- Step 1
Publish, then copy the URL
A published Lovable app has a public URL. Paste it into Writhink and you have a project. If the app is not published yet, or sits behind a login you built, skip to the table below and use the Chrome extension instead.
- Step 2
Send one link
Your client opens it and sees your app running, not a static screenshot. No account, no app to install, no signup. They give a display name and that is the entire onboarding.
- Step 3
They pin comments in place
They click the element that is wrong and type. Writhink records the position, the element anchor, the page URL, the viewport size, the device type and an automatic screenshot of the pinned spot. They can attach files, reply in a public thread, and edit or delete their own comments.
- Step 4
You generate the prompt
Writhink reads every comment, including the ones dashed off in three words, rewrites them clearly without inventing requests, merges duplicates, groups them by page and by element, keeps the screenshot URL attached to each item, and sets priorities.
- Step 5
Paste it into the Lovable chat
One message. It reads as a build brief rather than a transcript of complaints. If the list is long, send it in chunks: the grouping by page makes the cut points obvious, and smaller batches are easier to check afterwards.
- Step 6
Re-publish and send the same link back
The review link does not change. Your client reloads it, sees the new build, and either confirms or pins the next thing. Mark items resolved as you go, and any reply you post shows up in their thread on the same page.
03
The two Lovable addresses, and which one to review
Lovable hands you two ways to look at the same app and they behave nothing alike once someone else is doing the looking. Everything beyond this — a custom domain, a login you built, a local export, the choice between a review link, the Chrome extension and the embeddable widget — follows the general rule on /website-feedback-tool.
| Which address | How your client reviews it | What actually happens |
|---|---|---|
| The published app URL | Paste it into Writhink and share the review link | Publishing gives the app an address anyone can fetch, which is exactly what the Writhink proxy needs. Pins attach to real elements on the running app, and after you re-publish the same review link serves the new build — so a round of comments and the fix that answers it live at one address. |
| The editor preview | Chrome extension, on the preview open in your own tab | The preview inside the builder is your editing session, not a page a stranger can load, and it rebuilds under you while the model works. Review it in your own browser with the extension, or publish first and send a link. Comments land in the same project either way, and feed the same prompt. |
The extension is Chrome only: there is no Firefox, Safari, or Edge build. If a published page refuses to render through the proxy, the extension is the fallback, and the generated prompt does not care which route the comments came in through.
04
What the pasted prompt carries that a screenshot does not
Nothing here is wired together, so everything depends on the quality of the text you paste. That is what the generation step is for.
- The page and the element each request belongs to, so the model is not guessing which card you meant.
- The viewport size and the device type, which is how "it is broken on my phone" becomes a specific breakpoint.
- Duplicates merged. Three people asking for a bigger heading is one instruction, not three contradictory ones.
- Priorities, so the first paste is the pass that actually matters and the nitpicks wait.
- Ambiguous requests marked "(unclear — ask the client)" instead of being guessed at, with a closing instruction to draft those questions back to your client.
- The screenshot URL for each item. You can open it yourself; what a chat box does with a link is up to the tool on the other side.
05
Worth setting up, or not
This fits if
- You are building for someone else, and that someone else is the one who spots what is wrong.
- Feedback currently arrives as voice notes, cropped screenshots and "the spacing looks weird on the second page".
- You want one written brief to read before letting the model touch a working app.
- Reviews happen in rounds, and you keep losing track of which comments were already handled.
Skip it if
- You are the only person using the app. Just describe the change in the chat.
- You expect the fixes to be applied automatically. Nothing here writes to Lovable. You paste, you review, you publish.
- You need a Lovable plugin or a two-way sync. It does not exist here, and pretending otherwise would waste your afternoon.
- Your reviewers want tickets in Jira or Linear. There is no native integration with either — with anything, in fact.
06
Where this stops
The model on the other side is still Lovable's. Writhink makes the request precise; it cannot make the build correct. Re-publish, look at the result yourself, and let your client be the one who says it is done — on the same link they commented on.
Generation is a per-round move, not a per-comment one. Let the pins pile up through a review, generate once, paste once. Firing it off after every third comment hands the model a fragment of the picture and hands you three prompts to reconcile, which is how a client ends up seeing two half-applied rounds in the same build.
And nothing writes back. No plugin applies the changes, no sync closes an item when you re-publish. You mark things resolved yourself. It takes seconds, and it is the only reason your client's picture of what is done matches yours at the end of the round.
Before you count on it
Writhink is in open beta: everything described here is available and free, no credit card. Paid plans are announced but not purchasable yet. The one limit that applies today is five AI prompt generations a month per organization.
FAQ
Questions people actually ask
- Is there a Writhink plugin for Lovable?
- No. There is no plugin, no marketplace listing and no connector. A public URL goes into Writhink and a prompt comes out for you to paste. That is the whole surface, and it is deliberate rather than a roadmap item we are hiding.
- Does my client need a Lovable account?
- No, and they do not need a Writhink account either. They open the review link, give a display name, and start pinning comments. They can attach files and reply in the thread without signing up for anything.
- Can I collect feedback on a Lovable app before I publish it?
- The review link needs a page a proxy can load, so an unpublished preview inside the editor is out. Use the Chrome extension on the preview in your own browser instead. The comments land in the same project and feed the same prompt.
- What if Lovable changes more than I asked for?
- Keep each paste scoped to one page or one group. The prompt is already grouped by page, so the cut points are there. Then re-publish and check the result against the review link, where the original pins are still sitting on the elements they were about.
- Can an AI agent read the feedback directly instead of me pasting it?
- Yes, if the agent speaks MCP. Claude Code, Cursor and Claude Desktop can connect to the Writhink MCP server and read feedback, reply and change statuses on their own. Lovable is not an MCP client, so for Lovable specifically the pasted prompt is the route.
Start
Send one link. Get feedback you can build from.
Your clients comment right on the page — no account, no screenshots, no voice notes. Writhink sorts the comments and writes the prompt for your AI.