Mots-clé : transparence

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.

pygame : exemple de transparence

Voici un exemple simple pour gérer la transparence : cet exemple est très simple, il crée un petit carré qui suit la souris partout, et un autre « gros » carré qui apparait autour de la souris puis ne bouge plus, et dès que la souris sort de ce carré, hop, il fait un fondu au noir. Vous pouvez donc vous baser sur cet exemple pour comprendre comment transformer votre Surface en surface transparente destinée à être rapidement affichée à l’écran. Je parle de convert_alpha(). Avec cet appel, pour vous donner une idée, le temps pris est presque 40 fois plus rapide que sans l’appel. Vous pouvez tester par vous même !

Attention !
Le plus important c’est de faire dans l’ordre :

        self.image.set_alpha(valeur_transparence)
        pygame.Surface.convert_alpha(self.image)

Car l’ordre self.image.set_alpha(valeur_transparence) fera créer un masque au complet, et ce n’est qu’après qu’il vous faudra convertir la totale via pygame.Surface.convert_alpha(self.image).

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os, pygame, sys, time, random, copy, pprint
from pygame.locals import *

class MySprite(pygame.sprite.Sprite):
    def __init__(self,width,height):
        # (!) Avant toute chose appeler le constructeur parent :
        pygame.sprite.Sprite.__init__(self)
        self.width = width
        self.height = height
        self.rect  = pygame.Rect(0, 0, width, height)
        self.image = pygame.Surface( (self.rect.width, self.rect.height) )
        self.image.set_colorkey((0,0,0))
        self.image.fill((0, 0, 0))

class SMouse(MySprite):
    def __init__(self,width,height):
        MySprite.__init__(self,width,height)
        pygame.draw.rect(self.image, (205,250,130), self.rect, 5)
        self.image = self.image.convert()

    def update(self):
        self.rect.topleft = pygame.mouse.get_pos()

class Contour(MySprite):
    def __init__(self,width,height,speed):
        MySprite.__init__(self,width,height)
        pygame.draw.rect(self.image, (105,250,230), self.rect, 5)
        self.fadeout = False
        self.speed = speed
        self.alpha = 250
        self.done = False
        self.image.set_alpha(self.alpha)
        # Convertir en transparent :
        pygame.Surface.convert_alpha(self.image)

    def update(self):
        if not self.fadeout:
            if not self.rect.collidepoint( pygame.mouse.get_pos() ):
                self.fadeout = True
        else:
            self.alpha -= self.speed
            if self.alpha<0:
                self.alpha = 0
                self.done = True
            self.image.set_alpha(self.alpha)

def main():
    pygame.init()
    pygame.mouse.set_visible(0)
    screen = pygame.display.set_mode( (0,0),
        pygame.FULLSCREEN | pygame.DOUBLEBUF | pygame.HWSURFACE )
    if pygame.display.Info().bitsize < 24:
        print "This game needs a 24 bits display"
        pygame.quit()

    background = pygame.Surface(screen.get_size())
    background = background.convert()
    background.fill((0, 0, 0))
    screen.blit(background, (0, 0))
    pygame.display.flip()
    clock = pygame.time.Clock()
    c = Contour(500, 500, 5)
    c.rect.center = pygame.mouse.get_pos()
    group_sprites = pygame.sprite.RenderPlain( [ SMouse(50, 50), c ] )