How I Upgraded My Personal Website Using AI in One Session

Introduction

If you’re a tech professional, you probably know the feeling: you built your personal website years ago with the best intentions of keeping it updated, and then… life happened. My Hugo-based blog had been gathering digital dust since 2018. The theme was outdated, the deployment process was manual, and every time I thought about updating it, the sheer amount of work ahead made me postpone it for another month.

Last week, I decided to try something different. Instead of blocking out a weekend to tackle the modernization, I sat down with Google’s Antigravity (powered by Gemini 3.0 Pro and Claude Sonnet 4.5) and asked, “Can we upgrade this entire site today?”

Spoiler: We did. Here’s how it went.

The Starting Point: A Snapshot of 2018

My website wasn’t broken—it still served its purpose—but it was showing its age. I was running a legacy Hugo template that had been deprecated years ago. The deployment process involved manually running commands, copying files, and pushing to GitHub. There was no automation, no CI/CD, and honestly, no clear documentation on how I’d even set it up back then.

The posts were outdated, the theme had compatibility issues with newer Hugo versions, and the whole setup felt fragile. I knew that if I didn’t modernize it soon, it would become a “legacy system” I’d be afraid to touch.

Sound familiar?

The Decision to Use AI Assistance

I’ve been following the AI development tools space with professional interest. The scope was clear:

Migrate to a modern Hugo template
Modernize the development workflow
Set up proper automation and CI/CD
Make the site portable (easy to work on from any machine)
Improve performance and user experience

Could AI help me do this in one sitting? I was genuinely curious.

The Modernization Process

Theme Migration: The Foundation

The first task was migrating away from the legacy theme. I asked the AI to help me find and set up a modern Hugo template that was actively maintained and had good documentation.

What impressed me was how the AI didn’t just point me to documentation—it actually walked me through the process. “Let’s create a fresh Hugo site structure,” it suggested, “and then migrate your content piece by piece so we can verify each step.”

This methodical approach saved me from the classic mistake of trying to do everything at once and ending up with a broken site. We migrated the blog posts, set up the author profile, and configured the homepage—all while keeping the development server running so I could see changes in real-time.

Lesson learned: AI is excellent at breaking down complex tasks into manageable steps.

Building a Modern Development Workflow

I already had a Makefile for my site, but it was basic. The AI helped me enhance it with more robust commands and better error handling:

make check    # Verify all dependencies are installed
make setup    # Set up the entire environment from scratch
make watch    # Local development with live reload
make build    # Production build
make deploy   # Deploy to live site

We set up dependency management using Mise (my suggestion, based on my preference for modern tooling), which handles Go, Python, Node.js, and Hugo versions automatically.

Here’s what that looks like in practice:

check:
    @echo "Checking development environment..."
    @command -v git >/dev/null || echo "❌ Git not found"
    @command -v hugo >/dev/null || echo "❌ Hugo not found"
    @hugo version | grep -q extended || echo "⚠️  Hugo Extended required"

What AI made possible: I described what I wanted in plain English (“I want new developers to run one command and know if they’re ready to work”), and the AI translated that into working automation.

Setting Up CI/CD

I wanted the flexibility of both manual and automated deployments. Manual control for when I’m experimenting, automated for the main branch.

The AI helped me set up GitHub Actions for both scenarios. What could have taken me hours of reading GitHub Actions documentation and debugging YAML syntax errors was done in about 20 minutes of conversation.

We created two workflows:

A manual trigger for when I want to deploy from any branch
An automated deployment on pushes to main

The AI even suggested adding build caching to speed up deployments. These are the kinds of best practices that I know exist but often skip when rushing to “just get it working.”

I wanted a clean, minimal design focused on content and performance. The AI helped me:

Simplify the navigation menu
Remove unnecessary visual elements
Optimize for fast page loads
Ensure mobile responsiveness

The realism check: Not everything worked on the first try. Some configuration changes needed iteration, especially when dealing with theme-specific settings. But the feedback loop was fast enough that it felt collaborative rather than frustrating.

What AI Assistance Actually Looks Like

Let me be honest about what AI did and didn’t do in this project.

What AI Excelled At

Configuration without context-switching: Instead of reading Hugo documentation, Makefile syntax guides, and GitHub Actions references in different tabs, I stayed in one conversation. The AI pulled from all that knowledge and gave me working examples.

Troubleshooting with context: When Hugo threw an error about incompatible versions, I just pasted the error. The AI recognized it immediately and suggested the fix. These kinds of environment-specific issues usually take me an hour of Googling.

