New Year, New Website: How I Migrated from WordPress with GitHub Copilot

It was 2 a.m. on a Friday and my website was down. Again. Some WordPress plugin had auto-updated and broken the entire thing. I was staring at a white screen, a cryptic PHP error, and the sinking feeling that I'd be spending my weekend restoring from backups instead of, you know, doing actual research. Meanwhile, my hosting company was happily charging me 75 ILS a month (~$20 USD) for the privilege. That was the night I decided: I'm done with WordPress.

What I didn't know at the time was that rebuilding my website from scratch would turn out to be one of the most fun and surprisingly easy projects I've done in years. And I'd do it almost entirely through conversations with an AI.

The WordPress Years

Let me back up a bit. I built my first website as an early PhD student, back when my web coding skills were basically nonexistent. After a brief fling with Joomla (yes, I'm that old), I moved to WordPress. At the time, it was perfect: a nice GUI, drag-and-drop editors, no coding required. My main goal has always been to make research accessible to everyone, and WordPress let me do that.

But over the years, the cracks kept getting wider. WordPress was heavy. Pages loaded slowly because every request hit a database. The admin panel itself felt sluggish. And the plugins... oh, the plugins. You'd install one to handle image galleries, another for SEO, a third for security, and then they'd fight each other like toddlers over a toy. I lost count of how many times a random plugin update nuked my site's layout or, worse, took the whole thing offline.

The design was locked behind whatever theme I'd chosen, and customizing anything beyond the basics meant diving into PHP templates I barely understood. I wanted to reorganize my publications page? Good luck. Change the layout of the homepage? Hope you enjoy reading undocumented theme hooks.

And then there was the security. I run Israeli academic websites. We get attacked. A lot. WordPress is one of the most targeted platforms on the internet, and every unpatched plugin is a potential door left wide open. I spent more time worrying about security than creating content.

So for years I procrastinated on the migration, because the thought of preserving 74 blog posts, podcast episodes, publications, hundreds of images, and all the SEO I'd painstakingly built up felt overwhelmingly daunting. Until that 2 a.m. breaking point.

Building a Website from Scratch Has Never Been Easier

Here's the thing that surprised me most: in 2026, building a website from scratch is genuinely easier than wrestling with WordPress. That sounds absurd, but hear me out.

With modern static site generators like Eleventy (11ty) and free hosting on Cloudflare Pages, you get a site that's faster, more secure, and completely free to host. No database. No server-side code. No random plugins breaking at 2 a.m. Just clean HTML files served from a global CDN.

And the best part? Everything lives in Git. Want to undo something? git revert. Want to try a new design? Branch, experiment, merge. It's version control for your website.

But the real reason it's easier than ever is the AI. Specifically, I used GitHub Copilot powered by Anthropic's Claude models—Claude Opus for the heavy thinking (planning, architecture, complex debugging) and Claude Sonnet for the fast execution (writing code, making edits, running builds). The combination turned out to be remarkably natural: I'd have a conversation about what I wanted, and the AI would just... do it. If you want to get up to speed quickly, the official Copilot best practices guide is a solid starting point.

How It Actually Went Down

I want to walk you through my actual workflow, not because it's the One True Way, but because I think the process itself is interesting—and maybe useful if you're considering something similar.

The Plan

I started by asking Copilot (with Claude Opus) to create a migration strategy. Not just "convert WordPress to static HTML," but a full project plan with self-contained work packages, dependencies between them, and a testing strategy for each one. I refined it over several back-and-forth exchanges until we had something that felt solid.

The key decisions that emerged: use Eleventy for static site generation (lightweight, flexible, great template support), host on Cloudflare Pages (free tier, global CDN, automatic deployments from Git), and break the work into phases that could run in parallel.

I then asked Copilot to create a dependency graph of all the work packages. Which ones could run simultaneously? Which had to wait? This turned out to be crucial, because it meant I could launch multiple AI agents at the same time on independent tasks.

The Army of Agents

For each work package, I had Copilot open a GitHub issue with a detailed description, acceptance criteria, and links to the planning docs. Then—and this is where it felt like science fiction—I launched separate Copilot agent sessions for each independent work package.

One agent was exporting and converting WordPress content. Another was building the responsive image pipeline. A third was setting up the deployment infrastructure. A fourth was handling SEO. All running in parallel.

It genuinely felt like I had a team of very talented engineers working for me. Each agent was focused on its specific task, and I was the project manager giving direction and reviewing output. The parallelization meant that work that would have taken me weeks happened in days.

If you've ever managed students on a research project, you know the feeling. You give clear instructions, check in periodically, and occasionally course-correct. The difference here? Instead of waiting days for a response, the turnaround was minutes. And nobody was offended when I asked for changes.

The Messy Middle

I'd be lying if I said it was all smooth sailing. Working with AI agents has its own set of frustrations:

• Terminal integration. Copilot would get stuck in interactive terminal sessions—waiting for me to press q to exit a pager, or hanging on a git log that opened less. This happened constantly. (If any Copilot developers are reading this: please don't use exclamation marks at the end of terminal commands. It breaks things. Yes, I added it to my custom instructions. No, it doesn't always work.)
• Planning mode spirals. I'd ask a focused question and get back a 500-word essay on "other things to consider" instead of a direct answer. Learning to steer the conversation—being specific, giving constraints, pushing back on over-engineering—was a skill I had to develop.
• File clutter. AI agents are not great at cleaning up after themselves. By the end of the migration, I had dozens of temporary test files, investigation documents, and draft scripts scattered across the repo. We actually spent a whole session just on cleanup. It's worth budgeting time for this.

But here's the thing about these frustrations: they're minor. They're the equivalent of a colleague who leaves their coffee cups on your desk. Mildly annoying, easily fixed, and vastly outweighed by the productivity gains.

Trust, But Verify

After each agent finished its work, I'd pause and manually review. Run the build locally, click through pages, check that images loaded, verify the mobile layout. Sometimes things needed fixing—those I'd hand back to the same agent if they were quick, or open a new issue for anything bigger.

This rhythm—agent work, manual check, iterate—kept quality high while still moving fast. I never felt like I lost control of the project, which is something I was worried about when I started delegating so much to AI.

The Numbers

Here's what the migration actually achieved:

• Hosting cost: 75 ILS/month (~$20 USD) → 0. Cloudflare Pages is free.
• Page load: WordPress database queries → static HTML from a global CDN. The entire site builds in ~1.3 seconds.
• Content preserved: All 74 blog posts, podcast episodes, and publications migrated with formatting, images, and embedded media intact.
• Images optimized: 489 images converted to WebP, reducing total size by 78%.
• Security: No database, no PHP, no plugins. The attack surface essentially disappeared.
• Design control: Full control over every pixel. No more fighting with theme hooks or plugin CSS overrides.
• Version control: Everything in Git. Branching, PRs, rollbacks—all the tools I already use for research code.
• Copilot cost: The entire migration used less than 20% of my $40/month GitHub Copilot Pro subscription.

What I Actually Learned

Beyond the technical migration, a few broader lessons stuck with me:

• AI coding agents are force multipliers, not replacements.
  I couldn't have done this migration without understanding what I wanted at a high level. The AI didn't make the architectural decisions—I did, with its help. But the execution? That's where the agents shined. They turned weeks of tedious implementation into days of focused conversation.
• The workflow matters more than the tool.
  Whether you use Copilot, Cursor, Claude directly, or something else entirely, the principles are the same: plan thoroughly, break work into independent packages, parallelize what you can, and always verify manually. The specific tool is less important than the discipline of the process.
• Context switching got easier, not harder.
  I stretched this migration over several weeks, working on it in spare moments between research. Normally, getting back into a half-finished coding project after a break is my personal nightmare. But with Copilot, I could just open a new chat, point it at the relevant issue and branch, and say "where were we?" Within minutes, the agent had re-read the context and we were productive again.
• Building from scratch is now a viable choice for non-developers.
  I'm a computer vision researcher, not a web developer. My CSS knowledge before this project was basically "copy-paste from Stack Overflow and pray." But AI coding agents filled in the gaps. I learned an enormous amount—not just by reading the code they wrote, but by asking why they made specific choices. It was like having a patient, always-available tutor who also happened to write production-quality code.

From 75 ILS to Zero (and So Much More)

The cost savings are nice, sure. But the real win is something harder to quantify: I actually enjoy working on my website now. Adding a new blog post is trivial. Updating my publications list takes minutes. Tweaking the design doesn't require navigating three layers of WordPress admin menus and hoping a plugin doesn't interfere.

For years, my website was this thing I dreaded touching. Now it's a project I actively want to improve. That shift—from dread to enthusiasm—is the real story here. And it happened because the tools finally caught up with the ambition.

As a kid, I spent my nights chatting on ICQ (if you know, you know). Those marathon chat sessions where you'd solve all the world's problems one message at a time? This migration felt exactly like that—except instead of debating which X-Men character was the strongest, I was building a website. Same energy, better output.

If you've been putting off a project because it feels too technical, too tedious, or too daunting—try having a conversation with an AI about it. You might be surprised how far a good chat can take you. A few resources I found genuinely useful along the way: the GitHub Copilot documentation, the example prompts cookbook, and this 2026 guide to maximizing Copilot's agentic capabilities.