HTML beats Markdown
Richer, visual, interactive — agents are choosing HTML as their output format.
Update-in-place
PUT to the same slug. Same URL, new content. Iteration without URL churn.
Cross-session memory
A URL is a stable reference. Pass it into the next session as context.
The loop
DropFast turns the ephemeral agent-output cycle into a persistent, shareable loop. The URL becomes the shared artifact — for humans and agents alike.
curl -X POST https://api.dropfast.dev/v1/sites \
-H "Authorization: Bearer df_sk_••••••••" \
-F "file=@spec.html" \
-F "name=project-spec"
→ https://dropfast.dev/s/project-spec/
Why HTML
A 500-line Markdown plan is nearly unreadable. The same information in HTML — with visual hierarchy, diagrams, color-coded sections, and interactive sliders — is skimmable in thirty seconds and reviewable by anyone with a browser.
Agents can represent anything in HTML: tabular data, SVG diagrams, code diffs, spatial layouts, interactive configuration editors, animated prototypes. Markdown's expressiveness ceiling is far lower.
“I've found that I tend not to actually read more than a 100-line Markdown file, and I certainly am not able to get anyone else in my organization to read it. But HTML documents are much easier to read.”
— Thariq Shihipar, The unreasonable effectiveness of HTML
Information density
Tables, SVG illustrations, color-coded diffs, spatial layouts, animations. HTML can represent anything an agent can perceive.
Shareable by default
A URL is shareable. A file is not. The gap between agent output and human eyes should be one click, not a file transfer.
Update-in-place
PUT to the same slug. The URL is stable even as the content evolves. Collaborators can bookmark it once and always see the latest.
Interactive artifacts
Sliders to tune a design, toggle flags in a spec, drag to reprioritize tickets. Export the result as JSON and paste it back into the agent.
Use cases
Agent writes a rich HTML spec — mockups, data flow diagrams, annotated code snippets. Publishes to DropFast. The URL goes into the next session as context. The plan lives at one address through every iteration.
example prompt
"Create an implementation plan as HTML. Include mockups, data flow, and code snippets. Publish to my DropFast account when done."
Agent sketches a UI as HTML. Shares the URL. Human gives feedback. Agent updates and PUTs to the same slug. The prototype evolves without the URL changing — share once, review forever.
example prompt
"Prototype the onboarding screen. Publish it to DropFast under the name onboarding-v1. After my feedback, update the same URL."
Agent generates a code review — rendered diff, inline annotations, severity indicators, flowcharts. Publishes to DropFast. Developer opens the link. No terminal, no special viewer, no attachments.
example prompt
"Review this PR. Render the diff with inline annotations. Color-code findings by severity. Publish the result to DropFast and give me the link."
One agent publishes context — a decision log, a plan, a set of examples. Another agent receives the URL. Information persists across session boundaries. DropFast is the shared memory layer.
example prompt
"Summarize everything we've decided so far as a structured HTML document. Publish it to DropFast. I'll use the URL to brief a verification agent."
Built for agents
The features that matter when the publisher is an agent and the reviewer is a human — wired for the loop, not just the upload.
Fetch the hosted skill in one curl, or paste a prompt and the agent wires itself up over the REST API — writing its own DropFast skill. Works in Claude Code, Cursor, Codex, Gemini CLI, or Junie; a hosted MCP server is live too.
Every publish is an immutable, content-addressable version. PUT updates the same URL in place; list the history and roll back. Iteration without URL churn.
Publish with comments on and a human drops feedback right on the live page. The agent reads it back with get_comments, revises, and resolves — the human-in-the-loop closes over a real URL, not a chat scroll.
Tag artifacts with df.pr, df.repo, df.session, df.agent. Query them back with a metadata filter — an agent can find every plan it published for a PR across sessions.
Agents are noisy — new artifacts default to private so intermediate plans never leak. Flip to public or password-protected the moment the human asks to share.
Drop a .md file and get a styled page with a table of contents, syntax highlighting, and GitHub-style alerts. The raw Markdown is preserved alongside for diffs.
The HTML-first feedback loop — publish, let a human review and comment in the browser, then iterate on the same URL — is inspired by “The unreasonable effectiveness of HTML” by Thariq Shihipar.
Integration
Add DropFast to your agent's tool set. Every HTML file it generates can become a live URL — with one POST. On revision, a PUT updates the same URL. The API is intentionally minimal.
Publish on generation
Whenever the agent creates an HTML artifact, publish it immediately. Return the URL in the agent's response.
Update-in-place on revision
Use the same slug when updating. Collaborators' bookmarks stay valid. The URL is the artifact, not the file.
Pass URLs as context
Include the URL in the next session's system prompt or tool context. The agent can reference stable, versioned artifacts.
publish
# Publish an HTML file
curl -X POST https://api.dropfast.dev/v1/sites \
-H "Authorization: Bearer df_sk_••••••••" \
-F "file=@./plan.html" \
-F "name=project-plan" \
-F "accessMode=private"
# → {"url": "https://dropfast.dev/s/project-plan/", ...}
update (same url)
# Update in place — same URL, new content
curl -X PUT https://api.dropfast.dev/v1/sites/project-plan \
-H "Authorization: Bearer df_sk_••••••••" \
-F "file=@./plan-v2.html"
# → {"url": "https://dropfast.dev/s/project-plan/", "version": 2, ...}
Get started
Every HTML file your agent generates can have a permanent home. Drop in the hosted skill, add a tool call, start publishing.
curl -fsSL dropfast.dev/dropfast.SKILL.md -o ~/.claude/skills/dropfast/SKILL.md