Writing

My Website Has a Webmaster Now

I use Hermes Agent to inspect, update, test, deploy, and verify this site from a Discord conversation.

It can follow the same path a developer uses to make a real site change.

The old website loop

A personal site should be easy to change. In practice, it often is not.

A small update becomes a chain of chores:

1. Open the project.
2. Find the right file.
3. Remember the content model.
4. Make the edit.
5. Run the checks.
6. Build the site.
7. Deploy it.
8. Verify production.

None of these steps is difficult alone. Together, they create enough context switching that the site becomes easy to ignore.

The portfolio gets stale. The blog waits. The contact page is almost right but not quite. The website becomes another thing to maintain in the background.

What I set up

The setup is simple: Hermes Agent is connected to Discord and has controlled access to the parts of the site it needs to work on it:

• the local jmbartelt.com site repo
• the Astro content structure
• deployment secrets stored outside the repo
• SSH access to the Vultr server
• the OpenLiteSpeed deployment target

The site is an Astro static site. Blog posts are Markdown files in a content collection. Production runs on a Vultr box with OpenLiteSpeed serving the generated files.

That gives the agent a complete, repeatable path:

Discord message
  -> inspect repo
  -> write or edit content
  -> run tests and Astro checks
  -> build the static site
  -> deploy the build artifact
  -> verify the live URL

The setup is infrastructure, but it changes what I am willing to do. Site updates no longer require me to stop what I am doing, reopen a project, and remember every deployment detail before I can make a small change.

The practical recipe

The stack matters less than the contract. An agent needs a clear operating boundary:

You may edit this repo.
You may use these build commands.
You may deploy this build artifact to this server path.
You must verify the public URL when finished.

For this site, that boundary is backed by a code-driven workflow:

• content lives in Markdown and MDX
• Astro generates the routes
• checks run locally
• production is a static build
• deployment uses a defined script and target
• the public site is checked after deploy

An agent can read files, change files, and run those commands. There is no admin panel or undocumented sequence of clicks to reconstruct.

Put the agent where you already think

For me, that is Discord.

The interface matters. If I have to open a special dashboard to ask for a site update, I am less likely to do it. If I can message the agent where I already coordinate projects, asking for an update is much easier.

Give it real access, carefully

An agent that cannot touch the repo or server is an advisor. An agent with scoped access can do the work.

For this site, that means:

• SSH credentials and deployment variables live outside the repo
• the agent builds locally before touching production
• deployment is limited to the static output for this site
• production verification is part of every deploy

The boring safeguards matter. Secrets do not belong in chat. Backups should exist. The deployment target should be explicit. The agent should report what changed and verify the result.

Make verification non-negotiable

A deployment is not finished when a command exits successfully. It is finished when the live page returns the expected result.

For this site, the agent runs the local checks, builds the Astro site, deploys the generated output, and checks the production URL. If DNS or caching makes that unclear, it can test the server directly with the correct host header.

Without that final step, there is no reliable feedback loop.

What this changes

The obvious win is speed. I can ask to update the homepage, publish a post, or fix portfolio copy without rebuilding the entire context for a small change.

The bigger change is that the site is easier to keep current. The cost of updating it drops enough that I actually update it. A personal site should reflect current work, not preserve a perfect version of myself from a few years ago.

The caveat

I still decide what belongs here. I still own the taste, judgment, and professional claims.

The agent can operate the machinery, but I do not want it inventing my professional identity or filling the site with generic positioning copy. The writing voice, content model, deployment path, and review boundaries all matter.

More capable agents make those boundaries more important, not less. The agent should be able to execute; I should remain responsible for the direction.