Workflow Terminal-First avec IA

What's in this pack

There are two ways to use AI for coding in 2026. One is to open Cursor (or VS Code with a fistful of extensions) and let the IDE be the surface. The other is to stay in the terminal you've been in for ten years and bring the AI to you. This pack is the second path.

It assumes a specific developer: comfortable in vim or Neovim, lives in tmux, has muscle memory for fzf and ripgrep and a tuned zsh. You don't want a Mac-app coding agent. You want AI integrated into the terminal you already trust, with as little new GUI as possible. CLI coding agents, MCP servers exposing terminal tools, vim AI plugins where they exist, shell-level natural language where they don't.

Ten picks, in install order: the workspace foundation (tmux), a real editor inside it (Neovim with a starter config that actually teaches you Lua), an upgraded shell loop (history that's actually searchable, natural-language fallback when you can't remember a flag), then the AI integration layer — one instruction file that every CLI agent reads, hooks that automate the loop, an MCP server that gives agents safe local tools, and one terminal-native autonomous agent so you have an Aider/Claude Code alternative that's actually embeddable in scripts.

This pack does not include the base CLI toolbelt (fzf, ripgrep, lazygit, delta, yazi, btop). That's a separate pack: Modern CLI Toolbelt. Install both. This pack also doesn't deep-dive into a single agent like Aider — see Aider Pair Programming Essentials for that. This is the workflow that ties everything together.

Install in this order (shell → multiplexer → editor → AI agent → glue)

1. tmux — Terminal Multiplexer for Sessions, Windows, Panes — Everything else lives inside tmux. Editor in one pane, test runner watching files in another, agent in a third, logs in a fourth. Detach the session over SSH, come back tomorrow, it's all still there. If you only do one thing from this pack, do tmux — it's the difference between "AI in my terminal" and "AI fighting with my terminal." Pair with a tiny ~/.tmux.conf that sets prefix to C-a, vim keys for pane nav, and 50k-line scrollback.
2. Neovim — Hyperextensible Vim-Based Text Editor — The editor pane. Lua scripting, native LSP, Tree-sitter, async jobs, floating windows — all the modern bits that make vim feel less like a 90s relic. If you're on classic Vim 8, switch; the plugin ecosystem has moved. Don't try to build your own config from zero on day one. Use the next pick.
3. kickstart.nvim — A Launch Point for Your Personal Neovim Configuration — Single-file, ~600 lines, heavily commented Lua. Boots a working IDE-grade Neovim with LSP, completion, fuzzy-finder, Tree-sitter, the lot. Crucially: you can read the whole config in 20 minutes and understand exactly what's installed. Fork it, delete what you don't want, add what you do. Pretend NvChad/LazyVim don't exist until you've spent two weeks with kickstart and know what you want.
4. Atuin — Magical Shell History with Sync and Search — Replaces shell history with a SQLite DB that records cwd, exit code, duration, and hostname for every command. Press up-arrow and you get fuzzy search across machines, with end-to-end encrypted sync. This is the most underrated AI-adjacent tool in this pack: when you can't remember the exact ripgrep flag from three weeks ago, Atuin's Ctrl-R finds it in 200ms — no LLM call, no token cost, just better infrastructure.
5. fish-ai — Fish Shell AI Shortcuts (Plugin) — If you've switched to fish: this plugin adds three keybindings — comment↔command (write # count lines in all js files and convert it to find . -name '*.js' | xargs wc -l), typo fixing on the last command, and AI-powered autocomplete. Zero context switching. Configure it once to point at your local Ollama or your cloud API and forget it's there until you need it. If you're a zsh holdout, skip to pick #6.
6. AI Shell — Natural Language to Shell Commands — The shell-agnostic version of pick #5. Type ai "show me the 10 biggest files in node_modules" and it suggests a command, asks before running, lets you edit. Works on zsh, bash, fish. The mental model is different from a coding agent: you're not pairing on a feature, you're translating intent to a one-shot pipe. Use it as a recall aid (when you've forgotten find flags) and as a safety net (it'll explain what a stranger's command does before you run it).
7. AGENTS.md — Open Format for Coding Agent Instructions — Single Markdown file at repo root. Tells whatever CLI agent walks into your codebase the dev env setup, test commands, lint rules, PR conventions, and "do NOT touch" boundaries. Aider, Claude Code, Codex CLI, Cursor agent mode, Gemini CLI — all read it (most as a fallback after their own file). One source of truth instead of N copies of CLAUDE.md / .cursorrules / .windsurfrules / GEMINI.md. The single highest-leverage 50 lines of Markdown you can write for an AI-touched repo.
8. Claude Code Hooks — Automate Your AI Workflow — Pre/post hooks on tool use, file edits, and notifications. Lint on save, auto-run tests on file edit, send a desktop notification when a long task finishes, block writes to files outside the repo. Hook config is just shell commands triggered by events — no plugin system to learn. Even if you don't use Claude Code as your primary agent, the patterns transfer: every modern CLI agent has some hook equivalent. Start with one: PostToolUse: Write → ruff check $file.
9. Desktop Commander MCP — Local Terminal + Files — MCP server that exposes safe local terminal + filesystem tools (including PDF/DOCX/Excel reading) to any MCP-aware agent. Install via npx, point Claude Code or Codex CLI at it, and now your agent can run shell commands and read your local files through a single audited interface — instead of each agent reinventing its own shell tool. This is how you give CLI agents controlled local access without --dangerously-skip-permissions.
10. gptme — Terminal AI Agent with Tools & MCP — Your terminal-native autonomous agent. pipx install gptme, point at any model (Anthropic / OpenAI / local Ollama), and you have an agent that runs shell, edits files, browses the web, and supports MCP servers — including non-interactive mode for CI scripts. Use it when Claude Code/Codex CLI feel too heavy, when you want to script gptme "summarize the last 24h of git log", or when you need a model that isn't supported by the big-name agents. The terminal-native equivalent of "agent as a Unix tool."