Best practices made easy: The AI helped me quickly adjust configuration files like .gitignore to follow current best practices. These small touches add up to a more professional setup.

Iterative refinement: When my first request wasn’t quite right, I could refine it in natural language. “Actually, make the menu simpler” or “Adjust the header alignment” were immediately understood and implemented.

Where I Still Needed to Step In

Design decisions: The AI could implement my vision, but it couldn’t create the vision itself. I had to decide what “clean and minimal” meant for my site.

Final review: I read every line of configuration, every blog post update, and every deployment script. AI accelerated the work, but I remained the reviewer and decision-maker.

Understanding the output: When I suggested using Mise for dependency management, the AI helped me configure it properly and explained the benefits over manual version documentation. Understanding the reasoning behind technical decisions helps me maintain the site long-term.

The Results

After about 4-5 hours of work (with breaks), I had:

✅ A modern Hugo blog running the latest template
✅ Automated deployment via GitHub Actions
✅ Portable development environment (clone, run make setup, start working)
✅ Clean, fast-loading design
✅ Comprehensive documentation in README.md
✅ CI/CD pipeline with proper caching
✅ Dependency management and environment validation

More importantly, I now understand the setup well enough to maintain it myself. The AI didn’t just do the work—it explained the reasoning behind each decision.

Key Takeaways

1. AI is a Co-Pilot, Not Autopilot

The most productive moments came when I clearly articulated what I wanted and then collaborated on the implementation. The AI didn’t make strategic decisions for me—it accelerated the tactical execution.

2. The Feedback Loop is the Superpower

When something didn’t work, I could immediately ask “Why didn’t that work?” and get a thoughtful explanation. This tight feedback loop is what made the session productive. Compare this to traditional debugging: Google the error, read Stack Overflow, try a fix, repeat.

3. Domain Knowledge Still Matters

I could evaluate whether the AI’s suggestions were sensible because I understand Hugo, deployment pipelines, and web development. If I’d been working in a completely unfamiliar domain, I’d have needed to be much more cautious.

4. Best Practices Become Accessible

Things like CI/CD pipelines, dependency pinning, and environment validation used to be “nice to haves” I’d add later (read: never). With AI assistance, the activation energy for doing things properly the first time is much lower.

5. Documentation is Still Critical

Even with AI help, I created thorough documentation. Future me (or any contributor) needs to understand the system without relying on AI to explain it again.

What This Means for Technical Work

This experience changed my perspective on AI-assisted development. I’m not replacing my skills—I’m amplifying them. The mundane parts (reading docs, writing boilerplate, debugging syntax errors) happen faster, leaving more mental energy for the interesting parts (architecture decisions, user experience, strategic choices).

For technical leaders, this raises interesting questions:

How do we evaluate productivity when AI can 10x certain types of work?
What skills become more valuable in an AI-assisted world?
How do we maintain code quality when AI can accelerate both good and bad practices?

My take: The human judgment layer becomes more critical, not less. Anyone can ask AI to “build me a website.” Understanding whether the result is maintainable, secure, performant, and aligned with your goals—that’s still on us.

Should You Try This?

If you have a personal project that’s been on your “someday” list, give AI-assisted development a try. Here’s my suggested approach:

Start with a well-defined scope: “Modernize my website” worked because I knew what modernization meant. Vague goals lead to vague results.

Stay engaged: Don’t just copy-paste AI suggestions. Ask “Why this approach?” and “What are the trade-offs?” Understanding the reasoning makes you better at evaluating future suggestions.

Iterate quickly: If something doesn’t work, say so immediately. The conversation flow is the advantage—use it.

Review everything: AI accelerates work but doesn’t replace judgment. Read the code, test the features, understand the architecture.

Document for humans: Write documentation that explains the “why,” not just the “what.” Your future self will thank you.

Conclusion

I started the day with a dusty 2018 website and a vague plan to “fix it someday.” I ended with a modern, automated, maintainable blog that I’m genuinely excited to use again.

AI didn’t replace my technical skills—it eliminated the friction that was preventing me from applying those skills. The tedious parts became fast, which made the interesting parts more accessible.

Is this the future of development? I think it’s part of it. The best developers have always been good at leveraging tools to amplify their abilities. AI is just the latest (and most powerful) tool in that tradition.

The question isn’t whether to use AI assistance. It’s how to use it effectively while maintaining the judgment, creativity, and strategic thinking that makes our work valuable.

What are your experiences with AI-assisted development? Have you tried using AI for complex technical projects? I’d love to hear your thoughts—connect with me on LinkedIn or X/Twitter.