How ten months of AI-assisted Linux administration gradually turned copy-paste advice into direct access to a real server.
When AI stopped being just a buzzword
I have worked in IT for roughly 30 years. Most of my career has revolved around databases, but for more than a decade I have also administered my own Ubuntu LTS server. It handles backups, media, Home Assistant, and eventually the websites connected to one of my hobbies.
My real entry into AI came only toward the end of 2025. Using AI, I managed to turn dozens of scanned shopping receipts into a structured timeline of purchases and a final consolidated summary.
That was the first time I really raised an eyebrow.
Until then, I had tended to smile at the way the world attached the label “AI” to almost everything. That result convinced me it was time to stop watching from the sidelines and start following the field seriously. I tried Gemini, Copilot, and ChatGPT, and over time ChatGPT became my main tool.
That choice was not without doubts. I also paid for Gemini, and Claude impressed me when it analyzed roughly 2,500 lines of code I had written in a style I would probably never use today: by hand, through trial and error, checking syntax myself and applying various unconventional optimizations in an attempt to gain parallelism and faster processing.
Incidentally, that code has now been running reliably for eight years and still monitors a set of servers from several angles that matter to the services they provide.
Perhaps that is why I had a slightly unusual relationship with AI from the beginning. I never treated it as a magician. I treated it as a new tool whose limits had to be discovered first.
Ten years with your own server teaches caution
Over the years of running my home Ubuntu server, I have gone through countless upgrades, three complete hardware replacements, and one unpleasant SSD degradation where I managed to rescue all the data at the last possible moment. SMART had given me no clear warning that the drive was about to fail.
Anyone who exposes a server to the internet quickly discovers that the romantic image of a greasy-haired hacker sitting in a dark room in front of a flickering CRT belongs mostly to the 1990s.
Today, it is usually automated bots probing you. They sweep the internet for vulnerabilities, exposed services, and machines that can be turned into resources for someone else's attacks.
Suddenly you are tracking Ubuntu updates, Apache, PHP, Joomla, firewall rules, Fail2Ban, packet routing on your home network, and a long list of other things. A hobby gradually turns into a set of obligations, and you begin to understand why paying for hosting and leaving the administration to professionals is often the sensible choice.
But then half the fun would disappear.
So I kept going.
At first, it was just copy and paste
Soon after I started using newer generations of ChatGPT more intensively, I began testing how far AI could be useful in administering an Ubuntu server.
At first, the workflow was completely conventional.
The AI suggested commands. I checked them, pasted them into an SSH session in PuTTY, and copied the output back into the chat.
Over time, we developed a fairly natural working rhythm. ChatGPT would send a set of commands, I would execute them, and I often pasted the terminal output back with no commentary at all. I wanted to see whether the AI would interpret the result correctly on its own, notice an error, or adjust the next step.
It did not take long to learn that the capabilities were impressive, but certainly not flawless.
So I started adding my own rules to the process, following the old principle of “measure twice, cut once.” Before a change came a state check; before a risky operation came a backup; before changing configuration came a way back.
Some of those rules gradually became a natural part of how we worked together.
The safety net existed long before AI
Of course, I did not start thinking about backups because of artificial intelligence.
From the early years of the server, I had been creating Clonezilla images of the system disk before major changes. I mainly used them before Ubuntu upgrades or experiments where I did not feel completely comfortable.
I had also tested the restore process several times in the real world.
On top of that came ongoing backups of critical data and services. Important data is also synchronized off the server to another storage location.
In roughly eleven months of intensive work with AI, I never encountered a situation that forced me to restore the whole system from a Clonezilla image.
Ironically, the closest call came from something completely stupid.
While modifying a menu in Midnight Commander, I accidentally changed permissions on one of Ubuntu's system directories through my own action.
What followed was a repair that took several hours. We mounted the Clonezilla image in a way that allowed us to compare and restore the correct ownership and permissions of system files without rebuilding the entire server.
On my low-TDP homelab machine with an elderly CPU and 8 GB of RAM, this was not exactly a five-minute job.
But it worked.
That moment significantly increased my confidence in AI as a tool for tasks I would have found far harder to solve alone. The alternative would have been a complete system restore followed by rebuilding every change made since the last image.
Sometimes it failed. That mattered.
With each generation of ChatGPT, I also had a very direct way to observe how its capabilities were changing.
Not through benchmarks or tables.
On my own server.
Firewall changes, for example, required particular care because a mistake could cut off the SSH session to a server I could not immediately reach physically. Backup sessions, checking rules before applying them, and thinking through the recovery path before making the change became part of the job.
Over time, I increasingly preferred a workflow where the AI first analyzes the situation and only then proposes an intervention.
Not the other way around.
Another major test was migrating a damaged Home Assistant environment from Docker to a clean Home Assistant OS installation running under KVM on the same Ubuntu server, with dedicated CPU cores.
It was not smooth. We ran into startup, configuration, and network communication problems, and for one part of the process we even used a few prompts with a competing AI system.
Eventually Home Assistant OS was running, the firewall was sorted out, and the Apache reverse proxy worked.
Once again, I realized that tasks which would once have cost me evenings of searching documentation and forums were beginning to be solved in a completely different way.
The helper became a small security system
Over time, we also built a set of Python scripts that perform a regular weekly audit of the server.
They aggregate data from Apache, the firewall, Fail2Ban, disk health through SMART, temperatures, and other operational information. The output is sent through the OpenAI API, where the model compares it with the previous run, looks for changes, and flags things such as new bot activity, unusual login attempts, or a possible deterioration in the security situation.
I then read the result over my morning coffee in a simple HTML interface that we gradually polished a little.
For negligible cost, I ended up with a system that regularly summarizes the state of the server and points out things I would otherwise have to hunt for manually in logs.
At that point, I started asking a different question.
If AI can analyze all of this, why am I still acting as a secretary during every routine operation, carrying text back and forth between the chat and the terminal?
A Joomla incident moved the boundary again
The next major test was a vulnerability that affected my Joomla installation.
With roughly 19,000 files, it does not take long to appreciate how many places there are to hide injected code.
We were still working in the traditional chat-based way, but this time I felt very strongly how useful it would be if the AI could be there directly, examining the system for itself.
Eventually we found the problem and cleaned it up.
Immediately afterward, in the course of a single day, I built another layer of protection based on a Git baseline of the Joomla installation. The system checks PHP file changes every day, classifies them as High, Medium, or Low risk, and sends an email alert when the risk is high. The alerts continue until I review the change manually and confirm it by creating a new baseline.
Later, I used Codex to analyze and modify a Joomla template so the site could be prepared for a newer version of the CMS itself.
That was already a very different level of intervention from generating a simple Bash script.
And it worked.
A real experiment at the edge of trust
Then, one day while browsing new ChatGPT capabilities out of curiosity, I came across Remote Desktop Commander.
Experiments on my laptop gradually led me toward another way of letting AI work with a computer, and an idea began to take shape.
PuTTY on Windows stores connection profiles. I already had a working SSH key and a functioning connection to the Ubuntu server.
Using PowerShell and Plink, I prepared a path through which the AI could connect to my server without me ever typing a password into the conversation. The activity of that connection was logged as well.
After roughly ten months of intensive collaboration, I had reached a boundary that many administrators would consider a hard line:
The AI was no longer supposed to merely tell me what to type into the terminal.
It was going to be allowed to work there itself.
Someone has to walk the path first.
Not “do whatever you want”
Even today, my workflow does not look like this: I type “fix the server” and go to bed.
I start the request in ChatGPT, which knows the context of the system and the way I work. For more serious interventions, we effectively use a two-step model.
First:
analyze the problem; change nothing.
Only then:
propose the implementation.
I review the proposal, adjust it if necessary, and only after that does the working agent receive permission to carry out specific steps on the server.
It is not risk-free.
But neither is server administration performed by a human.
And the risks?
Of course they exist.
They exist in much the same way as when you get into a car in the morning and use it to take you somewhere.
You have a brain and you drive. You wear a seat belt, you have airbags, and you rely on multiple safety systems. You know that something can still go wrong.
That does not mean you stop using a car that saves you time and serves a useful purpose.
That is roughly how I see working with AI today.
It may still be too early to let artificial intelligence take its hands completely off the wheel.
But after what I have seen on my own server over the past months, I no longer wonder whether AI will change the way servers are administered.
What I wonder now is how many administrators quietly crossed this line before I did.
Author's note: This article is based entirely on my own experiences and original notes. ChatGPT was used as an editorial partner to restructure, polish, and translate the original Slovak manuscript.
