claudient 0.2.0 → 0.4.0

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/)

package/skills/productivity/nl/caveman.md

@@ -0,0 +1,72 @@
+> 🇳🇱 Nederlandse versie. [Engelse versie](../caveman.md).
+
+# Caveman Mode Skill
+
+## Wanneer te activeren
+- Je wilt het tokengebruik aanzienlijk verminderen tijdens een lange sessie
+- Het contextvenster raakt vol en je moet de nuttige levensduur van de sessie verlengen
+- Je voert een kostengevoelige werklast uit (veel parallelle agents, batchverwerking)
+- De antwoorden van Claude zijn uitgebreid en je wilt beknopte, fragmentstijl-uitvoer
+- Je wilt bestaande geheugen- of CLAUDE.md-bestanden comprimeren om invoertokens te verminderen
+
+## Wanneer NIET te gebruiken
+- Beveiligingswaarschuwingen of bevestigingen van onomkeerbare acties — deze hebben volledige zinnen nodig
+- Meerstappige reeksen waarbij fragmentambiguïteit tot verkeerd gelezen acties kan leiden
+- Onboarding van nieuwe teamleden in een codebase — duidelijkheid gaat hier boven beknoptheid
+- Documentatie schrijven die externe mensen zullen lezen
+
+## Instructies
+
+Caveman mode is een gevestigde tokencompressietechniek met een speciale implementatie op [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman). Deze skill is een verwijzing — gebruik de originele repo, dupliceer deze niet.
+
+### Wat het doet
+
+Caveman mode instrueert Claude om gecomprimeerde, fragmentstijl-proza te produceren:
+
+| Niveau | Regel | Voorbeeld |
+|--------|-------|-----------|
+| `lite` | Verwijder opvulling en aarzeling, behoud lidwoorden en volledige zinnen | "The function handles edge cases." |
+| `full` | Verwijder lidwoorden, fragmenten toegestaan, korte synoniemen | "func handles edge cases" |
+| `ultra` | Afkort prozawoorden, verwijder voegwoorden, pijlen voor causaliteit | "fn→edge cases handled" |
+
+Gemeten resultaten (maart 2026, [arxiv.org/abs/2604.00025](https://arxiv.org/abs/2604.00025)):
+- ~65% vermindering van uitvoertokens
+- 26 punten verbetering op benchmarks (beknoptheid scherpt het redeneren)
+- 100% technische nauwkeurigheid behouden
+
+### caveman-compress sub-skill
+Herschrijft `.md`-geheugen- en CLAUDE.md-bestanden naar caveman-proza — ~46% besparing op invoertokens per sessie, omdat gecomprimeerde bestanden bij elke contextlading opnieuw worden ingelezen.
+
+### cavecrew subagents
+Op Haiku gebaseerde subagents die in caveman mode draaien — ~60% minder tokens dan gewone agents voor eenvoudige classificatie-, extractie- en routeringstaken.
+
+### caveman-shrink MCP middleware
+Comprimeert MCP-toolteschrijvingen voordat ze de context van Claude binnengaan — vermindert MCP-overhead met ~30% zonder het gedrag van tools te wijzigen.
+
+## Voorbeeld
+
+**Caveman mode activeren in een sessie:**
+```
+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 gebruiken op een geheugenbestand:**
+```
+/caveman-compress .claude/memory/project-context.md
+```
+
+**cavecrew gebruiken voor een classificatietaak:**
+```
+Spawn a cavecrew subagent (Haiku, caveman full) to classify these 200 support
+tickets into 5 categories. Return only: ticket_id, category.
+```
+
+---
+
+**Referentie:** [github.com/JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman) — de gezaghebbende caveman-implementatie. Claudient verwijst naar dit werk; het wordt hier niet gedupliceerd.
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — wij bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. [uitbreiden.com](https://uitbreiden.com/)