Anthropic réduit discrètement les allocations Claude sans prévenir :la grogne monte

Claude :la grogne monte

Anthropic a opéré un ajustement en douceur de ses plafonds d’utilisation pour les abonnés Claude, réduisant mécaniquement la capacité de service durant les périodes de forte affluence afin d’équilibrer la demande avec ses ressources disponibles. L’annonce, pourtant significative, a été glissée le 26 mars 2026 par Thariq Shihipar, ingénieur au sein de l’équipe technique, via un simple post sur X — loin des canaux officiels de communication, ce qui a aiguisé l’irritation de nombreux clients.

Ce qui change concrètement

Durant les heures de pointe (de 5h à 11h heure du Pacifique, soit 13h à 19h GMT, en semaine), le coût en tokens de chaque session grimpe, ce qui signifie que l’allocation de cinq heures s’épuise plus vite que le temps réel d’activité. À l’inverse, les plafonds hebdomadaires demeurent inchangés — seule la répartition au fil des sept jours se modifie.
Qui trinque
Environ 7 % des utilisateurs heurteront désormais des limites qu’ils n’auraient pas atteintes auparavant. Les abonnés Pro sont les plus pénalisés. Les détenteurs de forfaits Max 20x s’en tirent largement, avec seulement 2 % de ce groupe concerné. Les abonnements touchés sont : Free, Pro (20 /mois),Max5x(100 /mois) et Max 20x (200 $/mois). Les clients API, facturés au token, échappent à cette mesure.

Le contexte qui pèse

Claude a engrangé des millions d’utilisateurs après que le contrat d’OpenAI avec le Pentagone a déclenché un boycott massif — 295 % de désinstallations de ChatGPT en une seule journée, 2,5 millions de participants au mouvement QuitGPT. Parallèlement, l’essor des fonctionnalités agentiques (vibe-coding, « computer use ») fait que les abonnés forfaitaires consomment bien plus de tokens qu’auparavant, tandis que les fournisseurs d’IA peinent à suivre la cadence.

Les griefs légitimes

Le manque de transparence suscite des critiques acerbes. De nombreux utilisateurs dénoncent l’absence de préavis, estimant que des changements substantiels sur les limites de service méritaient une annonce anticipée et officielle. La nouvelle a été discrètement publiée par un ingénieur sur les réseaux sociaux, plutôt que via un compte institutionnel ou le site web d’Anthropic.
Les faits rapportés ici sont corroborés par The Register, PCWorld, TechRadar, gHacks Tech News et plusieurs autres sources spécialisées.

Lemmings : l’histoire derrière le classique de DMA Design

Lemmings : L’histoire corrigée du jeu vidéo culte

Il y a plusieurs décennies, un jeu a captivé des millions de joueurs et reste, à ce jour, considéré comme l’un des titres les plus originaux, addictifs et exigeants de l’histoire. Nous parlons de Lemmings, un jeu qui a connu d’innombrables adaptations et qui a indéniablement marqué son époque.

L’origine des Lemmings

Pour comprendre la genèse de Lemmings, il faut se tourner vers le studio de développement écossais DMA Design et son éditeur, Psygnosis. L’idée du jeu est née d’une simple animation de petits personnages de 8×8 pixels créée par Mike Dailly, l’un des programmeurs de DMA, alors qu’il expérimentait pour un autre projet. C’est en voyant cette animation que son collègue, Russell Kay, s’est exclamé : « Il y a un jeu là-dedans ! » et a suggéré de nommer ces créatures « Lemmings ». David Jones, le fondateur de DMA Design, a ensuite dirigé le projet pour en faire le jeu que nous connaissons.

Le jeu est sorti le 14 février 1991 sur l’ordinateur Amiga, un jour de Saint-Valentin. Le succès fut immédiat et phénoménal : le jour de sa sortie, il s’est vendu à 55 000 exemplaires, un record pour l’époque. Au total, on estime que la franchise a vendu entre 15 et 20 millions d’exemplaires sur toutes les plateformes confondues.

Comment y jouer ?

Le concept de Lemmings est simple en apparence : dans chaque niveau, des créatures aux cheveux verts apparaissent via une trappe et marchent inlassablement, se dirigeant vers une mort certaine si le joueur n’intervient pas. La mission est de leur assigner des compétences spécifiques pour modifier le décor et leur créer un passage sécurisé jusqu’à la sortie.

