What changes when the model has a terminal

Most of the agent hype is about chat. The model says smart things. The model writes code. The model does the thing. That’s the part that demos well.

The part that changes my actual work is that the model has a terminal.

Before terminals, the model was a fancy autocomplete

Before the agent could run shell commands, my workflow with the model was: ask, get code, copy-paste into my editor, run the tests, read the error, paste the error back to the model, repeat. Each cycle was 20-30 seconds of human-in-the-loop. The model was helpful but the loop was slow.

Now the loop is: ask, the model writes the code, the model runs the tests, the model reads the output, the model fixes the bug, the model runs the tests again, the model reports back. The whole loop takes 30-60 seconds and I’m not in it. I check in when the model is done.

The “let it run” reflex is the actual skill

The hard part of working with a tool-using agent is letting it run. Old instinct says “I’ll just do it myself, it’s faster.” For a one-line change, that’s true. For a five-step refactor, it’s not. The agent will run the tests, read the error, fix the bug, and report back. If I jump in after step 2, I’m the bottleneck.

The skill is recognizing when the task is big enough to delegate the loop and small enough that I can review the diff. Tasks that take 1-3 minutes of agent time and produce a diff I can read in 30 seconds are the sweet spot.

What I let the agent run

pytest, npm test, go test, anything that runs my test suite
python -c "import module; module.do_thing()" to verify a single function
grep, find, rg for searching the codebase
git status, git diff, git log to understand the repo state
docker build and docker run for the image-related work
terraform plan (never terraform apply, never)
The agent’s own scripts for spinning up a sandboxed Python venv

What I don’t let the agent run

git push to main or any shared branch. I do that.
terraform apply. I do that.
rm -rf anything outside its own sandbox directory. I added this after a near miss in week 2.
Anything that touches production infrastructure, even read-only. Production reads happen on my screen.
Network calls to APIs I haven’t explicitly approved for the task.
The package manager’s install command for new dependencies. I review the new dependency first, then install it myself. The model can update requirements.txt but it doesn’t run pip install.

The sandbox matters

The agent runs in a sandboxed environment with no network access by default. When the task needs network, I grant it explicitly for the duration of the task. When the task is done, the network grant is gone. This is the part most people skip and then regret.

I learned this from a friend who let the model run “just this once” without sandboxing and it shipped a PR to his work repo that re-formatted every file. The diff was technically correct. The PR was technically mergeable. He spent a Saturday reverting it. Now he has a sandbox.

The model with a terminal is the most useful thing in my workflow. The model with a terminal and no guardrails is a liability. The setup matters.