Building a Personal Website: A Dialogue with AI

January 31, 2026

This website wasn't built by writing lines of code one by one. It was built by having a conversation.

In this post, I'll share the exact process and prompts I used with the Gemini CLI agent to build this site from scratch, maintain it, and deploy it to the cloud.

Phase 1: The Foundation

I started with a clear goal: replace my old site with something modern but simple. I wanted full control over the backend without the complexity of a heavy frontend framework.

My Prompt:

https://yichen.io/ is my current personal website. I want to create a brand new one with a similar content structure, but better looking and simpler. Start from scratch.

Initially, the agent suggested Next.js. I steered it towards my preferred stack.

My Prompt:

I find React too complex... I want my backend to be in golang.
How's the templating work? I want some sort of markdown involvement

The Result:
The agent immediately pivoted. It deleted the React files and scaffolded a Pure Go server using html/template and goldmark for Markdown rendering. It set up the directory structure, main server loop, and basic template files—all in a matter of seconds.

Phase 2: Visual Improvements

The site was functional, but visually plain. Instead of writing CSS classes manually, I asked the agent to act as a designer.

My Prompt:

Make the first page look better
Use a 3x3 grid for the skills section. Make it look premium.

The Result:
The agent generated complex Tailwind CSS layouts automatically. It created a responsive grid for my skills, added hover effects, and picked a clean typography hierarchy. I didn't have to look up a single Tailwind utility class.

Phase 3: Extending the Site (The Games Page)

I wanted to add a personal touch—a page dedicated to the games I play. This wasn't just about text; I needed images and a specific layout.

My Prompt:

Create a new page /games. I want to list the games I'm currently playing: Diablo IV, Path of Exile 2, and League of Legends.
Find appropriate cover art for these games and display them in a responsive card grid.

The Result:
The agent:

  1. Created content/games.md.
  2. Updated the Go handler to route /games.
  3. Searched for high-quality cover art for each game.
  4. Generated the HTML/Tailwind code to display them in a grid with overlay text.

It handled the full stack change: content, backend, and frontend.

Phase 4: When Things Go Wrong (Debugging)

AI isn't magic; sometimes things break. But the debugging process is also conversational.

On my "Misc" page, I noticed a link wasn't working. It looked like a link, but clicking it did nothing.

My Prompt:

The 'Read article' link on the misc page is not clickable. Debug this.

The Result:
The agent analyzed the HTML structure and CSS. It found that a container div had a negative z-index or was being overlaid by another element. It applied a fix to the CSS, and the link worked immediately.

Case 2: Silent Email Failures

I wanted a contact form that emailed me directly using net/smtp. It worked locally but failed silently in production.

My Prompt:

I'm not receiving emails from the contact form. Check the environment variables.

The Result:
It realized that while my code was correct, the GMAIL_APP_PASSWORD wasn't being passed to the container correctly. It advised me on how to set the environment variable in the Cloud Run console, ensuring the app could authenticate with Gmail.

Phase 5: Going Live (Cloud Run)

Deployment used to be a chore of writing Dockerfiles and YAML configs.

My Prompt:

Deploy this application to Google Cloud Run. Map it to yichen.io.

The Result:
The agent:

  1. Wrote a multi-stage Dockerfile optimized for Go.
  2. Built the container image using Google Cloud Build.
  3. Deployed the service to Cloud Run.
  4. Guided me through the domain mapping process for yichen.io.

Conclusion

This project demonstrates a shift in how we build software. I acted as the Architect and Product Manager, defining the what and why, while the Gemini CLI acted as the Engineer, handling the how.

The result is a clean, fast, and maintainable Go application that I understand perfectly—built in a fraction of the time it would have taken me alone.