# HTML Anything: When AI Agents Replace Your Template Engine
There's a moment every developer knows: you've written the thing — the document, the deck, the one-pager — and now you have to make it look like something a human would want to read. The Markdown is done. The content is good. But rendering it into something presentable means reaching for a template engine, or a CSS framework, or a design tool you haven't opened in six months. That gap between "written" and "readable" has always been someone's problem to solve. Usually yours.
HTML Anything is a bet that the gap closes differently in the agentic era.
The Problem With Templates
Template engines have solved the wrong problem for twenty years. They're excellent at mechanical substitution — take a blob of content, pour it into a slot, emit HTML. What they cannot do is make a decision. A Jinja template doesn't know whether your content wants to breathe across a wide editorial column or snap to a tight card grid. A Handlebars partial doesn't understand that your abstract belongs in a pull-quote and your data tables want to live in a sidebar. These are design judgments, and design judgments have always required a human in the loop — or a designer who speaks HTML.
The emergence of coding-agent CLIs changes that calculus. Tools like Claude Code, Gemini CLI, Cursor Agent, and Codex are already running on developers' laptops, logged in, warm, ready. They don't need API keys because they're billing against subscriptions that are already open. They understand layout. They read content and they understand structure. The only thing missing was a surface that let them act directly as the rendering layer — that asked them to produce polished, reader-ready HTML instead of application code.
That's the thesis behind HTML Anything.
Agentic Rendering, Concretely
"Markdown is the draft. HTML is what humans read. Your local agent writes it."
The project's core mechanic is disarmingly simple: it auto-detects whichever of eight coding-agent CLIs (claude, gemini, codex, cursor-agent, gh copilot, opencode, qwen-coder, aider) is on your PATH, opens the existing CLI session — not a new API call — and drives it with structured prompts derived from one of 75 composable skill templates. No configuration. No new credential. You already paid for the session; HTML Anything just gives it a job.
The skill templates (SKILL.md frontmatter in each template directory) encode the design decisions that would otherwise be yours to make. deck-swiss-international imposes a 16-column grid with a single saturated accent — Klein Blue, Lemon, Mint, or Safety Orange — across 22 locked layouts. doc-kami-parchment, inspired by tw93/kami, renders long-form prose onto a warm #f5f4ed ground with ink-blue accents and a single serif voice. deck-guizang-editorial produces something the README calls a piece that "reads like a printed art-zine, not a slide deck" — magazine proportions, e-ink palette, locked layouts that refuse to be improvised into mediocrity.
These aren't themes. They're constraints. The templates deliberately limit what the agent can produce, not because the agent lacks capability, but because constraint is what turns a capable generalist into a reliable designer. The agent brings the content awareness; the template brings the taste.
The nine deliverable surfaces — magazine articles, keynote decks, résumés, posters, Xiaohongshu cards, tweet cards, web prototypes, data reports, and Hyperframes videos — each carry their own compositional logic. A Xiaohongshu card is portrait, dense, high-contrast, built for a 9:16 scroll feed. A keynote deck is landscape, sparse, built for a room. The same piece of writing should produce radically different HTML depending on where it's going. The template tells the agent where it's going.
Export targets include WeChat, X, Zhihu, and Bilibili — a distribution footprint that skews conspicuously toward Chinese platforms, which makes sense: the team behind this also maintains Open Design, a 40,000-star design-systems project with over 200 contributors, and that community has always straddled English and Chinese developer circles. A recent commit adds Mastodon, Bluesky, and a Markdown round-trip target — breadth that suggests the team is watching where content actually travels.
Who This Is For
The immediate audience is people who produce content — specifically, developers and technical writers who already use coding-agent CLIs for code and have started to wonder why they can't use the same loop for everything else. If you're already asking an agent to draft release notes, the cognitive leap to asking it to render those notes into a polished magazine-style document is not large. HTML Anything removes the mechanical friction from that leap.
But the reach extends further. The 75 skill templates and nine surfaces suggest a tool thinking about non-developer users who happen to have a coding agent installed — or who work alongside someone who does. A growth marketer who wants to produce a Xiaohongshu card from a brief. A researcher who wants to push an abstract into a poster layout. A team lead who wants the sprint report to look like it was designed, not generated. The GitHub-backed skill marketplace mechanic (per a recent commit) implies a path toward community-contributed templates, which would significantly expand that surface area.
The no-API-key constraint is not just a convenience; it's a statement about who the primary user is. This is for people who already live in agentic workflows, not people evaluating whether to enter them.
What This Tells Us About Where We're Going
There's a line from the README worth sitting with: "in the agentic era, you don't hand-edit docs anymore, so the output format should be what the reader actually wants." That's a clean articulation of something the industry is circling without quite landing on.
The template engine paradigm assumed a separation of concerns: content here, presentation logic there, a developer in the middle translating between them. The agentic paradigm collapses that middle layer. The agent understands both the content and the presentation requirements. What remains — and what HTML Anything is precisely about — is giving the agent enough structured intent to make good decisions without drowning it in degrees of freedom.
The 75 templates are, in this reading, a knowledge representation problem: how do you encode sufficient design judgment to make an LLM reliable as a layout engine? The answer here is constraint — locked grids, named palettes, ranked layouts, recommended: frontmatter scores that surface the best options first. The agent fills in the content; the template fills in the taste.
That design pattern — constrained agent, structured intent, rendered output — is going to appear in a lot of places that are not HTML editors. Forms, reports, legal documents, dashboards. HTML Anything is an early, working instantiation of a general idea: that the rendering layer is now a job for the model, and the hard design work has moved upstream into the template.
The template engine isn't dead. It just learned to think.
