Goodbye WordPress: Migrating My Blog to Hugo With Claude Code and a Mikrus VPS

Piotr Zagórowski / / Technology

Another Monday, another coffee, another WordPress vulnerability report in my inbox.

I had read that kind of email many times before. A plugin I’d never heard of, a CVSS score of 9.8, “update immediately”. This time one of the plugins on the list was one I actually had installed. My site had automatic updates for critical vulnerabilities switched on, so I wasn’t in a panic. I was tired of it, though.

This post is about how that tiredness turned into a two-sitting project. coffeejourneys.blog no longer runs on WordPress. You’re reading a static site built with Hugo from plain Markdown files in a GitHub repo, served from a small VPS in Poland. An AI assistant did most of the heavy lifting.


The Bitter Aftertaste: Why I Left WordPress

WordPress served me well for years. My problem was never WordPress core. It was everything around it.

A blog like mine slowly collects plugins: SEO, image optimisation, popular posts, related posts, internal linking, an old newsletter form. Each one is a bit of PHP that somebody else maintains, running on a server that answers to the whole internet.

The reports keep coming. A few from this year alone:

  • Liquid Web’s February 2026 report listed an unpatched PHP object injection flaw in Link Whisper Free (CVE-2026-22384). I had Link Whisper installed.
  • Sucuri’s March 2026 roundup listed an unauthenticated broken access control flaw in a Mailchimp plugin with over a million installs, and a code execution flaw in W3 Total Cache with no fix available at the time.
  • Heise reported critical flaws in two popular plugins, one of them already being exploited in the wild.

To be fair, I wasn’t exposed. Auto-updates for critical vulnerabilities were on. But “auto-update for critical” only covers the critical ones. Everything else was still my job:

  • reading the weekly reports,
  • checking whether any of my plugins were on the list,
  • deciding whether a “medium” problem was really medium for my site,
  • and paying for hosting just to keep a PHP application and a database alive so they could serve what are, honestly, mostly static articles.

The question I couldn’t get past was simple: why am I running and patching an application when what I publish is text and pictures?

A static site has no admin panel, no login page, no database and no plugins. There’s nothing to update at 2 a.m. The web server serves files, and that’s it.


The House Blend I Already Had

I didn’t start from zero. A month earlier I wrote about building a live map of my corner of London, now running at map.zagor.org. That project laid the groundwork for this one:

  • a cheap Mikrus VPS,
  • the Mikrus MCP server, which lets Claude Code run commands on the server, upload files and manage domains,
  • and a way of working where the AI assistant ships changes the way a deployment pipeline in an IT department would.

The map showed me that an assistant can take an idea all the way to production on its own server. A blog migration felt like the obvious next step, and a good test of whether the approach holds up for something that has to keep 200+ existing URLs working.


The Order at the Counter: My Initial Prompt

As with the map, I didn’t polish the brief. Here’s roughly what I wrote, typos removed:

I would like to explore the idea of my blog migration. I use WordPress
and I host my blog with a Polish hosting company.

I want to download all my blog posts as well as the pages and have them
as markdown pages. I already have them (or most of them) in my Obsidian
vault. Part of the process will be to use what is on the blog as the
source of truth to swap all existing notes in Obsidian.

I see the process as follows:
- check the sitemap file for blog and pages
- check the blog structure checking the main page
- plan to download all text content
- plan to download images and PDFs linked from pages
- explore possible mechanisms that build the live website from markdown
- have all text content synced to a GitHub repo
- make sure that changes in GitHub reflect on the live website
- propose what to do with non-text content (GitHub + hosting machine?
  some cloud bucket?) - I prefer not to pay more than I already do.
  I have Google Cloud.
- I already have a VPS that hosts zagor.org. It used MCP to deploy
  the site. I would expect to use the same mechanism.

Based on the above, build the spec with a proposal or a few proposals
with pros and cons.

Then I asked: “Read it and let me know what you think.”

That last sentence matters. I didn’t say “do it”. I asked for an opinion first.


Cupping Session: Where Claude Pushed Back

