Automation9/27/2026

From Excel VBA to AI: Why I Enjoy Automation

How reducing repetitive work took me from Excel formulas, VBA and PML into Python, Bash, PowerShell, bots, server automation, and eventually AI agents.

Looking back at my journey in technology, one pattern appears repeatedly: I do not particularly enjoy performing the same task over and over when a computer could potentially help automate it.

That may be where my interest in automation truly began.

It started without complicated terminology. I was simply working with data and Microsoft Excel. Engineering work can involve significant amounts of information: drawings, materials, work status, progress, and many other datasets that need to be checked and organized.

A manual process may be acceptable when performed once. But when the same activity must be repeated dozens or hundreds of times, efficiency becomes important.

I began exploring Excel formulas more deeply, moving from simple calculations toward combinations of formulas for checking, matching, grouping, and processing information.

Then I discovered macros and VBA.

Excel was suddenly more than a spreadsheet. VBA allowed me to instruct the computer to execute sequences of operations automatically.

Processes requiring many clicks could become automated workflows. Data could be read, processed, reorganized, and transformed into useful outputs.

This experience became one of my entry points into programming.

In engineering environments, I also encountered PDMS and PML. PML was particularly interesting because scripting could directly support engineering applications.

I began recognizing the relationship between domain knowledge and programming. Someone who understands the work knows what should be automated. Programming becomes the tool for translating that knowledge into processes a computer can execute.

When I began experimenting with Linux and servers, my automation requirements changed again.

I frequently needed to repeat commands for installations, directory creation, permissions, services, updates, and backups.

This made Bash scripting increasingly valuable.

Instead of manually executing ten or twenty commands during every deployment, I could organize them into scripts that checked dependencies, created directories, copied files, configured permissions, installed packages, started services, and verified application health.

On Windows, PowerShell provided similar capabilities for development environments, file management, WSL, project launchers, and other workflows.

Python expanded these possibilities further.

It allowed me to experiment not only with simple scripts, but also bots, APIs, data processing, server tools, and applications.

Automation gradually moved from being a personal productivity tool into becoming part of the architecture of projects I built.

I developed the principle that applications should ideally be easy to install and update. Whenever possible, users should not need to perform excessive manual configuration.

This encouraged me to experiment with deployment scripts, update mechanisms, backups, restores, health checks, and other application-lifecycle tools.

Bots introduced another level of automation.

A Telegram bot, for example, can become an interface for server monitoring. Instead of connecting through SSH simply to inspect server health, CPU, RAM, disk, uptime, and service information can be delivered through messaging.

Notifications can also alert users when services experience problems.

Eventually, my attention moved toward Artificial Intelligence.

I initially used AI in familiar ways: asking questions, requesting explanations, conducting research, and assisting with coding.

But I began seeing a larger possibility.

Traditional scripts follow rules we explicitly define. AI can interpret natural language and context. What happens when these two capabilities are combined?

That question led me toward AI agents.

An AI agent becomes especially interesting when it does more than generate text. It can understand requests, determine steps, use permitted tools, retrieve information, perform actions, and return results.

This thinking contributed to experiments such as ARCLAW.

I wanted to understand how WhatsApp could become an interface for an agent. How does it identify authorized users? How should memory work? How are tasks scheduled? How can tools be safely exposed? How should system commands be restricted?

These questions demonstrate that modern automation is about much more than scripting.

Authentication, authorization, security, APIs, runtime management, memory, logging, scheduling, and error handling all become important.

The more I experiment, the more I realize that the journey from Excel VBA to AI agents has always had the same fundamental objective.

I want computers to handle processes that can reasonably be automated.

The technology changes. It started with formulas, followed by macros and VBA, PML, Bash, PowerShell, Python, bots, APIs, and now AI agents.

But the fundamental question remains the same: which repetitive tasks should no longer require continuous manual human effort?

I do not view automation as a way to eliminate the human role. I see it as a way to use human time more effectively.

Computers are excellent at structured and repetitive work. People can spend more time understanding problems, making decisions, being creative, and deciding what should be built.

That is why automation continues to interest me. Whenever I encounter a repetitive process, I almost always ask the same question:

Can this be simplified? Can a computer help do it?

Very often, that simple question becomes the beginning of my next project.

ExcelVBAPMLPythonPowerShellBashAIAutomation