Throughout the history of software engineering, we have witnessed several massive “forks” that completely changed how applications are designed. If the previous decade was a battle to define display platforms, today, we are entering a much deeper shift: A change in the nature of the user.
1. Web vs. Mobile: The Battle of Display Platforms
Between 2010 and 2018, the smartphone boom divided the software industry into two distinct paths.
-
- Web Application: Browser-based applications, flexible, and cross-platform (e.g., Google Docs).
-
- Mobile Application: Native applications installed on devices, maximizing hardware for smooth experiences (e.g., Instagram).
At that time, the biggest headache for tech companies was choosing a strategy: Web-first, Mobile-first, or both? However, whether Web or Mobile, the ultimate destination was the same: Serving human eyes and fingers. Software design in this phase revolved around UI/UX (User Interface and User Experience).
2. The Paradox of the Decade: The Resurgence of the Command Line (CLI)
Recently, a fascinating and paradoxical phenomenon has been unfolding. In an era where graphical user interfaces (GUIs) are designed to be sleeker and more animated than ever, top tech companies are pouring millions of dollars into developing… black-and-white screen tools (CLI – Command Line Interface).
Not only pure DevOps tools like Docker, Terraform, or Kubernetes, but even platforms famous for their beautiful Web interfaces like GitHub (gh), Stripe (stripe-cli), Vercel, or Supabase are sequentially releasing their own CLI applications.
Why is this happening? CLIs are inherently dry, lack clickable buttons, require users to memorize commands, and are entirely unfriendly to the general public. If the goal is solely to serve humans, GUIs are undoubtedly the optimal choice.
What exactly is this massive investment targeting?
3. The Real Reason: Software Is No Longer Just for Humans
The answer lies in an emerging truth: Today, humans are no longer the only “entities” using software.
Numerous automated systems, CI/CD pipelines, scripts, and especially AI Agents (autonomous artificial intelligence) are becoming the new “customer” base for tech platforms. For these systems, a dazzling graphical interface is completely useless.
CLIs and APIs possess characteristics that make them ideal interfaces for machines:
-
- Automation Capability (Scripting): A pipeline can run git pull, docker build, terraform apply thousands of times a day without a single mouse click.
-
- Standardized Data Format (Machine Readability): CLIs output results in plain Text or JSON, making it easy for other programs to read, understand, and process further.
-
- “Blind” Environment Operation (Headless): Runs smoothly on Linux servers without any graphical interface.
4. The New Divergence: Human Software vs. AI-Agent Software
We are witnessing a new branch, deeper than the Web/Mobile battle of the past:
-
- Software for Humans: Focuses on sensory experience, UI/UX, drag-and-drop operations (Notion, Figma, Slack).
-
- Software for Machines (Software for AI & Automation): Optimized for speed, machine readability, APIs, and CLIs.
This shift leads to an entirely new software architecture model, often called “API-First”:
Core Engine ➔ API (For AI/Systems) ➔ CLI (For Developers/Automation) ➔ GUI (For End Users).
In this model, the GUI (web/app interface) is essentially just a “shell” layered on top to serve humans. The core of the software now communicates via commands and data.
5. The Future of Software
In the coming years, we can expect a surge in applications adopting an AI-native philosophy.
Fundamentally, this entails:
- Software engineered to prioritize AI as the primary user
- Humans acting primarily as overseers or interacting only through high-level dashboards
This shift could pave the way for an ecosystem where:
- AI agents autonomously handle server deployments
- AI agents independently write, review, and modify code
- AI agents take full control of system administration
In such a landscape, CLIs and APIs will naturally serve as the core language facilitating machine-to-machine communication.
Conclusion
Major paradigm shifts have always been the engine of software history. While the past decade was defined by the split between web and mobile, today’s landscape is being reshaped by a new dichotomy: software tailored for people versus software optimized for AI agents. The rising dominance of CLI tools is by no means a downgrade in user-centric design, but rather a reflection of an undeniable truth: software operations are increasingly being driven by automated systems and machines rather than just human hands. Ultimately, it is highly probable that the next generation of software will be built for AI first, and humanity second.