10 alias bash qui m'ont fait gagner 2h par semaine

J'utilise atuin pour traquer mon historique shell depuis 14 mois. En regardant mes 12 300 commandes les plus fréquentes, je me suis rendu compte que 10 alias bien choisis remplaçaient à eux seuls 40% de mes frappes. Gains mesurés : 2h07 par semaine en moyenne. Voici les 10 alias, leur fréquence d'usage réelle, et pourquoi chacun vaut plus que son poids en caractères.

La méthodologie

Pour chaque commande dans mon historique, j'ai calculé : (nombre de frappes) × (fréquence d'usage sur 6 mois) = temps total passé à taper. Les 10 candidats les plus « coûteux » ont été convertis en alias. Puis j'ai mesuré à nouveau 4 semaines plus tard.

Les 10 alias (par fréquence décroissante)

1. `g = git status -sb` (1 847 usages / 6 mois)

alias g='git status -sb'

Le format -sb donne une vue compacte avec la branche. 4 caractères au lieu de 16. Économie par usage : 0,3 s × 1 847 = 9 minutes.

2. `gd = git diff --stat` (1 204 usages)

alias gd='git diff --stat'

Pour voir quels fichiers ont changé sans être noyé dans les diffs complets. Le --stat donne un résumé.

3. `gca = git add -A && git commit -m` (956 usages)

gca() { git add -A && git commit -m "$*"; }

Fonction, pas alias, parce qu'elle prend un argument. gca "fix bug X" au lieu de git add -A && git commit -m "fix bug X".

4. `lg = lazygit` (712 usages)

alias lg='lazygit'

Pour les fois où CLI git ne suffit plus (merge conflicts, rebase interactif, history exploration). lg c'est 2 caractères.

5. `k = kubectl` (643 usages)

alias k='kubectl'

Standard dans l'écosystème k8s. Économie : 7 caractères × 643 usages = 2,5 minutes.

6. `nr = npm run` (584 usages)

alias nr='npm run'

Suivi de dev, build, test, etc. Avec completion bash, nr d<tab> me donne nr dev.

7. `dc = docker compose` (497 usages)

alias dc='docker compose'

Pour ceux qui utilisent docker compose tous les jours. dc up -d au lieu de docker compose up -d.

8. `please = sudo $(fc -ln -1)` (342 usages)

alias please='sudo $(fc -ln -1)'

Quand tu oublies sudo sur une commande, au lieu de la retaper : please. Le fc -ln -1 récupère la dernière commande de l'historique.

9. `path = echo $PATH | tr : '\n'` (287 usages)

alias path='echo $PATH | tr : "\n"'

Voir ton PATH formaté une variable par ligne. Indispensable pour debugger « pourquoi ma commande n'est pas trouvée ».

10. `pn = pnpm` (273 usages)

alias pn='pnpm'

Pour les devs Node qui sont passés à pnpm. Court, propre.

Les gains mesurés sur 4 semaines

Le gain en temps (42 min / jour) est plus élevé que le gain en caractères (-38%) parce que les alias évitent aussi les erreurs de frappe et les backspace/correction qui bouffent du temps.

42 minutes × 5 jours = 3h30 / semaine de gain brut. En retranchant le temps d'installation (15 min) et la courbe d'apprentissage (environ 1 semaine à 20 min/jour), le gain net stable est 2h07 / semaine.

Les alias que j'ai essayés et **abandonnés**

Pour chaque alias qui marche, j'en ai essayé 3 ou 4 qui sont morts :

• •gl = git log --oneline -20 — remplacé par lazygit
• •gp = git push — trop dangereux, je préfère taper
• •ll = ls -la — redondant avec exa -la que j'ai aliasé sur ls de toute façon
• •.. / ... pour cd .. / cd ../.. — zsh autopush fait mieux
• •mkdir -p && cd combo — j'oublie de l'utiliser

Les alias que je n'ai **pas** créés (et pourquoi)

Certaines commandes fréquentes ne méritent pas d'alias :

1. 1.Commandes destructives (rm, git reset --hard) — je veux que ça soit pénible à taper. La friction me protège.
2. 2.Commandes où je tape les options différemment à chaque fois — un alias rigide est pire que le shell dynamique.
3. 3.Commandes complexes qui nécessiteraient une fonction de 20 lignes — je les mets dans ~/bin/ comme vrais scripts.

Ma `.bashrc` actuelle (extrait)

# ~/.bashrc — aliases section

# Git
alias g='git status -sb'
alias gd='git diff --stat'
gca() { git add -A && git commit -m "$*"; }
alias lg='lazygit'

# Kubernetes / Docker
alias k='kubectl'
alias dc='docker compose'

# Node / JS
alias nr='npm run'
alias pn='pnpm'

# Debug shell
alias path='echo $PATH | tr : "\n"'
alias please='sudo $(fc -ln -1)'

# Custom
alias reload='source ~/.bashrc'
export HISTSIZE=100000
export HISTFILESIZE=200000

Ce qu'il faut retenir

1. 1.Mesure d'abord, automatise ensuite. Atuin (ou équivalent) te dit où sont tes vraies frictions.
2. 2.10 alias bien choisis couvrent 40% de tes frappes quotidiennes.
3. 3.Le vrai gain ne vient pas que des caractères, mais aussi des erreurs évitées (-39%).
4. 4.Les alias inutilisés sont pires que pas d'alias — supprime ce que tu n'utilises pas.
5. 5.Ne raccourcis pas les commandes destructives — la friction est ta sauvegarde.

Pour aller plus loin sur la productivité en terminal et les workflows Claude Code avancés, j'ai écrit un livre dédié :

La Boucle Ralph

Guide Pratique du Coding Autonome par IA.

Découvrir →