Pour cela, le joueur dispose d’un nombre limité de huit compétences, parmi lesquelles :

  • Grimpeur (Climber) : pour escalader les parois verticales.
  • Flotteur (Floater) : pour utiliser un parachute et survivre aux chutes mortelles.
  • Bloqueur (Blocker) : pour stopper les autres lemmings et les forcer à faire demi-tour.
  • Bombe (Bomber) : pour faire exploser un lemming après un compte à rebours de cinq secondes.
  • Constructeur (Builder) : pour bâtir des escaliers.
  • Creuseur (Digger/Miner/Basher) : pour percer des tunnels à la verticale, en diagonale ou à l’horizontale.

Le jeu original proposait 120 niveaux répartis en quatre niveaux de difficulté : « Fun » (Amusant), « Tricky » (Délicat), « Taxing » (Éprouvant) et « Mayhem » (Chaos). Pour chaque niveau, il fallait sauver un certain pourcentage de lemmings dans le temps imparti.

Qu’est-il arrivé aux Lemmings ?

L’immense succès du jeu a entraîné une vague de portages sur la quasi-totalité des systèmes de l’époque : PC (MS-DOS), Super Nintendo, Game Boy, Mega Drive et bien d’autres. Des suites et extensions ont rapidement vu le jour, comme Oh No! More Lemmings dès 1991, qui ajoutait 100 niveaux inédits.

Mais que sont devenus ses créateurs ? DMA Design a continué sur sa lancée pour créer une autre franchise légendaire : Grand Theft Auto (GTA). Le studio a finalement été racheté et est aujourd’hui connu sous le nom de Rockstar North, un pilier de l’industrie du jeu vidéo.

Et qu’en est-il de la propriété intellectuelle (IP) du jeu ? Contrairement à une idée répandue, les droits n’ont pas été conservés par DMA Design. C’est l’éditeur, Psygnosis, qui détenait l’IP. Psygnosis a ensuite été racheté par Sony en 1993. C’est la raison pour laquelle les remakes et nouvelles versions de Lemmings sont apparus sur les consoles PlayStation, notamment sur PSP en 2006, sur PS Vita et même sur mobile, assurant ainsi la pérennité de ces créatures attachantes.

Cet article a été largement inspiré de l’article ici, mais révisé et corrigé pour garantir l’exactitude des faits concernant l’un des jeux les plus influents de l’histoire.

Comment utiliser Hyperfine ?

Comment utiliser Hyperfine pour comparer les performances de rg et ag

Qu’est-ce que Hyperfine ?

Hyperfine est un outil en ligne de commande qui permet de mesurer et de comparer les performances d’autres commandes. Il est particulièrement utile pour évaluer la vitesse d’exécution de différentes commandes ou scripts, en fournissant des statistiques détaillées comme le temps moyen, l’écart-type, et la plage de temps d’exécution.

Présentation de rg (ripgrep)

Ripgrep, souvent abrégé en rg, est un outil de recherche de texte ultra-rapide. Il est conçu pour parcourir rapidement des fichiers et des répertoires à la recherche de motifs spécifiques. Ripgrep est connu pour sa rapidité et sa capacité à ignorer les fichiers non pertinents, comme ceux dans les répertoires .git ou node_modules.

Présentation de ag (The Silver Searcher)

The Silver Searcher, ou ag, est un autre outil de recherche de texte, similaire à ack, mais plus rapide. Il est optimisé pour la recherche dans des projets de code, en ignorant automatiquement les fichiers et répertoires non pertinents. Bien qu’il soit rapide, il est souvent surpassé par rg en termes de performances.

Comparaison des performances avec Hyperfine

Pour comparer les performances de rg et ag, nous pouvons utiliser Hyperfine avec la commande suivante :

hyperfine --warmup 3 'rg -i "Olivier" -g "*php*" .' 'ag -i "Olivier" -G "php"'

Les résultats montrent que rg est significativement plus rapide que ag :

  • rg a un temps moyen d’exécution de 256.6 ms.
  • ag a un temps moyen d’exécution de 910.3 ms.

En résumé, rg est environ 3.55 fois plus rapide que ag dans ce scénario.

Pourquoi utiliser rg plutôt que ag ?

La comparaison effectuée avec Hyperfine démontre clairement que rg est plus performant que ag pour la recherche de texte. Si la vitesse est un critère important pour vous, rg est donc un choix évident. De plus, rg offre une meilleure gestion des fichiers ignorés et une intégration plus fluide avec les outils modernes de développement.

