It started with a blinking cursor and a question:\
Why am I still scanning through git logs when I can just ask?

![](/media/01M43VYWB48BBZT3QC6D6N2Z2G/ai-agents-are-the-new-shell-1.png)

## I am a shell rat 🐀

Back in the day — which is to say, last week — I was deep in the terminal. You can call me a “shell rat.” I loved automating everything with a flurry of small scripts, aliases, and muscle memory magic.

Sure, I never remembered exact syntaxes. But ask me what `gfa` does? Boom: `git fetch --all`.\
`l`? That’s `ls -lht`.\
`ll`? For `ls -lhta`.\
`glol`? Ah yes — my glorious one-liner to make Git logs actually readable:

```bash
alias glol="git log --graph --pretty=\"%Cred%h%Creset -%C(auto)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset\""
```

(I would *never* remember that, by the way. Muscle memory does the heavy lifting.)

But lately the whole setup is starting to shift.

## My new shell has a chatbox

This past week, I started trying something different. Instead of typing commands, I open Claude Code.

Instead of running `glol`, I type:

*“Which commit reorganized the DBT models in the folder* `blah/`?”

Instead of staging, committing, writing a description, and pushing myself, I just say:

*“Commit and push”*

It does the job. Not perfectly, but often good enough (and sometimes better than me, to be honest).

And when things get a little more complex:

*“Split this into two branches off main — one for the Neo4j query optimizations, another for the BigQuery batch.”*

Or even:

*“Move these Terraform files under* `infra/` *and update references.”*

These agents aren’t magic, but they are handy. I still double-check the output, tweak things, and guide them when they guess wrong. But that’s fine. It feels more like steering than executing.

## My scripts became playbooks

As I used these tools more, I started collecting my own patterns. So I wrote [AI playbooks](https://github.com/ruliana/ai-playbooks) — prompt-ready guides for the stuff that isn’t as mainstream as Git.

Some examples:

- [Neovim Lazy Plugin Setup](https://github.com/ruliana/ai-playbooks/blob/main/playbooks/neovim-lazy-playbook.md)
- [Guile Scheme Setup](https://github.com/ruliana/ai-playbooks/blob/main/playbooks/guile-scheme-setup-playbook.md)
- [BigQuery Pipe Syntax](https://github.com/ruliana/ai-playbooks/blob/main/playbooks/bigquery-pipe-syntax-playbook.md)

I just paste the link into Claude and give it a task. If it flops? That’s a sign I need to improve the playbook. The better the playbooks are, the better my next task will be.

## Aliases out. Prompts in.

Bit by bit, my old shell habits are shifting into conversational workflows:

- Less memorization. More delegation.
- Fewer scripts. More high-level descriptions.
- Less time solving cases I never scripted for.

Instead of Fish functions and aliases, I now use [Claude Code custom commands](https://docs.anthropic.com/en/docs/claude-code/slash-commands#custom-slash-commands). Instead of switching between scripts and docs, I just describe what I need.

## What I’m Keeping

That said, I’m not tossing the whole toolbox. Some tools are staying:

- `z` — because jumping to the right folder is still faster than explaining where I want to go.
- `ls` aliases and `tree` — especially since Claude can read `tree` output. That one surprised me.
- `htop` — because when things go sideways, I want instant visibility.

Some workflows are still faster with the old tools. Others are just more predictable (and sometimes, predictable beats smart).

## Agents as Tools

The biggest shift?

I don’t need to operate the shell directly — I can have a tool do that for me.

That doesn’t make the shell obsolete. It just adds another layer on top of it. **A layer that helps me focus on what I want done, not how to spell it.**

The shell used to be my interface. Now, prompts are part of the workflow.

## Still Adapting. Still Prompting.

So yeah — AI agents are becoming a *huge* part of my toolkit. I don’t miss typing `glol`. I miss *why* I built it in the first place.

Now, I describe what I want, and the tool handles the messy part.

Still learning. Still adjusting. But it feels like a natural evolution of the terminal mindset. Less about raw commands, more about intent.

What about you? What did you (or could you) replace by an AI agent?

> *Built with keyboard nostalgia, Claude Code, and a whisper of muscle memory.*