lac shell: Just Type What You Mean

The command I always forget

It's always something embarrassing. Not a complex Kubernetes incantation — just something like the exact flag order for tar, or which way round find wants its -exec arguments, or how to recursively change file permissions without accidentally nuking execute bits on directories. I know roughly what I need. I just don't know the exact syntax without looking it up.

The old workflow: Alt-Tab to the browser, type something into a search engine, skim three Stack Overflow answers that are all subtly different, copy a command, tab back, paste, squint at it, run it, hope. That's four context switches for something I've probably done a dozen times already.

lac shell cuts all of that out.

What lac shell actually is

lac shell is an AI-powered interactive shell that ships as part of lac-cli. You install it once:

pip install lac-cli

Or with the one-liner if you prefer:

curl -fsSL https://lacai.io/install.sh | bash

Then you just run:

lac shell

And you're in. It looks like a normal terminal prompt. The difference is that you can type plain English and it figures out the command for you. You can also run real shell commands directly — it doesn't intercept everything, only the things it recognises as natural language intent.

Ghost text autocomplete

This is the part I didn't expect to like as much as I do. As you type — whether it's a real command or an English description — the shell suggests a completion inline as ghost text. It appears faded ahead of your cursor. Hit Tab to accept it.

It feels a lot like Copilot in a code editor, but for your terminal. You type find all python files modified in the last 7 days and before you finish the sentence, the ghost text is already showing:

find . -name "*.py" -mtime -7

Tab. Done. It didn't even ask you to finish typing.

For commands you half-remember, it's faster than autocomplete in any shell I've used before, because it's working from intent rather than prefix matching. You don't have to know the start of the command — you just have to know what you want.

Confirm before run

One thing I was relieved to see: it always confirms before executing a translated command. You describe something, it surfaces the command, and you get a prompt to review it before anything actually runs. This matters more than it sounds. AI-generated shell commands can be subtly wrong — right general shape, wrong flag, wrong path assumption. The confirm step gives you a moment to actually read what it's about to do.

It's a small UX decision that shows a lot of restraint. The temptation when building something like this is to make it fully automatic — just run it, trust the model. But the people who'd use this tool are developers, and developers want to know what's running on their machines. So it shows you the command, you press Enter or edit it, and then it runs.

It handles the commands you actually forget

Here are a few things I've typed into lac shell in the past week, verbatim:

"show me all processes using port 3000" → lsof -i :3000
"copy folder recursively excluding node_modules" → rsync -av --exclude='node_modules' ./src/ ./backup/
"unzip and extract only the config folder" → unzip archive.zip 'config/*' -d ./output
"rename all .jpeg files to .jpg in current directory" → for f in *.jpeg; do mv "$f" "${f%.jpeg}.jpg"; done

None of those are hard commands. But every single one of them is something I'd normally have to look up, or rely on muscle memory that occasionally misfires. Typing intent and getting the right command back — with a chance to review it — is just faster.

Works with your model of choice

lac shell uses whatever provider you've configured in ~/.lac/config.json. That's Claude, OpenAI, or Ollama if you want to keep everything local and offline. The Ollama support is genuinely useful here — if you're on a flight or working somewhere without reliable internet, you're not stuck. Configure it once, forget about it.

Why I keep reaching for it over the fancier tools

lac-cli has a lot going on — lac agent with project memory and PlanMode, lac mind for multi-model debate, /multi for parallel agents, /watch for browser session capture. All of those are genuinely useful. But they're for specific workflows: building something, debugging something, generating docs.

lac shell is for all the moments in between. The quick commands. The one-liners you half-know. The syntax you learned two years ago and haven't touched since. It's the tool that earns its place by being there constantly rather than being impressive occasionally.

I have it open in a split terminal most of the day. It doesn't replace my normal shell — it sits beside it and handles the lookups. That's the right way to think about it: not a replacement, just an upgrade to the part of terminal use that's always involved a detour to the browser.

Get started in about 90 seconds

If you already have Python 3.9+, it's literally just:

pip install lac-cli
lac shell

Set your model provider on first run, and you're in. Type something in English, hit Tab when you see the ghost text, confirm the command. That's the whole loop. Everything else is optional depth you can explore when you need it.

The one thing I'd suggest trying first: describe the last command you had to look up. Whatever it was — the one from two days ago that sent you to Stack Overflow. Type it in plain English and see what comes back. That moment usually sells it better than anything I could write here.