En conclusion, si vous cherchez un outil de recherche de texte rapide et efficace, rg est une excellente option, surtout lorsque vous travaillez sur des projets de grande envergure où chaque milliseconde compte.

Automatiser le nettoyage des branches Git avec un alias : Guide pratique

Automatiser le nettoyage des branches Git avec un alias : Guide pratique

Travailler avec Git implique souvent de gérer de nombreuses branches, locales et distantes. Au fil du temps, il est courant que des branches distantes soient supprimées, laissant des branches locales obsolètes. Pour simplifier le nettoyage de ces branches, vous pouvez créer un alias Git qui automatise ce processus. Dans cet article, nous vous expliquons comment faire, ainsi que les avantages et les inconvénients de cette méthode.

Créer un alias Git pour nettoyer les branches locales

Voici la commande pour créer un alias Git nommé prune-all qui nettoie automatiquement les branches locales obsolètes :

git config --global alias.prune-all '!git fetch --prune && git branch -vv | grep ": gone]" | sed "s/^[[:space:]]*\([^[:space:]]*\).*/\1/" | xargs -r git branch -d'

Une fois cet alias configuré, vous pouvez simplement exécuter :

git prune-all

Cette commande va :

  1. Mettre à jour les références locales et supprimer les branches distantes supprimées (git fetch --prune).
  2. Identifier les branches locales qui n’ont plus de branche distante associée (git branch -vv | grep ": gone]").
  3. Extraire les noms de ces branches (sed).
  4. Supprimer les branches locales (xargs -r git branch -d).

Pourquoi utiliser cet alias ?

Cet alias offre plusieurs avantages :

  • Gain de temps : Plus besoin d’exécuter manuellement plusieurs commandes pour nettoyer les branches locales.
  • Automatisation : Le processus est entièrement automatisé, ce qui réduit les erreurs humaines.
  • Propreté du dépôt : Vous gardez votre dépôt local propre et synchronisé avec le dépôt distant.

Les précautions à prendre

Bien que cet alias soit très utile, il est important de comprendre ses limites et les risques potentiels :

  • Utilisation de git branch -d : L’alias utilise git branch -d pour supprimer les branches locales. Cela signifie que Git refusera de supprimer une branche si elle contient des commits non fusionnés. C’est une sécurité pour éviter de perdre du travail.
  • Risque de suppression accidentelle : Si vous utilisez git branch -D (avec un D majuscule) à la place de -d, les branches seront supprimées de force, même si elles contiennent des commits non fusionnés. Soyez prudent si vous modifiez l’alias pour utiliser -D.
  • Vérification manuelle : Avant d’exécuter l’alias, il peut être utile de vérifier les branches qui seront supprimées en exécutant :
git fetch --prune && git branch -vv | grep ": gone]"

Quand utiliser cet alias ?

Cet alias est particulièrement utile dans les situations suivantes :

  • Vous travaillez sur un projet avec de nombreuses branches, et vous voulez garder votre dépôt local propre.
  • Vous collaborez avec une équipe et les branches distantes sont fréquemment supprimées après fusion.
  • Vous voulez automatiser une tâche répétitive pour gagner du temps.

Conclusion

Créer un alias Git pour nettoyer les branches locales est une excellente façon d’automatiser une tâche fastidieuse et de garder votre dépôt propre. En utilisant git branch -d, vous ajoutez une couche de sécurité pour éviter de perdre du travail non fusionné. Cependant, soyez conscient des risques si vous décidez d’utiliser git branch -D à la place.

N’hésitez pas à essayer cet alias et à l’adapter à vos besoins. Bonne gestion de branches !

Vous avez des questions ou des suggestions ? Laissez un commentaire ci-dessous !

Écran Noir (Black Screen) – un outil simple mais utile

Écran Noir (Black Screen) – Un outil simple mais utile

J’ai récemment ajouté une fonctionnalité simple mais pratique à mon site : une page « Écran Noir » accessible à l’adresse olivierpons.fr/black-screen.

Qu’est-ce que c’est ?

Il s’agit simplement d’une page web complètement noire, sans aucun élément d’interface ou contenu visible. Elle a été conçue pour afficher un écran noir pur qui occupe la totalité de votre navigateur.

À quoi ça sert ?

