The first five minutes with lac-cli
Every time I recommend lac-cli to someone, the first question is the same: "How do I actually get it running?" The README covers it, but a quick walkthrough of what the setup flow feels like saves a lot of tab-switching. So here it is — install to first real command, no gaps.
Install
You've got three options. Pick whichever matches how you work:
pip (if you already have Python 3.9+):
pip install lac-cli
curl (macOS / Linux, one-liner):
curl -fsSL https://lacai.io/install.sh | bash
PowerShell (Windows):
iwr -useb https://lacai.io/install.ps1 | iex
The pip route is what I use day-to-day. It drops lac onto your PATH and that's it — no Electron app, no background daemon, nothing running until you actually call it.
The provider wizard
First time you run any lac command, it kicks off a short setup wizard. You can also trigger it explicitly at any point:
lac shell --setup
The wizard asks you to pick a provider: claude, openai, ollama, or a custom OpenAI-compatible endpoint. Then it asks for your API key (or skips that step if you're going with Ollama). Done. Config gets written to ~/.lac/config.json — plain JSON, easy to edit by hand later if you want to swap models or add a second provider.
One thing I appreciate: it doesn't assume which model you want within a provider. It lets you specify. If you're on Claude and you want claude-opus-4-5 instead of the default, you just type it in. Same with OpenAI — you're not stuck on whatever version they decided is "standard."
lac shell — start here
Once setup is done, open the AI shell:
lac shell
This is the best place to start because the feedback loop is instant. Type a plain English command and it translates it to the real shell command before running anything. Something like:
find all files modified in the last 24 hours and show their sizes
It comes back with the actual command, shows it to you, and asks for confirmation before executing. That confirmation step sounds annoying until you realize it's caught a couple of commands that technically did what I asked but would've also deleted things I didn't mean to touch.
The other thing that's genuinely useful is ghost text autocomplete. As you type, it suggests the rest of your command in dimmed text. Hit Tab to accept. It learns from context — if you're in a Python project directory, it's going to lean toward Python-related suggestions. If you just ran a Docker command, the next suggestion tends to be something adjacent to that.
Tab-completing AI suggestions in a terminal felt gimmicky when I first heard it described. Using it daily it's just... faster. Fewer trips to Stack Overflow for the flag I can never remember.
lac agent — when you need to touch files
Once you're comfortable with lac shell, spin up lac agent in a project directory:
lac agent
The agent reads your project structure on start. It can create files, edit existing ones, run commands, and track what it's done in a .lac-memory.json file it creates at the root. That memory file means if you close and reopen the session, it still knows what you were working on. It's not magic — it's just a JSON file — but it means you don't have to re-explain your project every single time.
Before it writes anything, you get a diff. Before it runs anything destructive, you get a prompt. And if a change lands wrong, /undo rolls it back cleanly. I've had junior devs express more caution than some tools I've used that just write directly to disk with no preview at all.
If you're brand new to it, give it a small, real task in an actual project — "add input validation to the registration endpoint" or "write a test for the auth middleware." Something specific. The more concrete the ask, the better the output.
lac mind — optional, but worth knowing about
If you want a second opinion on something — architectural decisions, debugging hypotheses, writing — lac mind is worth one run just to see how it works:
lac mind
It opens a local web interface and lets multiple models debate your question across rounds, then vote on the best answer. It's slower than asking one model, obviously, but for decisions where being wrong has a real cost, the cross-model challenge catches things a single model confidently glosses over.
I don't use it for every task. But when I'm genuinely unsure about something — database schema design, picking between two different approaches to a feature — running it through lac mind and seeing where the models disagree tells me exactly where to focus my own thinking.
Offline mode if you don't want to send data anywhere
All three tools work with Ollama if you'd rather keep everything local. After you install Ollama and pull a model, just run:
lac shell --offline
Or re-run the setup wizard and pick ollama as your provider. Everything else works the same. Response speed depends on your hardware obviously, but on a modern M-series Mac it's fast enough that I use it regularly when I'm on a spotty connection or just don't want a given session leaving my machine.
Where config lives
Everything lac-cli knows about your setup is in ~/.lac/config.json. If you ever want to switch providers, change your default model, or just inspect what's stored, open it directly. It's readable JSON — no binary format, no hidden state. Here's roughly what it looks like after setup:
{
"provider": "claude",
"model": "claude-opus-4-5",
"api_key": "sk-ant-..."
}
You can maintain multiple config files and point lac at different ones per project if you need to, though most people just use the default global config and don't think about it again.
The practical tip
If you're installing today, do this in order: run lac shell for a day before touching lac agent. Getting comfortable with how the shell handles plain English commands — and trusting the confirmation step — makes the agent feel natural when you get to it. Jumping straight to the agent without that context tends to make people under-use the diff preview, and that's the part that actually keeps you safe when it's editing real code.
Install it from lacai.io/lac-cli or straight from PyPI. MIT licensed, no subscription required.