The reply wasn’t “Great plan, let’s go!” It started with what was good (discovery first, reusing what I already pay for, Markdown in Git) and then went straight to the problems. Some of them were exactly the kind of thing I’d expect a good senior engineer to say in a design review:

  • “Export, don’t scrape.” My plan said “check the sitemap” and “download content”. Claude suggested using the WordPress REST API with an Application Password instead, so we’d get raw post content and clean metadata (dates, slugs, categories, featured images) rather than HTML wrapped in theme markup.
  • “Overwriting your Obsidian notes is the riskiest step.” I had casually written “swap all existing notes”. Claude pointed out this could destroy newer drafts and asked for a backup, a comparison report and a review before anything was replaced. (In the end I dropped the Obsidian sync altogether. More on that below.)
  • “Deploying via MCP and ‘GitHub changes go live’ don’t fit together.” This was a good catch. MCP is something the assistant uses interactively, so nothing runs it when I push a post from my laptop. If a push should update the site, something like GitHub Actions has to do the deploy. MCP stays useful for setting up the server.
  • “Keep the URLs working.” Every old link, in Google and on other people’s sites, should land somewhere sensible. That meant matching the WordPress permalinks and writing redirects for the rest.
  • “Measure the media before choosing where it lives.” No point designing a cloud bucket setup before knowing how many gigabytes we’re talking about.
  • “Your domain expires in six weeks.” Discovery found that coffeejourneys.blog expires on 2 January 2027. Not a migration problem as such, but exactly the kind of thing that ruins a December.

None of these were deal-breakers. Every one of them made the plan better, and a few would have hurt if I’d found them halfway through.


Comparing Beans: The Options, With Pros and Cons

Next came discovery. Claude read the sitemaps and the REST API (read-only, nothing changed) and found 110 posts, 183 pages and 413 media files, about 185 MB of originals. It turned out most of my “pages” were really “now” snapshots, newsletter issues, and 76 short links like /cv/ and /meet/ that just pointed elsewhere.

Then it wrote a spec with options for each decision. Here are the three tables that mattered most.

Which static site generator?

HugoAstroEleventyQuartz
Installsingle binaryNodeNodeNode
Build speed (~300 pages)under 1 s~10 s~5 s~10 s
Keep WordPress URLs, incl. nested pageseasyeasyeasyawkward
Image resizing built inyesyespluginlimited
Theming effortmedium (Go templates)low–mediummediumlow, but a “digital garden” look
Long-term maintenancevery low (no npm)medium (npm churn)low–mediummedium

Choice: Hugo. One binary, no dependency churn, and it handles a URL-preserving blog with several sections very well.

How does a push become a live site?

A. GitHub Actions → rsyncB. VPS pulls and buildsC. MCP deploy (the zagor.org way)
Push → live automaticallyyes, about a minuteyes, on a timer or webhookno, I ask Claude to deploy
New secretsSSH deploy key in GitHub, locked to one folderread-only GitHub key on the VPSnone
Load on the VPSnonebuilds on 1 GB RAM (fine)none
Where failures show upGitHub UIlogs on the VPSthe chat
Rollbackswitch a symlinksamesame

Choice: A, with C as the manual fallback. Both use the same release folder layout, so either one works at any time.

Where do images and PDFs live?

OptionCostProsCons
In the Git repo, next to each postfreeone source of truth, versioned, deployed with everything elsethe repo grows (~200 MB today)
Git for text, media synced separatelyfreesmall repotwo things to keep in sync and back up
Cloudflare R2 bucketfree up to 10 GBoffloads the VPS, CDNnew account, card required
Google Cloud Storagefree tier: 5 GB, US onlyI already have GCPbilling account attached, egress costs, slower from Europe
Git LFSfree 1 GB—every CI checkout eats the bandwidth quota

Choice: in the repo. At 185 MB, anything else is over-engineering. We’ll look at R2 if it ever passes a gigabyte or two.


The Barista and the Café Owner: My Advice, Again

I gave this tip in the map post and I’ll repeat it, because this project proved it again:

Treat the AI as a senior engineer, and yourself as the architect.

A senior engineer knows a lot, works fast and has opinions. They’ll tell you when your plan has a hole in it. But they don’t own the product. You do. The architect’s job is to know enough to push back, or to accept a risk knowingly.

This went both ways in this project.

Where I accepted Claude’s push: export through the API, GitHub Actions instead of MCP for routine deploys, media in the repo, Hugo.

Where I pushed back:

  • Analytics. When I asked whether the SEO data was preserved, the conversation moved on to analytics. Claude compared Umami and Plausible, and I agreed to try self-hosted Umami on the VPS. A few minutes later I stopped it: “let’s revert this Umami thing. It exposes another attack vector, I will use Clicky instead.” I’d just left WordPress to get rid of a running application and a database. Adding a new one for page view counts made no sense. Claude rolled it back and later purged the database from the server.
  • Obsidian sync. The original idea was to make the blog the source of truth for my vault. Claude built a read-only comparison script and the numbers looked fine. But once the posts lived in GitHub, the sync no longer had a job to do. I dropped it, and Claude struck it out of the spec rather than quietly forgetting it.

Neither of these was Claude being wrong. They were trade-offs, and trade-offs are the architect’s call. The assistant’s job was to make them visible. Mine was to decide.


No Brewing Before the Recipe Is Written

This is the part I’d recommend most: we didn’t touch anything until there was a full spec and a plan.