Cette page peut être utilisée dans plusieurs situations pratiques :

  1. Présentations et conférences : Pour faire une pause entre deux diapositives ou temporairement masquer votre écran.
  2. Économie d’énergie : Un écran noir consomme moins d’énergie sur les écrans OLED/AMOLED.
  3. Réduction de la luminosité : Dans un environnement sombre, quand vous avez besoin d’une source de lumière minimale.
  4. Tests d’affichage : Pour vérifier les fuites de lumière ou la qualité du noir sur votre écran.
  5. Méditation ou concentration : Éliminer les distractions visuelles pendant une session de concentration.

Comment ça fonctionne ?

Techniquement, c’est une simple page HTML statique avec un fond noir qui occupe 100% de l’écran et désactive le défilement. Elle est servie directement par Nginx sans passer par WordPress.

Cette solution a été implémentée avec l’aide de Claude, l’assistant IA d’Anthropic, qui m’a guidé dans la configuration Nginx et la création du fichier HTML approprié.

N’hésitez pas à l’utiliser quand vous en avez besoin, c’est un petit outil sans prétention mais qui peut s’avérer étonnamment utile !

Linux Mint : améliorer votre terminal ZSH avec l’auto-suggestion et la coloration syntaxique

Comment améliorer votre terminal ZSH avec l’auto-suggestion et la coloration syntaxique

Vous utilisez ZSH comme shell par défaut mais vous souhaitez le rendre plus puissant et agréable à utiliser ? Dans cet article, nous allons voir comment installer et configurer deux plugins essentiels : zsh-autosuggestions pour l’auto-complétion intelligente et zsh-syntax-highlighting pour la coloration syntaxique en temps réel.

Prérequis

  • ZSH installé comme shell par défaut
  • Git installé sur votre système
  • Droits d’accès à votre répertoire personnel

Installation des plugins

Commençons par créer un dossier dédié pour nos plugins ZSH et clonons les dépôts nécessaires :

mkdir -p ~/.zsh
git clone https://github.com/zsh-users/zsh-autosuggestions ~/.zsh/zsh-autosuggestions
git clone https://github.com/zsh-users/zsh-syntax-highlighting ~/.zsh/zsh-syntax-highlighting

Configuration

1. Activation des plugins

Ajoutez ces lignes à votre fichier ~/.zshrc pour activer les plugins :

source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh
source ~/.zsh/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh

2. Mise à jour de la liste des plugins

Si vous utilisez Oh My Zsh, modifiez la ligne des plugins dans votre fichier ~/.zshrc :

plugins=(git thefuck poetry zsh-autosuggestions zsh-syntax-highlighting)

Fonctionnalités

Auto-suggestions

Le plugin zsh-autosuggestions vous suggère des commandes basées sur votre historique pendant que vous tapez. Pour accepter une suggestion, appuyez simplement sur la touche ➡️ (flèche droite).

Coloration syntaxique

zsh-syntax-highlighting colore vos commandes en temps réel :

  • Commandes valides en vert
  • Commandes invalides en rouge
  • Options et arguments en couleurs distinctes
  • Chemins de fichiers existants soulignés

Conclusion

Avec ces deux plugins, votre terminal ZSH devient beaucoup plus convivial et efficace. L’auto-suggestion vous fait gagner du temps en proposant les commandes pertinentes, tandis que la coloration syntaxique vous aide à repérer rapidement les erreurs de frappe.

Conseils bonus

  • Redémarrez votre terminal ou exécutez source ~/.zshrc pour appliquer les changements
  • Vous pouvez personnaliser les couleurs et le comportement des plugins en consultant leur documentation respective sur GitHub
  • Ces plugins sont compatibles avec la plupart des frameworks ZSH comme Oh My Zsh et Prezto

N’hésitez pas à laisser un commentaire si vous rencontrez des difficultés ou si vous souhaitez partager d’autres astuces pour améliorer votre terminal !

Commandes à exécuter pour installer Chrome sur une nouvelle installation Linux Mint

Comment installer Google Chrome sur Linux (Ubuntu/Debian) – Guide complet

Dans ce guide, vous découvrirez comment installer facilement Google Chrome sur votre distribution Linux (Ubuntu ou Debian) en utilisant le terminal. Suivez ces étapes simples pour une installation réussie.

Étapes d’installation détaillées

  1. Créer le dossier pour les clés de sécurité
    Cette étape permet de préparer le système pour stocker les clés de sécurité Google.
  2. Télécharger et installer la clé Google
    Nous récupérons la clé officielle de Google pour garantir l’authenticité des paquets.
  3. Ajouter le dépôt Chrome
    Configuration du dépôt officiel dans votre système pour accéder aux paquets Chrome.
  4. Mettre à jour la liste des paquets
    Actualisation de votre système avec le nouveau dépôt ajouté.
  5. Installer Chrome
    Installation finale du navigateur sur votre système.

