5 Ways AI Has Actually Saved Me Time on My Computer

Since OpenAI burst onto the scene at the end of 2022, the world seems to have entered the AI era. People’s reactions—ranging from initial disdain for AI to later astonishment at its capabilities and fear that it might replace humans—are all emotional and not entirely rational. AI cannot fundamentally alter the nature of the world; after all, it is ultimately just a man-made product, and nothing created by humans can fundamentally replace what nature has created. But that doesn’t mean it’s useless—it’s actually quite powerful, especially in areas where it excels, particularly in computing. Because it’s essentially a computer program, having a computer handle itself is the perfect fit!

In this article, I’ll share some scenarios where I’ve found AI to be particularly useful when handling computer-related tasks.

Programming

Since AI is a computer program, it’s natural to use it to assist with programming, and there are already many coding agents available on the market.

I’ve always wanted to try these tools to see how well they can program, but I never had the right opportunity. Recently, I decided to set up my own website to write blog posts, as I feel this is the most flexible option, allowing me to minimize distractions from platforms or other factors. I chose the Hugo framework, which seemed relatively straightforward. But after browsing through its many themes, I wasn’t entirely satisfied with any of them, so I decided to write a simple theme myself. Finally, it was time to put a coding agent tool to the test. In this rapidly evolving and diverse field, I chose OpenCode—an open-source software that’s reportedly ready to use right out of the box.

The download and installation went smoothly, so I started giving it a try. Hmm, it really feels great—it has all the features I need and comes with many free LLM models. Speaking of AI models, choosing the right one is a science in itself. With so many models on the market, how do you pick one that’s both sufficient and cost-effective? I won’t go into that here; I’ll save it for later. Since this is my first time using AI for programming, I randomly picked a well-reviewed model: DeepSeek V4 Flash.

For this project, my initial plan was to first provide OpenCode with the background of the programming project, the key features, and a rough idea of the outcome, so that it could generate a preliminary framework and code. I would then build on that by adding, removing, or modifying elements as needed. I felt that even doing it this way should significantly improve development efficiency. I didn’t bother to craft a sophisticated AI prompt; I just straightforwardly wrote the above content and handed it over to OpenCode to execute. The result completely blew me away!

While carrying out the task, OpenCode clearly explained the reasoning behind each step and ultimately submitted code that looked very promising. I immediately deployed it locally to test it—and guess what? Every feature I requested was implemented correctly! Yes, every single one! I could use it right away with virtually no need to modify the code. Building on that foundation, I fine-tuned various aspects of the code, such as tweaking the project architecture, organizing configuration files, refining the CSS and JavaScript, and optimizing for mobile devices. It only took a few hours, and the project was essentially complete. The theme you see on this website right now is the result.

Although this project was relatively simple, I was truly impressed that the AI was able to implement it completely and correctly. If I had written it myself, it would have undoubtedly taken far more time and effort. And I was using an open-source LLM—if I’d chosen a paid model, the results would certainly have been even better.

Troubleshooting

Once I discovered just how useful OpenCode was, I began using it more and more frequently. I tried using it for all sorts of tasks to see how well it performed, one of which was troubleshooting issues with software I’d already installed.

I used to be pretty clueless when it came to computers, and those days had their ups and downs. The upside was that you could try new software and experience new features almost every day; the downside was that you’d often run into software errors and not know what to do. And when you looked it up online, you’d either fail to find a precise answer, or you’d come across many “experts” looking down on you as a “newbie,” pontificating and pointing fingers—all while refusing to actually solve the problem you’d asked about! This is very rude—even… You just need to know—and this is something I only realized much later—that often, those problems aren’t the user’s fault at all; they stem from the designer’s lack of skill (who, ironically, gets praised for their fame), and sometimes they’re even intentional!

All these problems still exist today, just as they always have! But things have finally improved somewhat—with AI, you can now use it to help troubleshoot issues with the software you’ve installed. Although AI itself comes with its own set of problems, it can at least help you solve those old issues…

A while back, I downloaded and installed a very popular piece of software from GitHub, but as soon as I started using it, a serious issue popped up that had to be resolved immediately for the software to function properly. I searched the official website for a solution and found that someone had already reported this bug; the developer had stated the issue was resolved and closed the thread. However, I also discovered another user had opened a new thread saying the problem still existed. OK.. A familiar story—and this is actually the better case; some software bugs just sit there, left unfixed for years. As usual, I had no choice but to investigate it myself, which rarely goes smoothly. A recurring bug usually means it’s not easy to fix, especially when you’re completely unfamiliar with the new software’s code. In fact, I tried several times without fully succeeding, so I gave up. I already know that my time is the most valuable asset :)

