This post is about the use case where it isn't.

What Claude's Publish does well

Credit where it's due: Publish solves the basic sharing problem cleanly. You built something — a calculator, a dashboard, a landing page, a little game — and you want someone to see it. Click Publish, copy the link, send it. Done.

Recipients can view it, fork it into their own Claude conversation, and you can embed it on another site. If you just want to show someone a thing you made, this is the right tool and you should use it.

Where it runs out of road

Publishing is broadcasting. You put it out there, and then... you wait. Maybe someone texts you "looks good." Maybe someone says "the button thing is weird" and you spend ten minutes figuring out which button, on which screen, in which browser.

Three things Publish doesn't do:

1. You don't know if anyone looked at it. No view count, no analytics, no read receipts. You send the link and hope.

2. There's no way to leave feedback on the page itself. The person looking at your artifact has to switch to a different channel — Slack, text, email — and describe what they're reacting to in words. "The thing on the left, no the other left, the blue one, wait is yours blue? Mine's grey." Every prototype review in history has had this conversation. Publishing the artifact doesn't fix it.

3. Feedback doesn't connect back to Claude. Someone tells you "make the hero bigger." You open Claude, retype what they said from memory, and hope you captured it right. The feedback lives in a text thread. The fix happens in Claude. There's a human copy-paste step in between, and that step loses context every time.

The version where feedback is built into the link

This is the part where I talk about dot., because I built it for exactly this gap. Full disclosure: I'm the founder, and everything below is the product working as designed — not a hypothetical.

The flow:

You build something in Claude. A landing page, a prototype, a dashboard, whatever. Then you say "share this with dot." The MCP connector gives you a live, hosted link — same as Publish, except the link has a feedback layer on it.

You send the link to anyone. They open it in a browser. No Claude account, no dot. account, no extension, no signup. They see the live artifact exactly as Publish would show it.

They click anywhere on the page to leave a comment. Directly on the element they're reacting to. Not in Slack, not in a text thread, not in a Google Doc with arrows drawn in red. On the thing itself. A pin drops where they clicked, and their comment is anchored to that spot.

Every comment carries context. A snapshot of exactly what they were looking at — the button, the card, the section — plus their browser, OS, and screen size. So "this looks broken on mobile" arrives with a screenshot of the broken thing and the device it was broken on.

Then the part nothing else does. Back in Claude, you say "pull my dot. feedback and fix what reviewers flagged." Claude reads every pinned comment — with the element snapshot and environment context — and regenerates the artifact with the fixes applied. The person who said "make the hero bigger" just talked directly to the AI that built it, without either of them knowing the other existed.

What about Team and Enterprise plans?

Worth mentioning: Claude Team and Enterprise accounts can't publish artifacts publicly at all. The Publish button creates an internal-only link visible within your organization. If you need someone outside your org — a client, a stakeholder, a freelancer — to see the artifact, Publish doesn't work.

dot. doesn't have that restriction. The review link works for anyone, on any plan, inside or outside your organization.

What about the other sharing tools?

There's a growing list of tools for hosting Claude artifacts — Stacktree, Shareable, ShareDuo, and others. They solve real problems: private hosting, password protection, analytics, custom domains. If you need those, they're good options.

What they have in common: they're all variations on "host the artifact somewhere and give people a link." The thing people do after they open the link — react to it, point at specific parts, tell you what to change — is outside their scope.

dot. is the only one where the link itself is commentable, and the only one where those comments flow back into Claude as structured input it can act on.

The short version

Claude's Publish button: share a link, hope for the best.

dot.: share a link, people pin feedback on the live page, you pull it back into Claude and fix everything in one prompt.

Same artifact. Different outcome.

Built something in Claude? dot. gives it a link where anyone can leave feedback — pinned on the page, with full context, no account needed. Then Claude fixes what they flagged. Try it free →

If you used Markup.io before 2025, you probably liked it. Paste a URL, share a link, clients click to leave comments. Simple, effective, reasonably priced. No complaints.

Then two things happened: the free plan disappeared, and Pro jumped from $29 to $79 a month. That's a 172% increase, which is the kind of math that makes you check whether you accidentally upgraded to something you didn't ask for.

For a lot of freelancers, small agencies, and solo designers, that pricing change turned a no-brainer into a line item that costs more than their hosting, email, and project management tools combined. So people started looking for alternatives.

This is one of them.

What Markup.io got right

Credit where it's due: Markup.io nailed the core interaction. Paste a URL, get a shareable canvas, click to comment. No browser extension, no client onboarding, no account for reviewers. That pattern — "just send them a link and let them click on the page" — is genuinely the right way to collect visual feedback. The rest of the industry spent years overcomplicating it.

The problem was never the product. The problem is that $79 a month is a lot of money for clicking on a website and typing "make this bigger."

What dot. does differently

dot. starts from the same idea — paste a URL, get a shareable link, reviewers click anywhere to pin a comment, no account for them — but 2it diverges in a few places that matter.

It costs $12 a month

Individual plan, unlimited projects, unlimited feedback. Reviewers are always free and never need an account. There's a genuine free tier with one project and feedback on three screens, no credit card, no 72-hour window, no expiration.

For context: Markup.io at $79, Pastel's Studio plan at $119, and Marker.io starting at $59 all charge more for roughly the same core feature. Ruttl charges per user, which means the bill scales every time you add a teammate or a client who needs access.

dot. charges the person who owns the projects. Everyone else — the reviewers, the clients, the stakeholders — uses it free, forever. That's not a trial limitation; it's the model.

Every comment carries context

When someone leaves feedback on dot., the comment comes with a snapshot of exactly what they were looking at — the button, the card, the section — plus their browser, OS, screen size, and device pixel ratio.