Commandes à exécuter

Copiez et collez ces commandes une par une dans votre terminal :

sudo mkdir -p /etc/apt/keyrings

curl -fsSL https://dl.google.com/linux/linux_signing_key.pub | sudo gpg --dearmor -o /etc/apt/keyrings/google-chrome.gpg

echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/google-chrome.gpg] http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee /etc/apt/sources.list.d/google-chrome.list

sudo apt update

sudo apt install google-chrome-stable

Vérification de l’installation

Une fois l’installation terminée, vous pouvez :

  • Lancer Chrome depuis votre menu d’applications
  • Ou utiliser la commande google-chrome dans le terminal

En cas de problème lors de l’installation, assurez-vous d’avoir les droits administrateur et que votre système est à jour.

JavaScript hack update

Mise à jour en pur JavaScript hacks

Voici une petite mise à jour en vanilla JS qui fait la même chose que ce que j’ai mis ici.

function emptyBody() {
    document.body.innerHTML = '';
}
function getRandomInt(max) {
    return Math.floor(Math.random() * Math.floor(max));
}
function addNewAvatar() {
    let curr = getRandomInt(5000);
    return function() {
        const img = document.createElement('img');
        img.src = `https://avatars.githubusercontent.com/u/${curr}`;
        img.style.maxWidth = '50px';
        img.style.display = 'inline-block';
        img.style.float = 'left';
        img.style.margin = '0';
        img.style.padding = '0';
        document.body.appendChild(img);
        curr += (1 + getRandomInt(3));
        setTimeout(addNewAvatar(), 100);
    };
}
emptyBody();
setTimeout(addNewAvatar(), 100);

ssh : les nouveaux types de cryptographies et clés pour plus de sécurité

GitHub et GitLab ont adopté des normes de sécurité SSH plus récentes et plus robustes pour renforcer la sécurité des connexions.

En remplacement, GitHub a introduit les clés hôtes ECDSA et Ed25519, qui sont basées sur la cryptographie à courbe elliptique, offrant ainsi de meilleures caractéristiques de sécurité pour des augmentations modestes de taille et de calcul.

Aujourd’hui, on recommande l’utilisation de clés SSH ED25519, qui sont plus sécurisées et devraient être disponibles sur n’importe quel système. Bien sûr quand on parle de système Linux on est sûr qu’elles sont déjà présentes.

Il est essentiel de générer des paires de clés SSH sûres et de les configurer correctement. Par défaut une clé de 1024 bits est générée, il faut donc impérativement changer la taille de la clé par au minimum 4096 :

ssh-keygen -t rsa -b 4096

Python : f-string vs str()

Quelle est la différence de performance entre f"{x}" et str(x) ?

Voici mes tests qui m’ont surpris, car je m’attendais à l’inverse :

from typing import Dict

def benchmark() -> None:
  """Main
  function for benchmark.
  """
  t1 = timeit.timeit("f_str()",
                     globals=globals(),
                     number=50000000)
  t2 = timeit.timeit("u_str()",
                     globals=globals(),
                     number=50000000)
  t3 = timeit.timeit("n_str()",
                     globals=globals(),
                     number=50000000)
  d: Dict[str, float] = {
    "f-string": t1,
    "str": t2,
    "no str": t3
  }
  s: Dict[str, float] = {k: v
                         for k, v
                         in sorted(d.items(),
                                   key=lambda i:
                                   i[1])}
  f: float = min(s.values())
  print("Method\tTime\tPerc.")
  print("------\t----\t-----")
  for k, v in s.items():
    p: float = (v / f) * 100
    print(f"{k}\t{v:.2f}\t{p:.2f}%")

if __name__ == "__main__":
  import timeit
  class T:
    def __init__(
            self, l: str) -> None:
      self.l: str = l
  o: T = T("test")
  def f_str() -> str:
    return f"{o.l}"
  def u_str() -> str:
    return str(o.l)
  def n_str() -> str:
    return o.l
  benchmark()

Explications

  • f"{self.label}" utilise le mécanisme d’interpolation de chaînes de caractères de Python qui peut être légèrement plus rapide parce qu’il est optimisé pour concaténer des littéraux de chaîne et des variables ;
  • str(self.label) appelle explicitement le constructeur de la classe str, ce est un peu plus lent en raison de l’appel de fonction.