AI Built Website
Featured Stories Web • Agent Built

AI Built Website

Buy a domain, point it at your Pocketcorp, and build your website by talking to your agent on Telegram — every change live in minutes.

Agent Hermes Agent
Level Starter
Setup ~45 min

Your Pocketcorp has a public IP, a terminal, and an agent that writes code. That is everything a website needs. This guide wires a domain to your server, puts nginx in front (with certbot doing the certificate work), and gives Hermes a site-builder skill with one golden rule: never claim “done” without a screenshot of the live URL.

Hermes Agent · Nous Research

Hermes is a terminal-native coding agent with a learning loop: after your first deploy it saves the whole build-verify-deploy workflow as a skill, so the tenth change ships faster than the first. Your Pocketcorp is the web server — the site never leaves your machine.

Start Here: One Prompt

Copy this prompt and send it to the agent on your Pocketcorp. It sets up everything in this guide and reports back when it’s done. The steps below explain what your agent is doing — and how to check its work.

prompt — paste to your agent
Turn this server into my website agency.

1. Connect Telegram: I’ll create a bot with @BotFather and give you
   the token. Put it in ~/.hermes/.env with my numeric user id as
   the only allowed user, then restart the gateway.
2. Ask me for my domain and a Cloudflare API token (Edit zone DNS,
   scoped to that zone). Create the A record pointing at this
   server, DNS-only (grey cloud), and verify with dig.
3. Install nginx and certbot (apt install nginx certbot
   python3-certbot-nginx). One server block per domain, root
   /var/www/<domain>, HTTPS via certbot --nginx. Iron rule: always
   nginx -t before reloading.
4. Create a site-builder skill: one git repo per site at
   ~/sites/<domain>; static-first (plain HTML, Astro only if a
   build step earns its keep); deploy = copy to /var/www, nginx -t,
   reload; after EVERY deploy screenshot the live URL with
   Playwright and send it to me with the link; max 3 fix loops,
   then ask me.
5. Then ask me what the first site is about — and build it.

The Stack

ChannelTelegram
ToolCloudflare DNS (API)
Toolnginx + certbot
Skillsite-builder SKILL.md
ToolPlaywright screenshots
Toolgit (one repo per site)
01

Send the prompt, then create your bot

Paste the prompt and the agent asks you for one thing: a Telegram bot token. Getting it takes half a minute and happens entirely inside Telegram — message @BotFather, send /newbot, pick a name, copy the token it answers with. Paste that token to your agent, and it stores it and locks the bot to you:

what the agent stores (~/.hermes/.env)
TELEGRAM_BOT_TOKEN=123456789:AAF...
TELEGRAM_ALLOWED_USERS=987654321   # your numeric ID — ask @userinfobot

The agent restarts its gateway and your bot comes alive. Say hi to it — anyone not on the allowed list is denied by default, so the bot answers you and nobody else.

02

Point your domain at the Pocketcorp

Two things only you can do: pick a domain (buy it anywhere — Cloudflare Registrar sells at cost) and give the agent permission to manage that domain’s DNS. The permission is a Cloudflare API token, and the agent tells you exactly which buttons to click — the “Edit zone DNS” template, limited to just your domain, so the token can’t touch anything else. Paste it to your agent:

what the agent stores (~/.hermes/.env)
CF_API_TOKEN=v1.0-abc...
CF_ZONE_ID=023e105f4ecef8ad9ca31a8372d0c353

From now on the agent manages DNS itself with one API call — this is what it runs when you say “point the domain at the server”:

what the agent runs
curl -X POST "https://api.cloudflare.com/client/v4/zones/$CF_ZONE_ID/dns_records" \
  -H "Authorization: Bearer $CF_API_TOKEN" \
  -H "Content-Type: application/json" \
  --data '{"type":"A","name":"mysite.com","content":"<your-pocketcorp-ip>","proxied":false}'
Heads up

The record stays DNS-only (grey cloud) at first — Cloudflare’s proxy would block the little handshake certbot uses to prove your domain and issue the free HTTPS certificate. The prompt bakes this rule in, so the agent gets it right; you can flip the orange cloud on once the certificate exists.

03

It puts nginx in front

The agent installs nginx — the web server that answers your visitors — and certbot, which fetches the free HTTPS certificate and renews it forever. One tidy folder per site:

/etc/nginx/sites-available/mysite.com
server {
    server_name mysite.com;
    root /var/www/mysite.com;
}

# enable it, then let certbot add HTTPS + the redirect:
# ln -s ../sites-available/mysite.com /etc/nginx/sites-enabled/
# certbot --nginx -d mysite.com
Pro tip

The guardrail that keeps one bad edit from downing every site: the agent must always run `nginx -t` before `systemctl reload nginx`. Test-then-reload is zero-downtime. The prompt writes this rule into the agent’s skill (next step), so it can’t forget it.

04

The skill it writes for itself

The prompt has the agent write its own operating manual — the difference between “an agent that can code” and “an agency that ships”. It encodes stack defaults, the deploy path, and the golden rule: never claim “done” without a screenshot of the live site:

~/.hermes/skills/web/site-builder/SKILL.md
---
name: site-builder
description: Build, deploy and iterate websites on this server
---

## Defaults
- One git repo per site at ~/sites/<domain>. Every change = commit.
- Static-first: plain HTML + Tailwind (CDN) or Astro if a build
  step is justified. No framework unless asked.
- Deploy = copy build output to /var/www/<domain>, then
  nginx -t && systemctl reload nginx. NEVER reload without the test.

## Verify loop (non-negotiable)
- After every deploy: screenshot https://<domain> with Playwright
  and send it to me with the live URL.
- If the screenshot does not match what I asked, fix and repeat
  before replying. Max 3 loops, then ask.

## DNS
- New domains: create the A record via the Cloudflare API
  (CF_API_TOKEN in env), verify with dig before claiming success.
05

Build it — from your pocket

Now the whole workflow is conversational:

You

Set up mysite.com — landing page for my bakery. Warm, minimal, one page: hero, menu, opening hours, map.

Agent

Live at https://mysite.com 🍞 [screenshot] — DNS propagated, HTTPS issued by certbot, repo initialized at ~/sites/mysite.com (commit 1a2f3c). Want changes?

You

Hero darker, and add a “pre-order for weekends” button.

Agent

Done — [new screenshot]. Darkened the hero overlay to 60% and added the pre-order CTA linking to your contact form. Commit 8e4d21; say “revert” to undo.

Note

Because every iteration is a git commit, “undo yesterday’s changes” is a real command, not a hope. You can also watch edits live in the Pocketcorp VS Code tab while the agent works.

06

Let the learning loop work

This is where Hermes differs from a one-shot site generator. After the first successful deploy, it saves what worked — your taste, the deploy quirks, the nginx layout — via its skill_manage tool, refining the site-builder skill from experience. The second site you ask for skips every mistake the first one taught it.

Prefer not to host on your own box? The same skill works with edge hosts — swap the deploy line for `wrangler pages deploy dist/` (Cloudflare Pages, free, doesn’t even consume build minutes via direct upload) or `netlify deploy --prod`. Your Pocketcorp stays the brain; the edge serves the bytes.

What you end up with

A live, HTTPS-secured website on your own domain and your own server, iterated by chat, verified by screenshot, versioned in git. Changes ship in the time it takes to type them.

Deploy your PocketcorpHermes Agent comes pre-installed. €15/month, or €12/month billed annually.

More stories to build