html-easy-deploy

Instantly deploy a single self-contained HTML page to htmlcode.fun for quick live URLs of landing, demo, or microsites without complex hosting setups.

Security Scan

The skill is internally consistent: it uploads single-file HTML to https://www.htmlcode.fun and includes a small helper script; it does not request unrelated credentials or install arbitrary third‑party code.

Purpose & Capability

Name/description, SKILL.md instructions, and the bundled Python script all align: they POST/GET JSON to https://www.htmlcode.fun to deploy, update, and fetch single-file HTML pages. Nothing in the files requests unrelated services, binaries, or credentials.

Instruction Scope

Instructions are scoped to producing one HTML document and sending it as JSON to the htmlcode.fun API. Caution: any HTML you send (including embedded data or credentials) will be published to an external host — do not deploy private or sensitive content. The SKILL.md does not instruct the agent to read unrelated files or secrets.

Install Mechanism

No install spec is provided (instruction-only skill) and the included script is a small, readable Python file using stdlib urllib. No remote downloads or archive extraction are performed by the skill.

Credentials

The skill requires no environment variables, credentials, or config paths. The payloads are JSON fields (filename, content, optional code/title) — no undeclared secrets are requested.

Persistence & Privilege

always is false and the skill does not request elevated or persistent agent/system privileges. The script only communicates with the host domain and reads/writes files the user explicitly passes.

Assessment

This skill appears to do exactly what it says: upload a single HTML file to htmlcode.fun. Before installing, consider whether you trust the target domain (no homepage/source URL provided here), and never deploy HTML that contains passwords, API keys, or other sensitive data — the service will publish whatever you send. Test with non-sensitive samples first, verify the returned URL/code behavior, and prefer a well-known hosting provider if you need custom domains, access controls, or long-term production hosting.

Overview

Use htmlcode.fun when the output can be delivered as one standalone HTML document and speed matters more than full project-hosting features. This skill is designed for agents that need the shortest path from HTML content to a live shareable URL.

Live example and walkthrough:

• https://www.htmlcode.fun/s/htmlcode-fun-guide

Bundled script:

• scripts/htmlcode_deploy.py for deploy, update, and fetch operations

Decision rule

Use this skill when all of the following are true:

• The deliverable is a single HTML page.
• The page can be self-contained or nearly self-contained.
• Fast sharing matters more than custom domains, CI/CD, or multi-file assets.

Do not use this skill when any of the following are true:

• The project is a React, Vue, Next, or multi-file frontend app.
• The site needs build steps, environment variables, or asset pipelines.
• The user specifically needs their own domain bound to the host.
• The page is likely to exceed the service limit of about 1 MB HTML payload.

Core workflow

1. Produce one complete HTML document.
2. Inline CSS and JS when practical.
3. Add quality metadata before deploy:
   • <title>
   • <meta name="description">
   • <meta name="viewport" content="width=device-width, initial-scale=1.0">
   • Open Graph tags when the page will be shared
4. Decide whether the page needs a stable short code.
   • For one-off pages, deploy without custom code.
   • For pages that will be updated in place, set enableCustomCode=true and choose customCode on first deploy.
5. Deploy with JSON to POST https://www.htmlcode.fun/api/deploy.
6. Save the returned code, url, and qrCode.
7. For later edits, update with PATCH https://www.htmlcode.fun/api/deploy/content using the same code.
8. If the API returns 429, wait for retryAfterSeconds before retrying.

Fastest path

Prefer the bundled script when working from local files.

Deploy a new page:

python scripts/htmlcode_deploy.py deploy page.html --title "launch-page" --code launch-page

Update an existing short code in place:

python scripts/htmlcode_deploy.py update launch-page page.html --title "launch-page-v2"

Fetch deployed content:

python scripts/htmlcode_deploy.py get launch-page --output launch-page.html

Use raw API calls only when the agent already has HTML content in memory and does not need a file-based workflow.

Request format

Always send JSON.

Required fields:

• filename
• content

Useful optional fields:

• title
• enableCustomCode
• customCode

Example deploy payload:

{
  "filename": "index.html",
  "title": "launch-page",
  "content": "<!doctype html><html>...</html>",
  "enableCustomCode": true,
  "customCode": "launch-page"
}

Example update payload:

{
  "code": "launch-page",
  "content": "<!doctype html><html>...updated...</html>",
  "title": "launch-page-v2",
  "filename": "index.html"
}

Best practices for agents

• Prefer one larger deploy over many tiny edits because the service enforces a 10 second cooldown after success.
• Do not use multipart upload or -F file. Read files into memory and send them as JSON content.
• Keep the page self-contained. Inline CSS, inline lightweight JS, and avoid many external dependencies.
• Keep images small. Large base64 assets can quickly hit the payload limit.
• If the page will be revised repeatedly, reserve a meaningful customCode at the first deploy.
• Save returned code, url, and qrCode immediately after deployment.
• When receiving 429, respect retryAfterSeconds instead of retrying aggressively.
• Treat htmlcode.fun as a fast publication channel, not a full static hosting platform.
• Tell the user clearly when the page is better suited for Vercel or Netlify instead.

What this host is good at

• Temporary landing pages
• Demo pages
• Shareable documentation pages
• QR-linked event or campaign pages
• AI-generated single-file frontends
• Stable short-link pages that need quick overwrite updates

What this host is not good at

• Multi-page sites with shared assets
• Framework builds
• Large production frontends
• Team workflows with preview environments and rollback
• Confirmed custom-domain hosting workflows

Example live page

Reference example:

• https://www.htmlcode.fun/s/htmlcode-fun-guide

Use that page as a model for how to explain advantages, limitations, and deployment guidance in one self-contained HTML document.