guide · computers

Terminal Commands Versus Python: When an Agent Should Write a Script

When to use one-liner terminal commands and when to write a 5-line Python script. The trade-off is readability and verifiability, not tool sophistication. Five signals that tip the choice.

July 14, 2026 · By Alastair Fraser

A friendly retro robot standing between two desks — a TERMINAL DESK on the left with a single shell prompt running one-line commands, and a PYTHON DESK on the right with a small script editor showing five lines of logic. The robot points at whichever desk fits the task, with a small flowchart floating above the scene.

The trade-off in one sentence

Terminal commands are read-and-run; Python scripts are read-and-think. Pick terminal when the task is one-shot and the output fits the shell’s quoting. Pick Python when the task is repeated, the output needs processing, or the logic branches.

This is not a sophistication argument. Both are first-class. The question is which is faster to read, easier to verify, and easier to revert.

Five signals that tip the choice

Signal	Tip toward	Why
Single command, single response	Terminal	One-liner; no logic
Looping, iteration	Python	Bash loops are unreadable
Output needs parsing	Python	Regex in bash is a footgun
Conditional logic (if/else)	Python	Bash `[[ ]]` chains break
Reusable across sessions	Python	Terminal scripts evaporate

Examples of each

Terminal — one-shot, no logic:

curl -sS -I https://agenticbotsitter.com/ | head -1
ls -la /var/www/agenticbotsitter/ | grep -E "\.html$"
df -h | grep "/dev/root"

These are read-and-run. The agent can verify them by inspection in milliseconds. No state.

Python — when the logic branches:

import subprocess, json
result = subprocess.run(["git", "ls-remote", "origin", "refs/heads/main"],
                        capture_output=True, text=True)
sha = result.stdout.split("\t")[0].strip()
print(json.dumps({"origin_sha": sha}))

The Python script doesn’t earn its keep on size alone — it earns it on testability. You can run this script, check the output, and trust the result. The terminal version is harder to verify because the shell parsing is implicit.

The “could you verify by re-reading?” check

After writing any “5”-plus-line command, ask: could the operator verify this by re-reading alone? If the answer is “no — too much shell quoting / too many conditional branches,” it should be Python. If the answer is “yes — I can see each step,” terminal works.

Terminal commands over “5” lines start hiding bugs in their own length. The “5”-line rule is empirical, not absolute.

When terminal wins

One-shot operations. grep, find, wc, tail -f, curl -I, ls -la.
Standard utilities you trust. git, npm, pip, cargo, docker. These have well-tested edge case handling.
Quick verification. git status, npm run build, pytest.
Streaming / interactive. tail -f, vim, less. Python isn’t a good replacement.
System state. ps aux, kill, journalctl. These talk to the kernel.

When Python wins

Multi-step with branching. Conditional logic, error handling, retries.
Output processing. Parsing JSON, XML, CSV; transforming data shapes.
Reusable. When the script will run again, writing it down saves the next time.
Testable. When there’s a clear input → output contract, Python is testable.
Complex shell escaping. When $ and ' and " start multiplying, switch.

What the agent should NOT do

Don’t write Python for one-liners. It’s overkill; readability goes down.
Don’t write bash for branching logic. Conditional chains break under load.
Don’t inline both. If the task does both — terminal I/O and Python processing — write a Python script that calls subprocess rather than mixing in the shell.

The hermes venv rule

On this VPS, Python means /opt/hermes/.venv/bin/python. The venv has openai, requests, pillow, and other libraries that the agent uses for image gen + web tasks. Use the venv path explicitly; the system python3 may not have what you need.

# Right
/opt/hermes/.venv/bin/python script.py

# Wrong
python3 script.py      # wrong interpreter
./script.py            # depends on shebang

The script’s shebang line should also point at the venv:

#!/opt/hermes/.venv/bin/python3

Verification checklist

#	Question	Rule
1	Is this a one-shot or a script?	One-shot → terminal
2	Does the output need processing?	Yes → Python
3	Could the operator verify by re-reading?	No → Python
4	Is this code that runs again?	Yes → Python
5	Am I using the right Python interpreter?	Yes → /opt/hermes/.venv/bin/python