Long-form pieces by miinideck — browse by role, format, the controls, or your industry.
Every piece, newest first.
You sent a Claude Slides deck with 'anyone with the link' and your client got a sign-up screen. Why that happens, what Docs, Slides and Design actually export, and how to get the work in front of someone who will never make a Claude account.
You sent a client the public link to a Claude Code artifact and asked them to mark up what to change. There's nowhere to comment. That's by design. Here's the rule, which plans it leaves without a comment option for outside viewers, and how to collect pinned notes anyway. Checked against Anthropic's docs on 15 September 2026.
Hit a ChatGPT Sites usage limit? Your Sites aren't gone. Here's how to tell the ones that are just pages, which travel, from the ones that need Sites underneath them.
Client-side encryption tools turn your page into an encrypted file, so the protection and the artifact are the same object — every edit means re-running the tool and re-uploading. What that actually costs, the salt setting that decides whether your old share links survive, and when a hosted password is the better trade.
Running the studio out of one folder per client is a good structure for making the work. It stops at the point where the client has to open it — a private repo needs a GitHub account, and Pages built from one is public by default. What the handover step actually needs, and how to add it without breaking the folder.
A .json Lottie is not a page — hand it to a client and they get a wall of numbers. What it takes to turn one into something that opens in any browser, and why the answer is smaller than the tooling suggests.
The attachment tells you nothing after it leaves. A link tells you it was opened, when, and for how long — which is most of what you wanted and less than people assume. What the number actually means, and where it stops being evidence.
"Client portal" is one word covering two very different jobs. One of them needs software with logins and permissions. The other one is four links in an email, and buying the first when you needed the second is how a solo practice ends up administering a system nobody logs into.
The prototype took an afternoon. Getting it in front of the person who has to say yes takes longer — because a repo-and-deploy is too much ceremony, an attachment opens as code, and a platform link drags your reader onto the platform. What the handoff actually needs.
You have one finished case study but the portfolio site isn't live yet. Here's how to send that single piece as a private link — without pushing a half-built site or flattening it into a doc.
You need one page live for a webinar, a resource hub, or a campaign — not a whole website. Here's how to stand up that page from a single HTML file: a private, no-index link in seconds, with expiry, custom domain, and an honest line on where registration capture belongs.
There's a third option between a free public download and a locked paywall: let people earn the freebie by engaging — a comment, a reply, a DM keyword. A private, unguessable link is the delivery layer that makes the engagement-gate work without an account wall or a public file.
Freebies, drafts, little tools — as a creator you keep needing a link that reaches specific people and nowhere else. A working guide to private share links for the three things creators send most.
Your freebie is the first thing a stranger ever taps in your bio — and a raw storage or design-tool URL gives you away before the page loads. Why a link-in-bio freebie should ride on a branded, own-domain link, and how to do it with no website and no server.
An AI tool writes you a working mini-tool — a calculator, a quiz, an estimator — from one prompt. Put it on a private link you control and it becomes a stronger lead magnet than any PDF, because people use it instead of just downloading it. Here's the conversion loop, and where the browser ends and a backend begins.
The comment-to-DM play, end to end. You reply with a freebie, move the conversation to a DM, and let one private hosted link carry the handoff. Here's the motion step by step — what to say, where the link goes, and why a private hosted page beats an attachment or a public deploy.
The permission prompt arrives mid-session and the honest answer is: by default, only you. What publishing actually does, when a link becomes public, and where Anthropic's own pages disagree — on which plans have it, and on whether a public link needs a Claude sign-in. Checked against their docs on 12 September 2026, sign-in rechecked 19 September 2026.
Bolt.new previews live behind a session URL that changes and can lapse. How to pull a static export — one HTML file or a built dist folder — out of Bolt and turn it into one stable, private link.
The page runs perfectly from your desktop, then one button stops working on the hosted version — usually fullscreen, copy-to-clipboard, or a fetch. Four causes, each with a one-line test you can run in the browser console to tell them apart.
Your Slidev or reveal.js deck is already a self-contained web app. Skip the public deploy, the screenshot, and the PDF flattening: run the build, zip the dist folder, and turn it into one private link that keeps every fragment, transition, and code highlight stepping exactly as it did locally.
v0 and Lovable build React/Next projects, not single files — so "export" means a folder or a public deploy, neither of which is a quiet private link. Here's how to get a clean build and share the static slice privately.
You open your host's protection settings and get an upgrade screen instead. The question isn't how to add a password — it's whose free plan has that switch, what the switch actually locks, and when paying for it beats moving.
A Replit webview link dies when the repl sleeps. If your build is static, you can lift the output out of the container and serve it from a link that never spins down. Here is the export path — and the honest line where it stops applying.
You ran ng build and now someone needs to open it — QA, a client, a stakeholder — before the real deployment gets scheduled. What to upload, what happens to relative asset paths, and the one honest limit: a refresh on an in-app route returns 404 unless you switch to hash routing.
A static page can post form submissions into a Sheet you already own, using a Google Apps Script web app as the endpoint. The fourth shape most 'form without a backend' guides leave out — how it works, the two settings that trip everyone up, and when a form service is still the better call.
You built a one-page site someone paid you for, and you are about to put it on a free plan. The question is not whether the free plan can handle it — it is whether the host's own terms permit it. Two different walls, and only one of them shows up as a bill.
Cursor builds projects as folders of linked files, not one shareable artifact. Three reliable ways to collapse a Cursor build into a single self-contained HTML you can drop on a private link — and the one case where you deploy instead.
How analysts, freelancers, and agencies hand AI-built client work over as a private, branded link instead of a raw chat export — so the work reads as a finished decision, not a transcript of the model making it.
Every free tier has a wall somewhere. On a private-link host the wall is not storage — it is time, and how many links you are allowed to keep. Here is exactly where each limit sits, what happens on day 8, and the three situations where free genuinely never runs out.
An agent writes a report, tells you the file path, and hours later the download button does nothing. The output was living on the computer that made it, and that computer was designed to disappear. Why this failure is structural rather than a bug, and what to do at the moment the work is finished.
A scheduled self-destruct retires a shared link on a date you set at upload — no reminder, no manual deletion. Here's why scheduling beats deleting by hand, how to pick the date, and what the viewer sees when the link retires.
A static page has no backend and no secrets, which sounds like it rules out forms, payments and bookings. It doesn't. The line isn't 'frontend versus backend' — it's whether the credential you'd have to publish is designed to be published. How to tell, in one question, before you build.
The person who needs your dashboard usually has no seat in your BI tool — and buying one is the wrong fix. How to ship a live, interactive dashboard to a no-login viewer, and where a live connection beats a snapshot.
Every list of free HTML hosts assumes you'll sign up. If you won't, the field narrows to a handful — and each one charges you for it in a different currency. Which hosts genuinely need no account, what you give up, and when signing up is the cheaper trade.
When the page is a folder rather than one file, the hosting question changes and so do the ways it breaks. Which free hosts take a ZIP, what happens to your folder structure once they unpack it, and the four failure modes that account for almost every broken zipped site.
Your AI built a working calculator. It runs in the chat preview and nowhere else. Here is how to get that interactive tool onto a real shareable link without touching a deploy command.
Skip the review call. Send the prototype as a private link, let people pin comments to the exact element with no account, and read every note in one place — async, on their schedule and yours.
Codex can now share a thread as a read-only link. It shows someone how the work was reasoned — not the working thing it produced, and not a copy that keeps up with you. Here is exactly what the snapshot carries, the four boundaries the announcement doesn't spell out, and how to tell which of the two jobs you're actually doing.
The AI tool built the page. Sending it to a client is a second job: stripping the construction site, making it read as yours, and putting it behind a private link. A practical checklist for turning AI output into a client-ready handoff.
A self-contained HTML file means the images travel inside it, not as links. The prompt wording that makes an AI base64-encode assets on the first pass — plus the size budget, what to inline, and what to leave alone.
Most AI-built HTML looks right on screen and breaks the moment someone hits Ctrl+P. The exact prompt clauses, CSS hooks, and a ninety-second verification pass that make a page export to PDF cleanly the first time.
Claude Code wrote the file. Now a teammate or a client has to see it working — and the obvious options each solve a different half of that. An honest split across GitHub Pages, Notion, paste-style hosts, an internal server, plain email, and a private link, judged against the five things people actually ask for.
A multi-page site usually means a router and a server. Prompt patterns that give you real pages — Home, Pricing, About — inside one self-contained file or one ZIP you can drop at a private link.
AI builders optimize for the preview — and a screen reader, a keyboard, and a contrast check are exactly what a preview can't show. Four things AI drops unless you ask, the prompt block that puts them back, and a three-minute check.
Desktop preview says the page is fine. The phone disagrees, and you find out after the client already has the link. Here's the loop that catches it first — and the part of the problem no host can fix for you.
AI gives you a dark mode that flashes white, forgets the toggle, and hardcodes one shade of gray everywhere. The token-first prompt that makes theming survive in a single self-contained HTML file.
A chart or dashboard is the AI output most likely to break on delivery — it fails in two invisible ways at once: the library 404s and the data loads from nowhere. Five prompt patterns that produce one interactive file that renders anywhere.
Sending a file attaches a frozen copy to an inbox; sending a link hands over a URL you still control. The three places that gap shows up — size ceilings, what actually renders, and who holds the deliverable after it lands.
The Gemini share button fails and the error tells you nothing. Usually it isn't a bug and it isn't your file — public link sharing is off by default on work and school accounts, and the switch is one only an admin can flip. Here's how to tell, and what to do when you can't wait for them.
A Loom or screenshot shows the reviewer your build. A live private link lets them click through it themselves. Here's exactly what each format loses in transit — and when a recording is still the right call.
Static hosts are metered on the assumption a human edits a few times a day. An agent doesn't work that way. Which hosts count builds, which count deployments, which count nothing — and where the bill actually comes from.
A sandbox preview link is bound to a live session and a project you keep open. A private link is a finished artifact. Here's exactly when the preview stops being the right thing to send — and what to send instead.
Cloudflare Pages is a public, global CDN site — built to be found and to scale. A private link is built to reach a named audience and nobody else. They solve opposite halves of "I made a page, now what." Here's the honest fit for each, where the backend boundary sits, and how to pick in one question.
Ask an AI assistant how to share a page privately and it will usually warn you that an unguessable URL is not real privacy. Half of that warning is correct. This is the half that isn't, the threats a random link genuinely does not cover, and the point where you should stop and put a login in front of it instead.
Replacing a page you have already handed someone is a different problem from publishing it the first time. Why the usual answer is 'learn git', who that answer is actually for, and what the other routes really cost.
Send the raw file and they see asterisks. Export to PDF and you lose easy revisions. The third option — and how to pick between the three by what the document has to do next.
GitHub Pages publishes a public, git-tracked site to the open web. A private unguessable link delivers a self-contained page to specific people. Here is the honest split — by who reaches it, what the URL is for, and where the work lives — so you pick the right one instead of bending one to fit.
New uploads have ended and the site runs only until the last existing page hits its expiry. PageDrop bundled three things most hosts split up — instant account-free publishing, expiry as a feature, and a public gallery. Here is which alternative covers which, compared side by side, and how to get your file back first.
A disabled Publish button isn't one bug — it's four different situations wearing the same grey. Two of them are permanent, two clear in a minute. Here's how to tell which one you're looking at, and how to get the page to the person waiting for it either way.
Every lever a private link gives you — expiry, password, searchable opt-in, custom domain, white-label, analytics — what each one is for, and which are free versus paid.
Prompt patterns that get Claude, ChatGPT, v0, Lovable, and Cursor to ship self-contained, lightweight, interactive HTML you can actually send as a link.
Everything between a file and a link someone can open — making HTML self-contained, sizing it, viewing it online, choosing it over PDF, and sending it to one person.
From a Claude artifact to a vibe-coded app to a multi-file Codex bundle — how to share what an AI tool builds, as a private link, without a deploy pipeline.
Designers, freelancers, agencies, consultants, in-house teams, and educators all hit the same wall — handing a finished HTML deliverable to the people who should see it. How the channel choice changes by role.
Two things people say about unlisted links are both half right. Whether a page gets indexed has almost nothing to do with how secret the address is — it comes down to two questions you can check yourself in about a minute.
HTML has quietly become a document teams work on together — reports, decks, small tools. But a link is a reading surface, and the thing your colleague's AI needs to open is the source. Where each one lives, and why collapsing them causes the mess.
AI builders often export an app as a folder — index.html plus separate CSS, JS, and assets — not a single file. How to share the whole thing as one private link without flattening it or deploying it.
A private link and a public deploy are the two ends of one dial: how findable the page should be. A job-by-job map of where each endpoint fits, plus the in-between cases most real work actually lands in.
Opening an HTML file and publishing one are different decisions, and most tools quietly make the second for you. The fork between a public address and an unguessable one — what each is for, and how to tell which the file in front of you needs.
You already have the finished HTML page. Putting your own domain on it is one DNS record and one upload — not a rebuild inside a website builder's editor. The walkthrough, and the one case where you need Vercel or Netlify instead.
You built an app in Bolt, v0, Replit, Lovable, or Claude and it works — but it only works on your machine, and the deploy pipeline is a bigger commitment than the question you're trying to answer. What fits the in-between moment: a live link in seconds, and you decide who opens it.
The tutorial worked for the person who wrote it. It does nothing on a static host, because .htaccess is an Apache file and a static host doesn't hand you an Apache to configure. What the file is actually doing up there, what to delete today, and what to use instead.
SharePoint is getting the ability to render uploaded HTML as a page. Before you route client deliverables through it: custom script is blocked by default and resets to blocked after 24 hours, and letting someone outside the tenant open it is a separate decision your admin owns.
A shared link tells you more than that it was delivered — it tells you when someone opened it. Here is how a view timestamp on a private link turns client, sales, and creator follow-up from guesswork into timing.
The wedding site lives for six months around the date and shouldn't outlive the thank-you notes. A setup pattern that handles the lifecycle without leaving a $14/mo subscription running into next year.
A lead magnet on a link that self-destructs in days is a slow leak in your funnel. Why marketers and coaches need a never-expire private link, and how one URL turns a freebie into an evergreen, semi-private channel from comment to DM.
The message is about Anthropic's side, not yours, and it usually clears on its own. The risk isn't the outage — it's what people press while waiting. Here's the safe order of operations, and how to get the work out of the artifact while you wait.
You built a page with an AI tool. Three places it can live — the builder's own share URL, a public deploy, or a private link — and a clear way to decide between them based on whether the page has a backend and who is supposed to reach it.
You built something in Claude, came back weeks later, and it's gone. Usually it isn't deleted — it's sitting inside a conversation you can no longer find. Here's how to get it back, and the one case where it really is unrecoverable.
Artifacts handle more than people expect right up until they don't. The four limits that actually stop projects — no backend, storage that only exists after publishing, an irreversible unpublish, and the settings toggle — and what to do at each one.
Artifacts stop appearing and every guide says the same four generic fixes. Here's the order that actually separates a setting on your side from an outage on theirs — starting with the one documented cause that produces total failure.
Materials trapped in the LMS disappear when the semester ends. The static HTML + private link shape lets a lesson live where the educator chooses, not where the institution provides.
The artifact works in the chat, publishing succeeds, and the link opens to nothing. Three different failures produce that same white screen, and one thirty-second check tells you which one you have.
3D renders flattened to PNG. Floor plans frozen in PDF. Section toggles lost in screen recording. The HTML preview shape that keeps the interactivity alive for client review.
Every cloud drive gives you two ways to share the same file, and they work on completely different principles. One grants a person access; the other grants a URL access. Knowing which is which decides who can still open your file in a year.
Automating the publish step is easy on the first run. The decision appears on the second: mint a fresh URL, or replace the contents at the old one. One of those quietly rots every link you've already sent, and nothing warns you.
The iframe snippet works on your laptop because the PDF is sitting next to the HTML. The moment the page travels, it's two files — and only one of them arrives. What actually survives the trip.
It looked like a URL. You sent it. Most of the time it never existed — but one of these is the opposite case: <private_url> means an address was there and got redacted. How to tell which one you have, in one second, and what each one actually needs.
Instant hosts trade takedown for tamper-proofing — and most people meet that trade at the worst possible moment. What immutable actually means, why support usually can't help, and the three questions worth asking before you press publish.
The agent handed you a URL and said it's live. It probably is. What it didn't tell you is who can open it, how long it lasts, whether the address is guessable, and what happens to it when you revise — four defaults chosen for you, none of them announced.
Yes — on the consumer product a Grok share link is public, and xAI says a publicly shared link may be indexed by a search engine. On Grok Business it works close to the opposite. Here's what the recipient gets, and how to send the finished result without the whole chat.
The attachment arrived, nothing was blocked, and your recipient sees markup instead of the page. That's three different email failures people keep merging into one. Here's which one you hit, and why the fix isn't a different attachment.
Upload an .html file to Drive, open it, and you get a wall of markup instead of the page. Nothing is broken — Drive is doing exactly what a filing cabinet does. Here's the mechanism, the workarounds people try, and what actually renders it.
Email providers cap attachments around 20-25MB. The fix when the file is bigger isn't to compress harder — it's to send the URL instead.
Nothing happened when you asked Claude to publish. There are four separate things it could mean, they look identical from the chat window, and each has a different fix. Here's how to tell them apart in order.
The page is fine. Your computer is fine. What differs is that a desktop knows what to do with an HTML file and a phone mostly doesn't — so the fix depends on whether you sent a file or an address. Here's how to tell which you sent.
Free hosting comes in two shapes, and they fail in opposite directions. Here's what actually happens when a free quota runs out, what expiry does and doesn't destroy, and how to match the shape to what you're sharing — including where we're the wrong answer.
A training or coaching program delivered as a file works on day one and degrades from there — pinch-zooming on a phone, a client on last month's version, no way to fix a typo. Here's what changes when the program lives at a link instead.
Recurring reports break in a way one-off deliverables don't: every send produces another address, and the old ones keep working with old numbers in them. Here's the version where the report has one address for the whole engagement.
You send a delivery link, the reply is 'blocked by our security policy.' Nothing is wrong with your file. Here's what actually inspects a link between you and them, why unfamiliar domains lose that inspection, and what you can do from your side.
Comment threads normally require identity, and for good reason — a note has to belong to someone. Here's how a review works when the reviewer signs into nothing, what that costs, and when the trade is the right one.
The writing got fast. The handover didn't. Here's why the last step of client work — getting the finished thing in front of the client — quietly became the slow part, and what a good version of it looks like.
Website annotation tools start by asking where the page lives — a reasonable assumption that quietly excludes the most common case in 2026: an HTML file your AI just made, sitting in your downloads folder, due in front of a client this afternoon.
The banner zip is correct for trafficking and wrong for approval. Here's why the review round is where ad creative loses time, and how to let the reviewer just watch the thing run.
AI builders ship beautiful forms with no idea where the submissions go. Three shapes that actually work — mailto, third-party embed, serverless route — and the prompts that make each one ship cleanly.
Anthropic's docs are explicit: on Free, Pro and Max, publishing makes an artifact publicly available to anyone with the link. Org-only sharing is a Team and Enterprise feature. Here's what that means if you're an individual sending work to one named client.
A view count is a useful signal and a bad witness. Here's exactly what one view is, what it can't distinguish, and how to read the number without inventing a story it doesn't support.
Cloudflare's changelog gives it straight: the no-account preview stays live for one hour unless you claim it into an account. That's not a catch, it's the design — and it draws a line worth seeing, because a preview and a delivery are different objects.
ChatGPT Sites can now invite a named viewer from outside your workspace — but they have to sign in with the account you invited. If your client won't, here's the shape of what's left and the route round it.
Everyone wants /pitch instead of a 32-character string. The catch isn't policy, it's arithmetic: a URL short enough to say out loud is short enough to guess. Here's the trade, where the middle ground sits, and why a custom short link only makes sense once you've decided a document should be public anyway.
Board members read the QBR on their phones over the weekend, then re-reference specific sections weeks later when drafting IC memos. The container shapes both halves of that cycle.
Sharing a chat creates a snapshot anyone with the link can open. Unsharing disables that link. Neither of those is the same as 'not indexable', and the difference caught a lot of careful people in July 2026. Here's the mechanism, where to check your own shares, and when you need noindex to be a property of the link itself.
The steps take about ten seconds. The cost is less obvious: unpublishing permanently retires that artifact's ability to be published, and deletes its stored data. Here's how to do it, what it takes with it, and what to reach for when access only needs to end for now.
The normal delivery ritual is finish, then send — and every revision mints a new URL and another 'ignore my last email'. If your AI tool can publish and then update in place, the link can go out first and stay correct. Including when that's a bad idea.
Claude refuses to share your artifact and suggests publishing a new version — which often doesn't clear it. Here's the diagnosis that actually separates the two failures behind that message, and the export route that doesn't depend on the toggle working.
UXR deliverables get read on phones by executives and re-read by PMs months later. The HTML report shape handles both — interactive video clips, hover transcripts, NDA-bound delivery — better than the slide deck it usually ships as.
Printing a QR code fixes the URL forever. It doesn't have to fix the content. The difference is entirely in what you point the code at — and it's the one decision to get right before the print run.
A SCORM package isn't a course you can open — it's a course wrapped for a machine. Here's what that wrapper buys you, what it costs, and when a plain web link is the honest artefact to hand someone.
Genially's HTML download keeps the interactivity a PDF export throws away — but it lands as a ZIP with an entry file that isn't index.html, and it needs a paid plan. Here's the honest shape of that export.
They solve the same problem — getting someone from the physical world to a URL — in ways that fail differently. The deciding question isn't which is more modern; it's whether the person can point a camera at it.
The course is published. The SME reviewing it has no LMS, no seat in your authoring tool, and no interest in unzipping anything. Here's the delivery shape that fits — and the one thing it deliberately gives up.
Lumi exports H5P content to a single standalone HTML file that runs in any browser. Two caveats decide whether that works for you — some content types won't export at all, and media gets inlined, which inflates the file fast.
The first-time receiver's walkthrough. Six moments from email arrival to tab close — what they see, what they don't see, and why each detail is built that way.
You want to send a deck as a link, not a .pptx attachment. For most decks the middle step is now one menu item — PowerPoint exports a PDF, and a PDF goes straight to a private link. When that is the right road, when HTML is, and what each one costs you.
Two ways to put a password on a static page without running a backend — client-side encryption you set up yourself, or a hosted gate you don't. What each actually protects, and which fits a page you're handing to one person.
Sending a client a finished page? A Drive link hands them a file in a filing cabinet to download or preview flattened. A private link hands them the thing itself, already open. The three places the two diverge: rendering, control, and who the link assumes the reader is.
WeTransfer is a courier: it drops the file and leaves, and the link self-destructs. A private link is a room that stays open. Which fits depends on whether you're moving a file or showing a finished page — and on how big it is.
A ZIP is a moving box: the recipient has to unpack it, find the entry file, and hope their mail provider didn't strip it. A hosted link is the room already set up. When a multi-file build should travel as a link instead of an attachment.
Private doesn't mean one recipient. Same URL to a five-person review committee, with basic analytics that still tell you who's engaged and who's not.
Most expiry windows get set by guess — 7 days because that's the default, 'never' because that's reversible. The actual fit comes from matching the window to what the content references.
Not to a public link — on any plan. On Pro and Max, a connector-backed artifact can't be shared at all. Here's the mechanism that makes that rule inevitable, and what to do once you know which page you're actually building.
Two architectures live under the same 'password protected' label. One is a real gate; the other is a UI prompt the receiver can click past in 30 seconds with DevTools open.
AI builders default to heavy: full framework bundles, web fonts, icon libraries, generous markup. Prompts that ship lean from the start, plus the trim pass for what slipped through.
The view count is the headline. The actual signal lives in the pattern — re-opens, time gaps, distinct devices. What each shape usually means in context.
The default expired-link page is generic and reads as the host's brand. Studio plans let the page read as the studio's own — what changes, when it matters.
Private-link hosts default to noindex; that's the product. The exception — a portfolio page, a public case study, a launch microsite — fits as per-document opt-in, not as a different account.
PageDrop vs miinideck, compared by design: one was built for links that expire on purpose, the other for links that need to last. What each was for, where they genuinely overlap, and where the disposable-page job goes now that PageDrop is winding down.
A personal site updates twice a year. CMS subscriptions and full deploy pipelines are sized for sites that update twice a week. The middle ground: one HTML file at your own domain.
Wedding RSVPs, conference landing pages, launch event sites — built for a window, awkward to leave online afterward. Channel options for a microsite that retires cleanly.
The iteration loop with Claude / Cursor / Lovable produces a new version every round. Channels that let each round travel cleanly — without exposing the chat, the previous version, or the next reviewer to noise.
Three paths to turn a multi-asset HTML page into a single self-contained file: a build-tool step, an LLM prompt, or a manual pass with DevTools. When each one fits.
A step-by-step: turn on Review for a private link, let anyone pin comments to the exact spot (no account), then export the thread as a prompt to paste into Claude or Codex.
You shared the AI-built page — then what? The real work is the loop: build, show, react, fold the reaction back into the next prompt. Why hosting is only step one, and what actually closes the loop.
"It asks me to log in." "It's blank." The link isn't broken — it was never built to leave the tool. What each AI tool actually hands you, and what opens.
Pointing a subdomain at a private-link host so the URL says your brand, not the vendor's. Steps, DNS gotchas, and when the apex vs subdomain choice matters.
VC partners read the deck on a phone, forward it to two more partners, re-open it three weeks later. The container choice decides what that cycle feels like.
Two tools that both turn a dragged file into a URL. One is designed for public deploy testing; the other for private one-recipient delivery. When each fits, where the overlap is real.
Vercel Drop turns a dragged file into a live production URL on a major platform. miinideck turns one into a private link for specific people. Both fit 'drag a file, get a URL' — and were built for opposite jobs. When each fits, where the overlap is narrow.
Vercel just shipped drag-a-file-get-a-link. With Netlify, tiiny, and others already here, sharing a built page as a live link is officially the new normal. Here's the whole landscape of tools — and how to pick one — if you're done emailing PDFs.
An AI tool builds the landing in fifteen minutes; deciding where it lives takes the next hour. Three hosting shapes and how to pick between them.
AI tools default to modular HTML — clean for development, fragile for one-file delivery. Cross-tool prompt templates that produce a single portable file from the first generation.
A short-lived link reads as a feature for one-off reviews and a bug for permanent references. The shape of the engagement decides which one the file needs.
AI-built pages default to clean, static, and slightly bland. Four animation patterns and the cross-tool prompt templates that bring them in — without dragging in a heavy library.
A Claude artifact looks self-contained inside the chat and often isn't. The five things that quietly stay external — CDN scripts, Tailwind, fonts, images, fetch calls — and how to inline each.
Twelve ways to put a single HTML file online for free — GitHub Pages, Netlify, Cloudflare, Vercel, Tiiny, Neocities, Static.app, EdgeOne, host-html, Linkyhost, Wasmer, and a private-link option — with an honest table of which fits which job, public or private.
There is no single number — it depends on the model, the image size, and whether you send a PDF as text or pixels. The per-model formulas, real measured costs, and how to count it for your own model.
Three formats people reach for by habit, built for three different jobs. A job-by-job map of when Markdown, HTML, or PDF is the right shape — and why they work best as a pipeline, not a choice.
Feeding a document to an AI? Markdown almost always costs fewer tokens and parses cleaner than the same content as a PDF. Where each format wins — and why the thing you hand a person at the end is neither.
PDF is built for archive and print. HTML is built for live, browser-native delivery. Where the three differences — interactivity, weight, single source of truth — actually decide which format ships.
A pricing proposal is read more like a website than a document. Channel options for sending one, and where private-link HTML sits between a PDF attachment and an esignature tool.
Figma is designed for collaboration, so the share link shows comments, version history, and the frames you parked. Channel options for a client-facing preview, and where private-link hosting fits.
The format you pick for an internal review is a category-signaling choice. When the team starts shipping HTML links instead of .pptx attachments, the room reads it before the content opens.
Sending a Claude or ChatGPT artifact to one client — how the channels compare, where private-link hosting fits, and the six clicks that get you there.
Interactive dashboards lose their interactivity in PDF, screenshot, and screen recording. The trade-off, and where private-link hosting fits between handoff and full deployment.
Five channels agencies use for client previews — and what each accidentally reveals about the work in progress. Where private-link delivery sits, and when it's worth the swap.
Two tools that both host an HTML file, designed for different jobs. When tiiny.host fits, when miinideck fits, and where the choice actually matters.
How analysts, consultants, and agency teams hand a finished HTML report to one named client — what each channel is built for, and where private-link hosting fits.
No card to try, no sign-up to get a link. Sign up free to keep links forever, password-protect them, and store more.