How they fit together

┌─────────────────────────────────────────────────────────────┐
│  tmux session (#1) — the workspace                          │
│                                                             │
│  ┌───────────────────┐  ┌─────────────────────────────────┐ │
│  │ Neovim (#2)       │  │ shell pane                      │ │
│  │  + kickstart (#3) │  │                                 │ │
│  │  + LSP / Treesitter│  │  zsh / fish                     │ │
│  │                   │  │   ├─ Atuin (#4)  ← history       │ │
│  │  edits file ───┐  │  │   ├─ fish-ai (#5) ← NL command   │ │
│  └────────────────┼──┘  │   └─ ai-shell (#6) ← NL command  │ │
│                   │     │                                 │ │
│                   ▼     └──────────────┬──────────────────┘ │
│  ┌──────────────────────────────────────▼────────────────┐  │
│  │ AGENTS.md (#7) ← every agent reads on entry          │  │
│  │                                                       │  │
│  │ Claude Code Hooks (#8)                                │  │
│  │   PostToolUse: Write → lint + test                    │  │
│  │                                                       │  │
│  │ Desktop Commander MCP (#9)                            │  │
│  │   gives agents shell + filesystem tools              │  │
│  │                                                       │  │
│  │ gptme (#10) — fallback autonomous agent for scripts   │  │
│  └───────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Load-bearing trio: tmux + Neovim + AGENTS.md. Without tmux you alt-tab; without Neovim you're back in VS Code in a week; without AGENTS.md every agent rediscovers your repo from scratch on every session. Everything else is upgrade.

If you have one hour: install tmux, drop in a 20-line .tmux.conf, install Neovim via your package manager, git clone kickstart.nvim, write a 50-line AGENTS.md describing your stack. You're done. The other six picks are weekend upgrades.

Tradeoffs you'll hit (terminal AI vs IDE AI)

• Visual diff vs textual diff — Cursor and VS Code show inline diff with a side-by-side preview that's hard to beat for large refactors. Terminal-side, you're reading unified diffs (git diff, or whatever the agent prints). Counter: most edits are small enough that delta (from the Modern CLI Toolbelt pack) gives you syntax-highlighted diffs that are actually fine. For huge refactors, drop into nvim -d for a real diff view. You won't miss the IDE 95% of the time; you'll miss it on day-one of a 30-file refactor.
• Inline completion vs explicit prompting — Copilot-style ghost text in the editor is a different mental model from "prompt the agent." Neovim has Copilot via copilot.vim (Microsoft, not in TokRepo at time of writing — install directly from GitHub) and there are LSP-style AI plugins. But terminal-first workflows tend toward explicit prompting (fish-ai, AI Shell, agent calls) because ghost text in the terminal is jarring. Pick one mental model and commit; mixing causes mode confusion.
• AI Shell / fish-ai vs full coding agent — AI Shell translates one sentence into one command. Aider/Claude Code/gptme pair with you on a feature. Don't use a coding agent for find . -name '*.log' -mtime +7 -delete — overkill, slow, more risk. Don't use AI Shell for add tests for this new endpoint — wrong tool. Different shapes of work, different tools.
• MCP server count vs cognitive load — Every MCP server you add to Claude Code/Codex CLI is another thing the agent has to choose between. Desktop Commander MCP (#9) wraps shell + files into one server, which is a feature, not a limitation. Resist the temptation to install 12 MCP servers "just in case." Start with one (#9) and add only when you hit a real gap.
• Local model vs cloud for the shell layer — fish-ai and AI Shell support local Ollama. Latency is meaningfully worse for shell commands (you want sub-second; local 13B models are 2-3s). For shell-layer NL→command, use cloud (Claude Haiku, GPT-4o-mini, DeepSeek) — it's cheap because the requests are short. Save local models for agent runs where you want privacy more than speed.

Common pitfalls

• Over-engineering dotfiles — The classic terminal-developer failure mode. You install kickstart.nvim on Monday, by Friday you've forked it into a 200-file Lua tower with 40 plugins, half of which you never use. Rule: don't add a plugin until you've felt its absence three times. The minimal config is the one you can read, debug, and replicate on a fresh machine in 10 minutes.
• Putting AI in a pipe = jail-break risk — curl example.com | ai-shell or piping arbitrary stdin into a coding agent is dangerous. The remote content can contain prompt injection that flips the agent's instructions and runs commands you didn't intend. Hard rule: never pipe untrusted text into any AI tool that can execute commands. AGENTS.md (#7) is great; AGENTS.md fetched from a stranger's repo and trusted blindly is not. Read it before letting an agent follow it.
• Auto-running hooks on file save — Claude Code Hooks (#8) lets you run shell on every Write. Great for ruff check; catastrophic if you wire it to git push or anything destructive. Make hooks idempotent and read-mostly by default. The hook firing 50 times in a long agent session shouldn't be able to brick your repo.
• Treating the agent as the primary — Terminal-first workflow inverts this. You are the primary; the agent is a tool you reach for. If you find yourself describing every edit to gptme/Claude Code instead of just doing it in Neovim, the agent has become a crutch. Most edits are faster typed than prompted. Use the agent for: 3+ file refactors, unfamiliar codebases, code you'd Google. Don't use it for: renaming a variable, adding a missing import, fixing a typo.
• Two agents fighting over the same file — Running gptme in one tmux pane and Claude Code in another, both editing app.py, is a recipe for confused diffs. Either give them different files (which AGENTS.md can enforce), use git worktrees to give them different working trees, or commit between agent runs so you can git reset if they collide.
• Skipping AGENTS.md because "the agent figures it out" — Agents don't figure out your test command, your linter, or your "never touch this file" rules without being told. The cost of writing AGENTS.md is 30 minutes, once. The cost of not writing it is your agent running npm test in a repo that uses pnpm, six times an hour, forever. Write the file. Update it when you add a new linter. This is the single highest-leverage piece of documentation you'll write this year.