A few days later, it suddenly occurred to me that OpenCode might be able to solve this problem—it’s actually a pretty natural transition from programming tasks to tackling this kind of issue. I gave it a try. As usual, I wrote a prompt describing the problem to the AI and had OpenCode run the task. Immediately, row after row of dizzying command lines began appearing on the screen. After a short while, the results came to light, and the AI clearly pinpointed the source of the problem. I followed its instructions right away, and the problem was perfectly solved!

Later, I reflected on the issue—it was indeed a bit tricky because it was tied to local environment configuration. So it’s understandable that the developers hadn’t fully resolved it. In any case, the fact that the AI can tailor solutions specifically for you is proof enough of its powerful capabilities in this area—it’s a real game-changer.

Configuring

Many software programs derive their power from the flexibility of their configuration options, but sometimes this also means they’re complex and cumbersome. For example, Vim is powerful, and its configuration is complex. Although its author put a lot of effort into creating excellent default configuration files to make it relatively “out-of-the-box” ready, if you want to further customize its functionality, you’ll need to invest a significant amount of time and effort. One of its variants, Neovim, has made improvements in this regard, but its configuration may still be quite complex for beginners.

Now, things are finally different—you can use AI to help you configure software. Even if a piece of software is unfamiliar to you or its configuration is complex, you can use AI to get up and running quickly and easily! Not long ago, I used OpenCode to configure Neovim from start to finish, and I’ve been very satisfied with the results ever since.

Installing

In addition to helping configure installed software, AI can go a step further and help you install software. Of course, installing software is generally quite simple, but in certain situations, things can get a bit trickier.

I currently use Fedora, a distribution of the GNU/Linux operating system, and occasionally need to use the GoldenDict software. This software used to be well-supported in the X11 environment, but Fedora has now completely replaced the old X11 environment with Wayland. Unfortunately, GoldenDict doesn’t support Wayland very well, and recently, it hasn’t even been possible to install it normally from the official repositories. I tried out some alternative software, but wasn’t satisfied with any of them, so I decided to install this software by compiling it from source.

This is quite a technical task; I haven’t installed software developed by others this way in a long time because it’s a painful process. First, you have to consult the software’s official documentation. If the documentation is well-written, that’s fine, but for many software projects, the documentation isn’t really intended for users—it’s written for the developers themselves. When you’ve finally managed to figure out what to do after wading through a tangled mess, the real challenge lies ahead: you start the process. If things go smoothly, you might get it installed on the first try—if things go smoothly… More often than not, you’ll run into all sorts of errors, forcing you to research solutions again and repeat the steps above countless times until you succeed—or fail.

While many software programs have likely improved somewhat in this regard, I don’t want to go through that process again. Thank AI—solutions to these kinds of problems are finally seeing massive improvements. I told OpenCode to check out GoldenDict’s GitHub repository and then compile and install it locally. With just that one instruction, OpenCode set to work on the various tasks, and before long, GoldenDict was successfully installed! I didn’t have to lift a finger the whole time. Although its support for Wayland remains limited—a result of inherent design differences between the two—fully resolving that issue would be a whole other story. So the current situation is acceptable; I’ve been using it ever since without encountering any other problems.

Maintenance

Maintaining software is perhaps even more challenging than the activities mentioned above. This is because maintenance is an almost never-ending process; as long as you use a computer, you’ll always have to maintain its environment. In fact, there’s no “set it and forget it” solution—don’t believe anyone who claims otherwise!

The Python language has its advantages, but configuring its environment is truly a headache. Over the years, the community has introduced one tool after another: pip, virtualenv, venv, conda, uv… When I started using uv, I finally felt they’d gotten it right. But looking back and browsing old web pages, there are far too many pitfalls that trap people, and far too much time and energy wasted for no good reason. Just imagine if you were a beginner entering a software ecosystem that wasn’t quite mature yet…

Fortunately, today you have tools that can largely take over these tedious tasks for you. I turned to OpenCode and had it audit my local Python environment. Then, based on OpenCode’s results, you can have it make various adjustments until you’re satisfied. Simple and effective. That’s my experience.

Conclusion

These are some of the scenarios where I’ve recently found AI to be quite useful. It’s not perfect, but it’s very helpful. Also, readers who’ve made it this far might think I’m quite critical of open-source software. That’s true—I do think there are real issues in this field, but that absolutely doesn’t mean I prefer closed-source software. A big reason I’ve mentioned so many flaws in open-source software in this article is that, in most cases, I actually prefer using open-source software over closed-source software—especially since I distanced myself from Microslop. Of course, that’s not to say all closed-source software is bad. It’s just that sometimes, you really feel like you have no choice. Now, with the advent of AI, the situation has improved somewhat—at least in my experience, it has made Linux less difficult to use, thanks to the intrinsic power and adaptability of the command line. For systems like Microslop, however, the impact is minimal, in the right way… AI itself presents a whole new set of challenges, but that’s a topic for another time.