Building CLI Apps for the Future Workforce (AI Agents)
Building CLI Apps for the Future Workforce (AI Agents)
The way we build apps is changing.
The next wave of "users" won't always be humans clicking buttons. A large part of the future workforce will be AI agents—running tasks, chaining tools, retrying on failure, and shipping work end-to-end.
While building multiple automation and AI-powered tools, one thing became very clear to me:
If you want AI agents to use your product reliably, build a CLI.
Why AI agents change how we should build apps
According to multiple industry reports, AI agents are expected to automate 15–50% of knowledge work by 2027, with companies already reporting:
- ~55% efficiency gains
- ~30–35% cost reduction
Source: https://www.wearetenet.com/blog/ai-agents-statistics
Salesforce's CEO has publicly stated that AI systems are already doing 30–50% of work internally at Salesforce.
This shift changes a core assumption:
Software is no longer built only for humans.
- AI agents don't need dashboards.
- They need tools.
Why CLI is the best interface for AI agents
A CLI is the most agent-friendly interface we have today.
AI agents are very good at:
- executing commands
- passing arguments
- parsing structured output
- retrying failed steps
- chaining multiple tools together
A simple command like:
mytool generate --input notes.md --output slides.pptx
is far more reliable for an agent than navigating a UI or guessing what a button does.
In practice, a CLI becomes: an API with zero ambiguity.
This is the future workforce
The future workforce looks like this:
- humans defining goals
- AI agents executing steps
- tools doing the actual work
Research shows that ~79% of organizations are already adopting AI agents, either in pilots or production.
Source: https://www.wearetenet.com/blog/ai-agents-statistics
As this grows, tools that are scriptable, predictable, and composable will win.
That's exactly what a good CLI provides.
What I learned while building CLI tools
While building and using CLI tools in real workflows, a few lessons stood out very clearly.
1. Simple commands matter more than features
Agents break when commands are vague.
Bad:
mytool
Good:
mytool generate --input file.md
One command should do one job. No guessing.
2. Deterministic behavior is critical
Same input should always produce the same output.
Agents fail when:
- output formats change
- behavior depends on hidden state
- errors are unclear
Predictability > cleverness.
3. CLI is not a dev toy, it's a contract
I now treat CLI design the same way I treat API design:
- explicit flags
- clear outputs
- meaningful exit codes
This makes the tool safe to automate at scale.
4. Distribution matters: skills.sh
Once the CLI works well, listing it on platforms like https://skills.sh becomes important.
Why?
- agents discover tools there
- tools become reusable "skills"
- workflows can reference them programmatically
If agents can't discover your CLI, they won't use it—no matter how good it is.
This mirrors how humans install packages from npm or pip. Agents are starting to do the same with skills.
Why CLI + skills is a powerful combo
Agent ecosystems are evolving around skills—reusable capabilities agents can install and run.
Vercel describes agent skills as modular capabilities that agents can invoke as needed: https://vercel.com/blog/agent-skills-explained-an-faq
A CLI packaged as a skill becomes:
- installable
- executable
- composable
- reusable across agents
This is how agent tooling ecosystems will scale.
The real takeaway
We're not just building apps anymore.
We're building infrastructure for AI workers.
And right now, the most reliable interface for those workers is:
- simple commands
- predictable behavior
- clear outputs
That's why I'm bullish on CLI-first tools.
Not because they're old-school—but because they're agent-native.