I started building websites by writing HTML by hand using one of the most basic tools available: Vim, a simple text editor. You wrote the HTML, saved the file, put it on a web server, and you had a website. It was remarkably simple.
Of course, it was also a pain. If you wanted to change the navigation menu, you might have to edit dozens of files. If you wanted to add a new article, you had to create the page, update the index, and make sure everything looked consistent. The more pages you had, the more tedious the work became.
So we started building software to make it easier.
First came server-side scripting languages like Perl, PHP, and Microsoft's Active Server Pages. Instead of maintaining individual HTML files, we could write programs that generated the HTML for us. We could store content in databases, use templates to keep pages consistent, and dynamically assemble websites in response to requests.
Then came increasingly sophisticated content management systems, blogging platforms, and frameworks. WordPress, in particular, made it possible to publish articles, organize content, manage navigation, and change the appearance of an entire website without touching a line of HTML.
And it worked. What had once required a fair amount of technical knowledge and tedious manual effort became something almost anyone could do.
But somewhere along the way, we also made things considerably more complicated.
Instead of simply retrieving an HTML file, a web server might now need to execute PHP code, query a database, load plugins, and assemble a page before sending it to the visitor. All of that flexibility came with costs, including performance, security, and maintenance.
So naturally, we built more software to address those problems.
We added caching systems so we wouldn't have to regenerate the same pages every time someone visited. We developed performance optimization tools, database optimization tools, and security plugins. We added layers of infrastructure to make the increasingly complicated systems run efficiently and reliably.
There's something wonderfully circular about all of this. We built elaborate software to generate HTML pages dynamically, then built more elaborate software to avoid having to generate those pages dynamically.
Often, after all that work, the optimization was simply to save the resulting HTML and serve it as a static file.
Which brings me to this website.
My old website ran on WordPress. It did its job for years, but it had become dated, and the underlying software needed attention. I wanted to redesign the site, improve its performance, and simplify its maintenance.
Instead of installing another content management system, I decided to see what I could accomplish using Codex, OpenAI's AI coding agent.
I described the website I wanted, reviewed the results, and worked with Codex to refine the design and functionality. It created the pages, styles, navigation, and supporting code. And when something needed to change, I could simply describe the change rather than track down every file that needed editing.
The resulting website is largely what I might have built by hand decades ago: HTML, CSS, JavaScript, and images, with a small build process to keep things organized. There is no WordPress installation, no content database, and no PHP application running every time someone requests a page.
The difference is that I no longer have to do all the tedious work myself.
And that's what I find most interesting about this experience. We've spent decades developing increasingly sophisticated systems to abstract away the complexity of working directly with computers. But now, AI gives us another way to deal with that complexity. Rather than relying on an elaborate application to manage everything, I can use an AI coding agent to work directly with the underlying files.
Of course, static websites and static-site generators are nothing new, and there are plenty of reasons to use WordPress or another content management system. But for a relatively simple website like mine, the tradeoffs have changed.
There's also a certain irony in using an extraordinarily sophisticated AI system to create something as simple as a collection of HTML files. The complexity hasn't disappeared. In a sense, it's moved from the software running the website into the tools used to build and maintain it.
And I think that's a rather interesting development.
After all these years, I've come full circle. I'm back to serving ordinary HTML files from a web server. I can still open them in Vim and edit them by hand, just as I did decades ago.
The difference is that now I don't have to.
My publishing workflow is straightforward: I push the site updates to GitHub from Codex, then deploy by pulling from GitHub on my Linux server and copying the finished static files into the website's directory. The pages are generated before they reach the server, so there is no build step to run there.
The code for this project, including the Python script that generates the pages, navigation, article listings, RSS feed, and sitemap, is publicly available in the NOLAPATENT GitHub repository. You can also find me on my GitHub profile.