The spec (SPEC.md in the repo) covered goals and non-goals, the discovery results, the options above, a step-by-step migration pipeline, a cut-over plan with a rollback, and an explicit list of decisions needed from me. It was updated as we went, so it ended up as a record of what we actually did, not what we first thought we’d do.

It also spelled out what I had to do myself. The assistant can do a lot, but some things need a human with the right logins:

  1. Create a private GitHub repo.
  2. Create a WordPress Application Password and put it in a local .env file (which Claude added to .gitignore first, and never printed).
  3. Add the deploy key as a secret in GitHub.
  4. At cut-over time, change exactly two DNS A records in my DNS panel (apex and www), and leave MX, TXT and NS alone.
  5. Fix the SPF record. This one I wouldn’t have spotted. My SPF record used a, which after the DNS change would have allowed the shared Mikrus front-end IP to send mail as my domain. Claude flagged it in the cut-over runbook.
  6. Submit the new sitemap in Google Search Console, and confirm Clicky shows visits.

Each step said what to change, where, and how Claude would verify it afterwards. When I wrote “DNS changed, add the domain”, Claude checked the authoritative name server first, then added the domain.


The Heavy Lifting: Mikrus and Its MCP

Here’s what the Mikrus MCP server made possible without me opening a single SSH session:

  • Checking the server first: disk, RAM, which ports were already taken (port 20157 is the live map, so the blog shares nginx on 30157 as a second virtual host next to zagor.org).
  • Testing the risky assumption early: does the Mikrus front pass the original domain name through to nginx? Claude put up a test site on a free subdomain and confirmed it does, before any of the design depended on it.
  • Setting up a locked-down deploy user: GitHub Actions logs in as deploy with a key that can only upload into one folder and switch the current symlink. Nothing else.
  • Wiring the domain: adding coffeejourneys.blog to Mikrus Cytrus, which issued the HTTPS certificate about 80 seconds later.

Meanwhile, on my laptop, Claude wrote the export and conversion scripts, built a Neve-like theme so the site still feels like mine, reproduced the Yoast SEO titles and descriptions (194 out of 194 titles match), generated over a hundred nginx redirects for old URLs and short links, and ran a URL parity check: all 242 old URLs return a page or an intentional redirect.

Every change is a commit. Every push builds and deploys in about a minute. Each release is a timestamped folder, so a rollback is a symlink away. And WordPress is still sitting untouched at the old host for a few weeks, as the ultimate rollback.

The first message went in early on a Thursday morning. The site went live on the real domain early on Friday, about 25 hours and two sittings later.


A Second Cup: The Polish Blog

I also run a Polish blog, tatonawyspach.co. Once coffeejourneys.blog was live, I asked Claude whether we should do the same there.

It wrote a handover file for the new project: what I needed to prepare (repo, app password, .env), which scripts and configs to copy, what to adapt, and, most usefully, the mistakes from the first migration not to repeat. An rsync flag that quietly made every deploy a full 226 MB copy, 76 “pages” that turned out to be short links, the Umami detour.

Then I started a fresh session in a new folder and pointed it at that file.

The difference was huge. The discovery and spec were committed at 05:04. By 05:25 the Hugo site, converter, deploy pipeline and all 85 posts and 15 pages were in the repo. The cut-over followed later that day, with all 126 old URLs checked against the live domain. Most of the time went on the decisions only I could make, not on building anything.

That’s what a good spec and a written-down set of lessons buy you. The second migration wasn’t a new project. It was a re-run of a known recipe.


CategoryDescriptionLink
Previous postBuilding the live mapForest Edge Live Map
HostingMikrus VPS by Jakub Mrugalskihttps://mikr.us/
AI assistantClaude Codehttps://claude.com/claude-code
Site generatorHugohttps://gohugo.io/
AnalyticsClickyhttps://clicky.com/
Vulnerability reportsWordfence Intelligencehttps://www.wordfence.com/threat-intel/

Lessons Learned From This Coffee Journey

  • Your attack surface is what you run, not what you publish. If your content is text and images, you probably don’t need a database and plugins to serve it.
  • Ask for an opinion before asking for work. “What do you think?” got me six improvements before a single line of code.
  • Treat the AI as a senior engineer and yourself as the architect. Accept its push when it’s right; push back when the trade-off is yours to make.
  • No spec, no start. Options with pros and cons, decisions written down, steps for the human listed explicitly.
  • Give the assistant hands. An MCP for your hosting provider turns server setup into just another step in the plan.
  • Write down the lessons. The second migration was fast because the first one left a recipe behind.

My coffee is cold again, but there’s nothing left to patch.

Are you still running WordPress for a mostly static blog? What’s keeping you there? Tell me in the comments.