So "this looks broken on mobile" arrives with a screenshot of the broken thing and the exact device it was broken on. No follow-up email asking "what browser are you on?" No twenty-minute Slack thread triangulating which page, which section, which viewport. The comment is the bug report.

It works on AI-built prototypes, not just live sites

This is where dot. and Markup.io stop being comparable. Markup.io reviews live websites. dot. reviews those too — but it also hosts prototypes built in Claude, Lovable, v0, or Cursor and gives them a live, shareable URL without a deploy step.

If your workflow involves building something in an AI tool and showing it to a client before it has a domain, Markup.io assumes you've already deployed it somewhere. dot. is the deployment and the feedback layer. One step instead of two.

Feedback flows back into your AI

This is the part nothing else does. dot. connects to AI tools through MCP, which means a reviewer's pinned comments can travel back into the tool that built the project. Tell Claude to pull your dot. feedback and fix what reviewers flagged, and it reads each comment — with the element snapshot and environment context — and regenerates the build.

Client says "make the hero bigger." Claude makes the hero bigger. No copy-pasting feedback into a chat window, no translating a screenshot into instructions. The comment becomes the fix.

The honest limitations

dot. is younger than Markup.io and doesn't have everything the older tool built over years. Specifically:

• No Jira, Trello, Asana, or Slack integrations yet. If your workflow depends on feedback auto-creating tickets in a PM tool, dot. doesn't do that today. You'd export manually.

• No PDF or image annotation. dot. reviews live web pages and hosted prototypes. If you review static files, that's a different tool.

• Simpler permissions model. Markup.io has team roles, workspaces, and granular access. dot. has owner, team members, and everyone-else-is-a-reviewer. For a 2-person agency that's plenty; for a 40-person department it might not be.

If any of those are dealbreakers, they're dealbreakers. Better to know now than after you've migrated.

When dot. is the right move

You're a designer, product manager, or even developer. You review work with clients. You've been on Markup.io's free plan or the old $29 Pro and the jump to $79 made you blink. You want the same paste-a-URL, click-to-comment simplicity without the per-seat math and without the price that assumes you have an enterprise budget.

Or you build with AI tools and need the whole loop: build it, host it, collect feedback, fix it — without stitching four products together.

Either way, $12 a month. Reviewers free. No 72-hour window. No expiration.

Switching from Markup.io, or just starting fresh? dot. gives you a link where anyone can pin feedback on the live page — no account, no install, $12/mo flat. Get started free →

It even has commenting built in. Which raises a reasonable question: do you need anything else to collect feedback? Sometimes no. Sometimes yes. Let's go through it without anyone getting hurt.

How commenting works in Lovable

Pretty nicely, actually. Guest comments are on by default, so anyone with your preview link can leave a note without making a Lovable account, a small mercy, given that the average human now maintains roughly 4,000 logins. Comments land, the owner gets notified, the team replies from the editor. For a quick round of "hey does this look okay," it's about as frictionless as it gets.

That's Lovable's whole personality: build, publish, share, all in one place. When your work lives entirely inside Lovable, its built-in comments fit like they were supposed to. Because they were.

Where a dedicated feedback layer sneaks in

A few situations wander just outside what built-in preview comments are built for. These aren't Lovable's failings, every feature has an edge, and this is simply where this one ends. No villains in this story.

When feedback needs to outlive a week

Lovable's preview links are temporary, they expire after about seven days, and the comments clock out with them. Great for a quick look. Less great if your review cycle has the lifespan of an actual project, which tends to be "longer than a week and full of people who reply on day nine." dot. links don't expire. They just... stay. Like a good houseplant.

When the thing you're reviewing is already published

In Lovable, comments live on the preview. Publishing is a separate step that ships your app to its permanent URL. So the moment your work is live on your real domain — frequently the exact moment you want a client or stakeholder to bless it, you've left the comment-able preview behind. dot. works on any live URL, so the version people are actually staring at is the version they can mark up.

When you build in more than one tool

Many teams use Lovable and Claude and v0 and something a developer hand-wrote at 2 a.m. Built-in comments live inside the tool that made them, so feedback scatters across platforms like socks across a dryer. dot. sits on top of all of them, one dashboard, every project, including the Lovable builds you've pushed live.

When a comment needs to bring context

dot. clips a snapshot of exactly what the reviewer was looking at onto every comment, plus their browser, OS, and screen size. So "this looks broken on my end" arrives with evidence instead of vibes, and you can see their end without launching a forensic investigation.

The part that connects to how you build

One more thing, specific to AI-built projects, and honestly the fun part. dot. plugs into AI tools through MCP, which means feedback can travel back into whatever built the project. Tell Claude to pull your dot. feedback and fix what reviewers flagged, and it reads each pinned comment, snapshot and context and all, then regenerates the build with the changes made. Your reviewers, essentially, talking directly to the robot. Everyone's polite about it.

Lovable has its own version of this loop inside its agent, and it's good at it for Lovable projects. dot. just spreads the same trick across whatever tools you happen to use.

So which should you use?

Plot twist: usually both.

Use Lovable's built-in comments when you're building in Lovable, sharing a quick preview, and everyone's looking at that preview this week. Fastest path, already there, zero setup.

Reach for dot. when feedback needs to outlast a seven-day link, when the work's gone live on a real domain, when you're building across several tools and want one tidy pile instead of six messy ones, or when you want comments that carry context and boomerang back into your AI as fixes.

Lovable takes you from idea to live app at a speed that feels vaguely illegal. dot. makes sure the feedback on that app, wherever it ends up living, is easy to collect, keeps its context, and turns into actual changes. Two tools, same team. No rivalry, no dramatic music.

Building in Lovable, Claude, v0, or somewhere else entirely? dot. gives you a link where anyone can pin feedback - no account, no expiration, no forensic investigation. Get started free