claudient 0.1.0 → 0.3.0

package/skills/backend/java/spring-boot.md

@@ -0,0 +1,331 @@
+# Spring Boot Skill
+
+## When to activate
+- Building a Spring Boot REST API or microservice
+- Setting up Spring Data JPA with Hibernate and PostgreSQL/MySQL
+- Configuring Spring Security (JWT, OAuth2, session-based auth)
+- Writing Spring Boot tests (unit with Mockito, integration with TestRestTemplate or MockMvc)
+- Setting up Spring Cloud (service discovery, config server, API gateway)
+- Implementing async processing with `@Async` or Spring Events
+- Configuring profiles, properties, and externalized configuration
+- Writing custom Spring Boot starters or auto-configurations
+
+## When NOT to use
+- Quarkus or Micronaut projects — different DI and config models
+- Plain Java without Spring — overhead isn't justified for simple scripts
+- Android projects — different ecosystem entirely
+- Jakarta EE/WildFly — different application server model
+
+## Instructions
+
+### Project structure
+```
+src/
+├── main/
+│   ├── java/com/example/app/
+│   │   ├── AppApplication.java         # @SpringBootApplication entry point
+│   │   ├── config/                     # @Configuration beans
+│   │   ├── controller/                 # @RestController — HTTP layer only
+│   │   ├── service/                    # Business logic — @Service
+│   │   ├── repository/                 # @Repository — data access
+│   │   ├── domain/                     # @Entity models
+│   │   ├── dto/                        # Request/response shapes (records)
+│   │   ├── exception/                  # @ControllerAdvice error handling
+│   │   └── security/                   # Security config and filters
+│   └── resources/
+│       ├── application.yml             # Base config
+│       ├── application-dev.yml         # Dev overrides
+│       └── application-prod.yml        # Prod overrides
+└── test/
+    └── java/com/example/app/
+        ├── controller/                 # MockMvc / @WebMvcTest
+        ├── service/                    # Unit tests with Mockito
+        └── integration/               # @SpringBootTest full context
+```
+
+### Application entry point
+```java
+@SpringBootApplication
+public class AppApplication {
+    public static void main(String[] args) {
+        SpringApplication.run(AppApplication.class, args);
+    }
+}
+```
+
+### application.yml structure
+```yaml
+spring:
+  application:
+    name: my-service
+  datasource:
+    url: ${DATABASE_URL}
+    username: ${DB_USER}
+    password: ${DB_PASSWORD}
+  jpa:
+    hibernate:
+      ddl-auto: validate         # Never 'create' or 'update' in production
+    show-sql: false
+    properties:
+      hibernate:
+        format_sql: true
+
+server:
+  port: ${PORT:8080}
+
+# Custom properties — always use @ConfigurationProperties, never @Value for groups
+app:
+  jwt:
+    secret: ${JWT_SECRET}
+    expiration-ms: 86400000
+```
+
+### Entity and Repository
+```java
+// domain/User.java
+@Entity
+@Table(name = "users")
+public class User {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false, unique = true, length = 320)
+    private String email;
+
+    @Column(nullable = false)
+    private String passwordHash;
+
+    @CreationTimestamp
+    @Column(updatable = false)
+    private Instant createdAt;
+
+    // No-arg constructor required by JPA
+    protected User() {}
+
+    public User(String email, String passwordHash) {
+        this.email = email;
+        this.passwordHash = passwordHash;
+    }
+    // getters only — no setters on entities
+}
+
+// repository/UserRepository.java
+public interface UserRepository extends JpaRepository<User, Long> {
+    Optional<User> findByEmail(String email);
+    boolean existsByEmail(String email);
+
+    // JPQL for complex queries
+    @Query("SELECT u FROM User u WHERE u.createdAt > :since")
+    List<User> findRecentUsers(@Param("since") Instant since);
+}
+```
+
+### Service layer
+```java
+@Service
+@Transactional(readOnly = true)   // Default read-only; override for writes
+public class UserService {
+    private final UserRepository userRepo;
+    private final PasswordEncoder passwordEncoder;
+
+    public UserService(UserRepository userRepo, PasswordEncoder passwordEncoder) {
+        this.userRepo = userRepo;
+        this.passwordEncoder = passwordEncoder;
+    }
+
+    @Transactional   // Override: this method writes
+    public UserDto createUser(CreateUserRequest request) {
+        if (userRepo.existsByEmail(request.email())) {
+            throw new ConflictException("Email already in use");
+        }
+        User user = new User(request.email(), passwordEncoder.encode(request.password()));
+        return UserDto.from(userRepo.save(user));
+    }
+
+    public UserDto getById(Long id) {
+        return userRepo.findById(id)
+            .map(UserDto::from)
+            .orElseThrow(() -> new NotFoundException("User " + id + " not found"));
+    }
+}
+```
+
+### Controller layer
+```java
+@RestController
+@RequestMapping("/api/v1/users")
+@Validated
+public class UserController {
+    private final UserService userService;
+
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public UserDto createUser(@RequestBody @Valid CreateUserRequest request) {
+        return userService.createUser(request);
+    }
+
+    @GetMapping("/{id}")
+    public UserDto getUser(@PathVariable Long id) {
+        return userService.getById(id);
+    }
+
+    @GetMapping
+    public Page<UserDto> listUsers(Pageable pageable) {
+        return userService.findAll(pageable);
+    }
+}
+```
+
+### DTOs with records
+```java
+// dto/CreateUserRequest.java
+public record CreateUserRequest(
+    @NotBlank @Email String email,
+    @NotBlank @Size(min = 8) String password
+) {}
+
+// dto/UserDto.java
+public record UserDto(Long id, String email, Instant createdAt) {
+    public static UserDto from(User user) {
+        return new UserDto(user.getId(), user.getEmail(), user.getCreatedAt());
+    }
+}
+```
+
+### Global exception handler
+```java
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(NotFoundException.class)
+    @ResponseStatus(HttpStatus.NOT_FOUND)
+    public ProblemDetail handleNotFound(NotFoundException ex) {
+        return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
+    }
+
+    @ExceptionHandler(ConflictException.class)
+    @ResponseStatus(HttpStatus.CONFLICT)
+    public ProblemDetail handleConflict(ConflictException ex) {
+        return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, ex.getMessage());
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public ProblemDetail handleValidation(MethodArgumentNotValidException ex) {
+        var detail = ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, "Validation failed");
+        detail.setProperty("errors", ex.getBindingResult().getFieldErrors().stream()
+            .map(e -> e.getField() + ": " + e.getDefaultMessage())
+            .toList());
+        return detail;
+    }
+}
+```
+
+### Spring Security — JWT
+```java
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http, JwtAuthFilter jwtFilter) throws Exception {
+        return http
+            .csrf(AbstractHttpConfigurer::disable)
+            .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+            .authorizeHttpRequests(auth -> auth
+                .requestMatchers("/api/v1/auth/**", "/actuator/health").permitAll()
+                .anyRequest().authenticated()
+            )
+            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)
+            .build();
+    }
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+}
+```
+
+### Testing
+```java
+// @WebMvcTest — controller slice test (no full context)
+@WebMvcTest(UserController.class)
+class UserControllerTest {
+    @Autowired MockMvc mockMvc;
+    @MockitoBean UserService userService;     // Spring Boot 3.4+: @MockitoBean
+
+    @Test
+    void createUser_returnsCreated() throws Exception {
+        given(userService.createUser(any())).willReturn(new UserDto(1L, "a@b.com", Instant.now()));
+
+        mockMvc.perform(post("/api/v1/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("""{"email":"a@b.com","password":"password123"}"""))
+            .andExpect(status().isCreated())
+            .andExpect(jsonPath("$.email").value("a@b.com"));
+    }
+}
+
+// @SpringBootTest — full integration test
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@Transactional
+class UserServiceIntegrationTest {
+    @Autowired UserService userService;
+
+    @Test
+    void createUser_persistsToDatabase() {
+        var user = userService.createUser(new CreateUserRequest("a@b.com", "password123"));
+        assertThat(user.email()).isEqualTo("a@b.com");
+        assertThat(user.id()).isNotNull();
+    }
+}
+```
+
+### Spring Cloud patterns
+```yaml
+# Service discovery with Eureka
+spring:
+  application:
+    name: user-service
+eureka:
+  client:
+    service-url:
+      defaultZone: http://eureka-server:8761/eureka/
+
+# Config server client
+spring:
+  config:
+    import: configserver:http://config-server:8888
+```
+
+```java
+// Feign client for inter-service calls
+@FeignClient(name = "order-service")
+public interface OrderClient {
+    @GetMapping("/api/v1/orders/user/{userId}")
+    List<OrderDto> getOrdersByUser(@PathVariable Long userId);
+}
+```
+
+## Example
+
+**User:** Build a Spring Boot REST API for a product catalogue with CRUD endpoints, PostgreSQL via JPA, bean validation, global error handling, and a `@WebMvcTest` for the GET endpoint.
+
+**Expected output:**
+- `Product` entity — `id`, `name`, `price` (BigDecimal), `stock`, `createdAt`
+- `ProductDto` record + `CreateProductRequest` record with `@NotBlank` / `@Positive` validation
+- `ProductRepository extends JpaRepository<Product, Long>`
+- `ProductService` — `@Transactional(readOnly = true)` class-level, `@Transactional` on writes
+- `ProductController` — CRUD at `/api/v1/products`, `Pageable` on GET list
+- `GlobalExceptionHandler` — `NotFoundException` → 404, `MethodArgumentNotValidException` → 400 with field errors
+- `ProductControllerTest` using `@WebMvcTest` + `@MockitoBean ProductService`
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. [uitbreiden.com](https://uitbreiden.com/)

package/skills/productivity/caveman.md

@@ -0,0 +1,70 @@
+# Caveman Mode Skill
+
+## When to activate
+- You want to dramatically reduce token usage across a long session
+- Context window is filling up and you need to extend the session's useful life
+- You're running a cost-sensitive workload (many parallel agents, batch processing)
+- Claude's responses are verbose and you want terse, fragment-style output
+- You want to compress existing memory or CLAUDE.md files to reduce input tokens
+
+## When NOT to use
+- Security warnings or irreversible action confirmations — these need full sentences
+- Multi-step sequences where fragment ambiguity could cause misread actions
+- Onboarding new team members to a codebase — clarity beats brevity here
+- Writing documentation that external people will read
+
+## Instructions
+
+Caveman mode is an established token-compression technique with a dedicated implementation at [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman). This skill is a pointer — use the original repo, do not duplicate it.
+
+### What it does
+
+Caveman mode instructs Claude to output compressed, fragment-style prose:
+
+| Level | Rule | Example |
+|-------|------|---------|
+| `lite` | Drop filler and hedging, keep articles and full sentences | "The function handles edge cases." |
+| `full` | Drop articles, fragments OK, short synonyms | "func handles edge cases" |
+| `ultra` | Abbreviate prose words, strip conjunctions, arrows for causality | "fn→edge cases handled" |
+
+Benchmarked results (March 2026, [arxiv.org/abs/2604.00025](https://arxiv.org/abs/2604.00025)):
+- ~65% output token reduction
+- 26-point accuracy improvement on benchmarks (brevity sharpens reasoning)
+- 100% technical accuracy maintained
+
+### caveman-compress sub-skill
+Rewrites `.md` memory and CLAUDE.md files to caveman prose — ~46% input token savings every session because compressed files are re-read on every context load.
+
+### cavecrew subagents
+Haiku-based subagents running in caveman mode — ~60% fewer tokens than vanilla agents for simple classification, extraction, and routing tasks.
+
+### caveman-shrink MCP middleware
+Compresses MCP tool descriptions before they enter Claude's context — reduces MCP overhead by ~30% without changing tool behaviour.
+
+## Example
+
+**Activating caveman mode in a session:**
+```
+Use caveman mode (full level) for this session. Drop articles, use fragments,
+short synonyms. Auto-revert to normal prose for: security warnings,
+irreversible action confirmations, multi-step sequences.
+```
+
+**Using caveman-compress on a memory file:**
+```
+/caveman-compress .claude/memory/project-context.md
+```
+
+**Using cavecrew for a classification task:**
+```
+Spawn a cavecrew subagent (Haiku, caveman full) to classify these 200 support
+tickets into 5 categories. Return only: ticket_id, category.
+```
+
+---
+
+**Reference:** [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman) — the authoritative caveman implementation. Claudient references this work; it is not duplicated here.
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. [uitbreiden.com](https://uitbreiden.com/)

package/skills/productivity/de/caveman.md

@@ -0,0 +1,72 @@
+> 🇩🇪 Deutsche Version. [Englische Version](../caveman.md).
+
+# Caveman Mode Skill
+
+## Wann aktivieren
+- Du möchtest den Token-Verbrauch in einer langen Sitzung deutlich reduzieren
+- Das Kontextfenster füllt sich und du musst die nutzbare Lebensdauer der Sitzung verlängern
+- Du führst eine kostensensible Aufgabe aus (viele parallele Agents, Batch-Verarbeitung)
+- Die Antworten von Claude sind ausführlich und du möchtest knappe, fragmentartige Ausgaben
+- Du möchtest bestehende Memory- oder CLAUDE.md-Dateien komprimieren, um Input-Tokens zu reduzieren
+
+## Wann NICHT verwenden
+- Sicherheitswarnungen oder Bestätigungen für nicht umkehrbare Aktionen — diese benötigen vollständige Sätze
+- Mehrstufige Abläufe, bei denen Fragmentmehrdeutigkeit zu Fehlinterpretationen führen kann
+- Onboarding neuer Teammitglieder in eine Codebasis — hier überwiegt Klarheit gegenüber Kürze
+- Schreiben von Dokumentation, die externe Personen lesen werden
+
+## Anweisungen
+
+Caveman Mode ist eine etablierte Token-Kompressionstechnik mit einer dedizierten Implementierung unter [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman). Dieser Skill ist ein Verweis — verwende das originale Repository, dupliziere es nicht.
+
+### Was es bewirkt
+
+Caveman Mode weist Claude an, komprimierte, fragmentartige Prosa auszugeben:
+
+| Stufe | Regel | Beispiel |
+|-------|-------|---------|
+| `lite` | Füllwörter und Abschwächungen weglassen, Artikel und vollständige Sätze beibehalten | "The function handles edge cases." |
+| `full` | Artikel weglassen, Fragmente erlaubt, kurze Synonyme | "func handles edge cases" |
+| `ultra` | Prosa-Wörter abkürzen, Konjunktionen entfernen, Pfeile für Kausalität | "fn→edge cases handled" |
+
+Benchmark-Ergebnisse (März 2026, [arxiv.org/abs/2604.00025](https://arxiv.org/abs/2604.00025)):
+- ~65 % Reduzierung der Output-Tokens
+- 26 Punkte Verbesserung der Genauigkeit in Benchmarks (Kürze schärft das Denken)
+- 100 % technische Genauigkeit beibehalten
+
+### caveman-compress Sub-Skill
+Schreibt `.md` Memory- und CLAUDE.md-Dateien in Caveman-Prosa um — ~46 % Einsparung bei Input-Tokens in jeder Sitzung, da komprimierte Dateien bei jedem Kontextladen neu eingelesen werden.
+
+### cavecrew Subagents
+Haiku-basierte Subagents, die im Caveman Mode laufen — ~60 % weniger Tokens als normale Agents für einfache Klassifizierungs-, Extraktions- und Routing-Aufgaben.
+
+### caveman-shrink MCP Middleware
+Komprimiert MCP-Tool-Beschreibungen, bevor sie in Claudes Kontext gelangen — reduziert den MCP-Overhead um ~30 % ohne das Verhalten der Tools zu verändern.
+
+## Beispiel
+
+**Caveman Mode in einer Sitzung aktivieren:**
+```
+Use caveman mode (full level) for this session. Drop articles, use fragments,
+short synonyms. Auto-revert to normal prose for: security warnings,
+irreversible action confirmations, multi-step sequences.
+```
+
+**caveman-compress auf einer Memory-Datei verwenden:**
+```
+/caveman-compress .claude/memory/project-context.md
+```
+
+**cavecrew für eine Klassifizierungsaufgabe verwenden:**
+```
+Spawn a cavecrew subagent (Haiku, caveman full) to classify these 200 support
+tickets into 5 categories. Return only: ticket_id, category.
+```
+
+---
+
+**Referenz:** [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman) — die maßgebliche Caveman-Implementierung. Claudient verweist auf diese Arbeit; sie wird hier nicht dupliziert.
+
+---
+
+> **Arbeite mit uns:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir entwickeln KI-Produkte und B2B-Lösungen mit Entwickler-Communities. [uitbreiden.com](https://uitbreiden.com/)

package/skills/productivity/es/caveman.md

@@ -0,0 +1,72 @@
+> 🇪🇸 Versión en español. [Versión en inglés](../caveman.md).
+
+# Skill Modo Caveman
+
+## Cuándo activar
+- Quieres reducir drásticamente el uso de tokens en una sesión larga
+- La ventana de contexto se está llenando y necesitas extender la vida útil de la sesión
+- Estás ejecutando una carga de trabajo sensible al costo (muchos agentes en paralelo, procesamiento por lotes)
+- Las respuestas de Claude son verbosas y quieres una salida concisa, estilo fragmento
+- Quieres comprimir archivos de memoria o CLAUDE.md existentes para reducir los tokens de entrada
+
+## Cuándo NO usar
+- Advertencias de seguridad o confirmaciones de acciones irreversibles — estas necesitan oraciones completas
+- Secuencias de varios pasos donde la ambigüedad de fragmentos podría causar lecturas erróneas
+- Incorporación de nuevos miembros del equipo a una base de código — la claridad supera a la brevedad aquí
+- Escritura de documentación que leerán personas externas
+
+## Instrucciones
+
+El modo Caveman es una técnica de compresión de tokens consolidada con una implementación dedicada en [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman). Este skill es un apuntador — usa el repositorio original, no lo dupliques aquí.
+
+### Qué hace
+
+El modo Caveman instruye a Claude a generar prosa comprimida, estilo fragmento:
+
+| Nivel | Regla | Ejemplo |
+|-------|-------|---------|
+| `lite` | Elimina relleno y matices, conserva artículos y oraciones completas | "The function handles edge cases." |
+| `full` | Elimina artículos, fragmentos permitidos, sinónimos cortos | "func handles edge cases" |
+| `ultra` | Abrevia palabras en prosa, elimina conjunciones, flechas para causalidad | "fn→edge cases handled" |
+
+Resultados medidos (marzo 2026, [arxiv.org/abs/2604.00025](https://arxiv.org/abs/2604.00025)):
+- ~65% de reducción en tokens de salida
+- Mejora de 26 puntos en benchmarks (la brevedad agudiza el razonamiento)
+- 100% de precisión técnica mantenida
+
+### Sub-skill caveman-compress
+Reescribe archivos de memoria `.md` y CLAUDE.md a prosa caveman — ~46% de ahorro en tokens de entrada en cada sesión, ya que los archivos comprimidos se vuelven a leer en cada carga de contexto.
+
+### Subagentes cavecrew
+Subagentes basados en Haiku ejecutándose en modo caveman — ~60% menos tokens que agentes estándar para tareas simples de clasificación, extracción y enrutamiento.
+
+### Middleware MCP caveman-shrink
+Comprime las descripciones de herramientas MCP antes de que entren al contexto de Claude — reduce la sobrecarga de MCP en ~30% sin cambiar el comportamiento de las herramientas.
+
+## Ejemplo
+
+**Activar el modo caveman en una sesión:**
+```
+Use caveman mode (full level) for this session. Drop articles, use fragments,
+short synonyms. Auto-revert to normal prose for: security warnings,
+irreversible action confirmations, multi-step sequences.
+```
+
+**Usar caveman-compress en un archivo de memoria:**
+```
+/caveman-compress .claude/memory/project-context.md
+```
+
+**Usar cavecrew para una tarea de clasificación:**
+```
+Spawn a cavecrew subagent (Haiku, caveman full) to classify these 200 support
+tickets into 5 categories. Return only: ticket_id, category.
+```
+
+---
+
+**Referencia:** [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman) — la implementación caveman de referencia. Claudient hace referencia a este trabajo; no se duplica aquí.
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. [uitbreiden.com](https://uitbreiden.com/)

package/skills/productivity/fr/caveman.md

@@ -0,0 +1,72 @@
+> 🇫🇷 Version française. [English version](../caveman.md).
+
+# Skill Mode Caveman
+
+## Quand activer
+- Vous souhaitez réduire drastiquement l'utilisation des tokens sur une longue session
+- La fenêtre de contexte se remplit et vous devez prolonger la durée de vie utile de la session
+- Vous exécutez une charge de travail sensible au coût (nombreux agents parallèles, traitement par lots)
+- Les réponses de Claude sont verbeuses et vous voulez une sortie concise en style fragmenté
+- Vous souhaitez compresser des fichiers mémoire ou CLAUDE.md existants pour réduire les tokens d'entrée
+
+## Quand NE PAS utiliser
+- Avertissements de sécurité ou confirmations d'actions irréversibles — ceux-ci nécessitent des phrases complètes
+- Séquences en plusieurs étapes où l'ambiguité des fragments pourrait provoquer des actions mal interprétées
+- Intégration de nouveaux membres d'équipe dans une base de code — la clarté prime sur la brièveté ici
+- Rédaction de documentation destinée à des personnes externes
+
+## Instructions
+
+Le mode Caveman est une technique de compression de tokens établie avec une implémentation dédiée sur [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman). Ce skill est un pointeur — utilisez le dépôt original, ne le dupliquez pas.
+
+### Ce qu'il fait
+
+Le mode Caveman demande à Claude de produire une prose compressée en style fragmenté :
+
+| Niveau | Règle | Exemple |
+|--------|-------|---------|
+| `lite` | Supprimer les mots de remplissage et les formules d'atténuation, garder les articles et les phrases complètes | "The function handles edge cases." |
+| `full` | Supprimer les articles, fragments acceptés, synonymes courts | "func handles edge cases" |
+| `ultra` | Abréger les mots en prose, supprimer les conjonctions, flèches pour la causalité | "fn→edge cases handled" |
+
+Résultats mesurés (mars 2026, [arxiv.org/abs/2604.00025](https://arxiv.org/abs/2604.00025)) :
+- ~65 % de réduction des tokens de sortie
+- Amélioration de 26 points sur les benchmarks (la brièveté affine le raisonnement)
+- 100 % de précision technique maintenue
+
+### Sous-skill caveman-compress
+Réécrit les fichiers mémoire `.md` et CLAUDE.md en prose caveman — environ 46 % d'économies de tokens d'entrée à chaque session, car les fichiers compressés sont relus à chaque chargement du contexte.
+
+### Sous-agents cavecrew
+Sous-agents basés sur Haiku fonctionnant en mode Caveman — environ 60 % de tokens en moins que des agents classiques pour les tâches simples de classification, d'extraction et de routage.
+
+### Middleware MCP caveman-shrink
+Compresse les descriptions d'outils MCP avant qu'elles n'entrent dans le contexte de Claude — réduit la surcharge MCP d'environ 30 % sans modifier le comportement des outils.
+
+## Exemple
+
+**Activation du mode Caveman dans une session :**
+```
+Use caveman mode (full level) for this session. Drop articles, use fragments,
+short synonyms. Auto-revert to normal prose for: security warnings,
+irreversible action confirmations, multi-step sequences.
+```
+
+**Utilisation de caveman-compress sur un fichier mémoire :**
+```
+/caveman-compress .claude/memory/project-context.md
+```
+
+**Utilisation de cavecrew pour une tâche de classification :**
+```
+Spawn a cavecrew subagent (Haiku, caveman full) to classify these 200 support
+tickets into 5 categories. Return only: ticket_id, category.
+```
+
+---
+
+**Référence :** [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman) — l'implémentation Caveman de référence. Claudient fait référence à ce travail ; il n'est pas dupliqué ici.
+
+---
+
+> **Travaillez avec nous :** Claudient est soutenu par [Uitbreiden](https://uitbreiden.com/) — nous construisons des produits IA et des solutions B2B avec des communautés de développeurs. [uitbreiden.com](https://uitbreiden.com/)