Publish with AI

AI makes beautiful HTML all day, and it usually has nowhere to live. Quickish is the home: connect it once, then just say “publish this to Quickish” and your page goes live, assets and all.

ChatGPT · Custom GPT

Requires ChatGPT Plus. Create a GPT with one action and OAuth, publish it, and you (and anyone you share it with) just sign in once with Quickish. No tokens to pass around.

  1. ChatGPT → Explore GPTs → Create → Configure.
  2. Name it Quickish Publisher. Paste these Instructions:
You are the Quickish publisher. You put web pages online instantly.

When the user shares content or asks you to publish it (e.g. "publish this to
Quickish", "make this a page/site/link"):
1. Produce ONE complete, self-contained index.html. Inline all CSS and
   JavaScript. Embed small images as data URIs; otherwise use absolute https
   URLs. Never reference local files.
2. Call publishToQuickish with that HTML as `html`. Use `page` only for a named
   sub-page, `invites` if they name specific people, or `share`
   (private/public/workspace) for visibility.
3. Reply with the live URL it returns as a clickable link.

Keep pages clean and mobile-friendly. Never make the user deal with hosting,
files, or assets. Just publish and hand back the link.
  1. Under Actions → Create new action, paste this schema:
{
  "openapi": "3.1.0",
  "info": { "title": "Quickish Publish", "version": "1.0.0" },
  "servers": [{ "url": "https://api.quickish.website" }],
  "paths": {
    "/_assistant/publish": {
      "post": {
        "operationId": "publishToQuickish",
        "summary": "Publish a self-contained HTML page and return its live URL.",
        "requestBody": {
          "required": true,
          "content": { "application/json": { "schema": {
            "type": "object",
            "required": ["html"],
            "properties": {
              "html":    { "type": "string", "description": "A complete self-contained HTML document." },
              "page":    { "type": "string", "description": "Optional sub-page name." },
              "share":   { "type": "string", "enum": ["private", "public", "workspace"] },
              "invites": { "type": "array", "items": { "type": "string" } }
            }
          } } }
        },
        "responses": { "200": { "description": "Published",
          "content": { "application/json": { "schema": {
            "type": "object", "properties": { "url": { "type": "string" } } } } } } }
      }
    }
  }
}
  1. Set Authentication to OAuth and enter:
    • Client ID: quickish-gpt
    • Client Secret: your QUICKISH_OAUTH_GPT_SECRET (from your Quickish deployment)
    • Authorization URL: https://quickish.website/oauth/authorize
    • Token URL: https://quickish.website/oauth/token
    • Scope: publish  |  Token Exchange Method: Default (POST)
  2. Save, then Publish the GPT (or keep it to yourself). Share the link with anyone.
  3. Open it, click Sign in with Quickish once, then say “publish this to Quickish” and it returns the live link. Everyone you share it with signs in with their own Quickish account.

Claude · Custom connector

Add Quickish as a connector and sign in once. Then publish from any chat.

  1. In Claude, open Settings → Connectors and choose Add custom connector.
  2. Set the URL to https://quickish.website/mcp and connect.
  3. Sign in with Quickish when prompted, then say “publish this to Quickish” in any conversation.
Build a real app, not just a page. The connector also gives Claude tools to read, seed, and write your page’s quick.db collections — so you can prototype a stateful app end to end: “build a sprint-retro board with live columns, seed three example cards, and publish it private.” Claude writes the HTML (using quick.db + quick.realtime + quick.identity()), seeds the data, and hands back a live URL.

Claude Code / agents can also publish with the quickish CLI; the publishing skill teaches the flow. Building your own agent or script? Mint a data token to read/write a page’s collections directly over HTTP.

Do it yourself

Ask an assistant that can run commands

Coding agents and assistants with a terminal (e.g. Claude Code) can publish for you. Sign in once with quickish login, then just ask:

“Build a one-page site as a single self-contained index.html, then publish it to Quickish with the quickish CLI.”

It writes the file, runs quickish, and hands you the live link. To share with specific people, add: “…and invite alex@acme.com and sam@acme.com” and the assistant passes --invites for you.

Generated HTML in a chat?

Save what your assistant produced as index.html (put any images/CSS next to it), then either drop the folder into your dashboard or run quickish . in that folder. Live in seconds.

Tip: tell the model to output one self-contained index.html with the CSS and JS inlined. It's the most reliable thing to host, and it just works.

Advanced · Direct API

For your own scripts, or an assistant you wire by hand: grab a publish token in your dashboard → Settings → Publish with AI, then POST a self-contained page:

$ curl -X POST https://api.quickish.website/_assistant/publish \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "html": "<!doctype html><h1>hi</h1>", "invites": ["a@co.com"] }'

Returns { "url": "..." }. Optional fields: page, share (private / public / workspace), invites.