Kelsey Hightower recently pushed back on AI agent hype, reminding us that agents are “just software dealing with data.” Kelsey is a smart person with a ton of experience who I respect and even hero-worship a bit. He’s not wrong. But he’s not entirely right either.
DevOps engineers are drowning in “AI will replace you” headlines. Alert fatigue is real. The pressure to adopt AI everywhere is exhausting. But here’s the thing: the future isn’t AI agents OR shell scripts. It’s both. And that’s boring in the best way possible.
The AI Agent Hype Cycle (And Why Engineers Are Exhausted)
The market tells one story: AI agents projected to grow from $7.84 billion in 2025 to $52.62 billion by 2030. Every vendor pitches their AI agent as the thing that will replace your entire ops team, and keep the breakroom coffee fresh.
The reality is messier. DevOps engineers are experiencing AI fatigue. Not because AI agents don’t work, but because the hype obscures what they’re actually good for.
Kelsey’s right to call this out. Agents are software. They deal with data. They’re not magic. But dismissing them as “just software” undersells something important: nondeterministic automation is qualitatively different from what came before.
Shell Scripts Aren’t Dead (And Never Will Be)
The UNIX philosophy still works: do one thing well, make tools composable. Shell scripts embody this perfectly.
Why shell scripts remain powerful:
- Deterministic: Same input always produces the same output
- Transparent: You can read exactly what happens
- Universal: Runs anywhere with a shell
- Fast: No model inference overhead
Shell scripts win when you need:
- CI/CD pipelines
- System initialization
- Cron jobs and scheduled tasks
- Infrastructure provisioning
These aren’t going away. If anything, they’re more important than ever as a foundation layer.
Where AI Agents Actually Excel
Nondeterministic automation adapts. It learns. It decides based on context.
Real AI agent strengths:
- Pattern recognition across massive log datasets
- Predictive maintenance that catches issues before they escalate
- Context-aware decisions like “should I deploy now or wait?”
- Natural language interfaces for expressing intent, not scripting steps
AI agents win when you need:
- Complex decision trees with many variables
- Incident triage and root cause analysis
- Adaptive deployment strategies
- Handling unexpected scenarios
The difference isn’t subtle. It’s the difference between following a recipe and improvising based on what’s in your fridge.
Deterministic vs Nondeterministic: A Framework
| Deterministic (Shell Scripts) | Nondeterministic (AI Agents) |
|---|---|
| Predictable outcomes | Variable outcomes based on context |
| Rule-based logic | Learning-based decisions |
| Transparent execution | ”Black box” inference |
| Fast, lightweight | Slower, resource-intensive |
| Fails on unexpected input | Adapts to new scenarios |
| Best for: Known workflows | Best for: Dynamic environments |
Most real-world automation needs both.
The Boring Middle: Why the Pendulum Will Balance
Kelsey predicts we’ll rediscover the UNIX philosophy. I think he’s half right. We won’t abandon AI agents. We’ll integrate them.
The pattern emerging in production systems:
- Shell scripts handle deterministic steps
- AI agents handle dynamic decisions
- Both work together
Example workflow:
- Shell script: Pull latest code, run tests (deterministic)
- AI agent: Analyze test results + system health → decide deploy timing (nondeterministic)
- Shell script: Execute deployment steps (deterministic)
- AI agent: Monitor for anomalies, trigger rollback if needed (nondeterministic)
Camunda research backs this up: “Deterministic automation will remain in control of the core long-running process, while AI models will support bursts of insight and efficiency.”
The boring middle isn’t compromise. It’s synthesis.
Lessons from the Pendulum Swing
Technology pendulums always swing to extremes before balancing.
We saw it with microservices. “Everything should be a microservice!” turned into “Maybe not everything needs to be a microservice.”
We saw it with NoSQL. “SQL databases are obsolete!” turned into “SQL databases are still great for many use cases.”
Now we’re seeing it with AI agents. “AI will automate everything!” will turn into “AI agents complement existing tools.”
Boring middle means:
- Using the right tool for the job
- Not chasing hype
- Incremental improvement over revolution
- Boring equals reliable, maintainable, understandable
Practical Guidance: When to Use What
Use shell scripts when:
- ✅ The workflow is well-defined and rarely changes
- ✅ You need transparent, auditable execution
- ✅ Performance and low overhead matter
- ✅ The task is simple and deterministic
Use AI agents when:
- ✅ You need pattern recognition across large datasets
- ✅ The environment is dynamic and unpredictable
- ✅ Human-like decision-making adds value
- ✅ You want predictive capabilities (not just reactive)
Use both when:
- ✅ Core workflows are deterministic but need adaptive decision layers
- ✅ You want guardrails (scripts) with intelligence (agents)
- ✅ Building production systems (most real-world cases)
Why Kelsey’s Right (And Wrong)
Kelsey’s right:
- AI agents are just software
- Demystifying the hype is healthy
- Engineers shouldn’t feel pressured to adopt AI everywhere
Where I respectfully disagree:
- Dismissing agents as “just software” undersells their unique capabilities
- Nondeterministic automation is qualitatively different from shell scripts
- The glossary he wants already exists: it’s deterministic versus nondeterministic
The Future Isn’t Either/Or
In two or three years, the question won’t be “AI or scripts?” It will be “How much of each?”
The best automation systems won’t be revolutionary. They’ll be boringly reliable. They’ll use shell scripts for deterministic foundations and AI agents for adaptive decisions on top.
The pendulum will swing back toward simplicity. But it won’t land where it started. It will land in the middle, where both approaches coexist.
That’s not sexy. It’s not a hot take. But it’s where success lives.