Communitygithub.com

growth-log

Nach einer komplexen Aufgabe, einem Fehlschlag oder bei der Überprüfung dessen, was gelernt wurde, anwenden. Lehrt, wie man Wachstumsprotokolle erstellt, die wiederverwendbare Muster extrahieren – keine Tagebucheinträge.

Was ist growth-log?

Dieser Skill lehrt Entwickler und KI-Agenten, wie man Wachstumsprotokolle (Growth Logs) erstellt – Lernartefakte, die über mehrere Sitzungen hinweg Wert aufbauen, anstatt einfache Tagebucheinträge zu sein. Er ist für jede Aufgabenumgebung geeignet, die komplexe Arbeit oder Fehlerbehebung umfasst, und funktioniert mit jedem Notizsystem (Markdown, Notion, Obsidian). Der Skill definiert drei Kernregeln: Fehler sind wertvoller als Erfolge, wiederhole keine bereits dokumentierten Muster (Bole Principle), und jeder Eintrag muss eine übertragbare Erkenntnis enthalten („Beim nächsten Mal werde ich …“). Eine detaillierte Vorlage und Qualitätsprüfungen helfen dabei, Muster von Ereignissen zu trennen, Ursachen von Symptomen zu unterscheiden und Einträge prägnant zu halten. Die vier Eintragstypen – Fehlschlag, Methodik, Mustererkennung und Fähigkeitsänderung – decken verschiedene Lernsituationen ab. Der Skill kann mit einem optionalen „Delivery Gate“ kombiniert werden, das anhand des Dateizeitstempels prüft, ob heute eine Lernnotiz erstellt wurde, und so die Disziplin der kontinuierlichen Reflexion sicherstellt.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/everything-claude-code/tree/main/skills/growth-log

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Wachstumsprotokoll-Skill

Das Problem: Die meisten Leute schreiben "Fehler in X behoben" als Lerntagebuch. Das ist ein Tagebucheintrag, kein Lernartefakt. Ein echtes Wachstumsprotokoll extrahiert das Muster, damit du es beim nächsten Mal wiedererkennst.

Dieser Skill lehrt: Wie man Lerneinträge schreibt, die sich über mehrere Sitzungen hinweg aufbauen. Funktioniert mit jedem Notizsystem – Markdown-Dateien, Notion, Obsidian, einfacher Text. Die Vorlagen sind generisch; passe sie an deine Umgebung an.

Wann aktivieren

  • Nach einer komplexen Aufgabe (mehrere Dateien, neue Funktion, Architekturänderung)
  • Nach einem Fehlschlag, Fehler oder einem "Das war schwieriger als erwartet"-Moment
  • Wenn du überprüfen möchtest, was du über einen Zeitraum gelernt hast

Wann NICHT aktivieren: Triviale Änderungen (Tippfehlerkorrektur, einzeilige Anpassungen, Konfigurationswertänderungen ohne Fehlersuche). Der Schwellenwert: War bei dieser Aufgabe Fehlersuche, Nacharbeit, Rollback oder eine nicht offensichtliche Entscheidung erforderlich? Wenn ja → Eintrag schreiben. Wenn nein → überspringen.

Die drei Regeln

Regel 1: Fehler > Erfolge

Ein Fehler ist nährstoffdichter als ein Erfolg. Ein einzelner Bug, der 2 Stunden zum Finden brauchte, lehrt mehr als 3 Features, die beim ersten Versuch funktionierten.

Schlecht: "Erfolgreich den Login-Flow implementiert." Gut (Webentwicklung): "Login-Flow: Session-Token wurde nicht persistent, weil das Cookie SameSite standardmäßig auf Lax in Chrome 128+ gesetzt war. Muster: Immer explizit SameSite=None; Secure setzen, wenn Cross-Origin. Erkennungssignal: Auth bricht nach Browser-Update oder beim Überqueren von Origin-Grenzen." Gut (Datenpipeline): "CSV-Import schlug bei leeren Zeilen stillschweigend fehl, weil pandas.read_csv(dropna=False) Zeilen mit Breite Null behält, die len() als gültig zählt. Muster: Immer df.dropna(how='all', inplace=True) vor der Zeilenanzahl-Validierung."

Regel 2: Das Bole-Prinzip (伯乐原则)

Bevor du einen neuen Eintrag schreibst, frage: "Ist dies grundlegend dasselbe wie etwas, das ich bereits aufgezeichnet habe?"

Gleiche Ursache, anderes Symptom → zusammenführen, nicht duplizieren. Neue Ursache → neuer Eintrag.

So überprüfst du: Suche vor dem Schreiben in vorhandenen Einträgen nach Schlüsselwörtern aus deiner Ursache. Wenn du einen Treffer findest, füge dein neues Symptom als zusätzliches Beispiel unter dem vorhandenen Eintrag hinzu, anstatt ein Duplikat zu erstellen.

Beispiel: "Vergessen, den Ausgabeindex nach dem Erstellen einer Datei zu aktualisieren" und "Vergessen, die Skill-Bewertungen nach einer Aufgabe zu aktualisieren" – gleiche Ursache (kein automatischer Erfassungsauslöser). In einen Eintrag über "Erfassungslücken nach Aufgaben" zusammenführen.

Regel 3: Muss übertragbar sein

Jeder Eintrag muss beantworten: "Was mache ich beim nächsten Mal in einer ähnlichen Situation anders?"

Wenn du diesen Satz nicht schreiben kannst, hast du das Muster noch nicht extrahiert.

So extrahiert man ein Muster aus einem konkreten Ereignis:

  1. Beschreibe das Ereignis in einem Satz
  2. Frage iterativ "warum?", bis du zur Ursache gelangst (normalerweise 3-5 Warums)
  3. Verallgemeinere: "Um welche Klasse von Problemen handelt es sich?" (nicht "Chrome-128-Fehler", sondern "Browser-Standardänderung, die bestehendes Verhalten bricht")
  4. Formuliere als: "Beim nächsten Mal, wenn ich [Signal] sehe, werde ich [Aktion] ausführen."
  5. Benenne das Signal: Welche spezifische Beobachtung sagt dir, dass dieses Muster aktiv ist?

Eintragsvorlage

Umfang: Ein Eintrag pro eindeutiger Ursache. Typische Länge: 4-8 Sätze. Wenn das Schreiben >2 Minuten dauert, erzählst du Ereignisse. Wenn <30 Sekunden, bist du nicht tief genug gegangen.

## [Titel: das Muster, nicht das Ereignis]

### Kontext
- Was wollte ich tun?
- Was ist schiefgelaufen / was hat überraschend gut funktioniert?

### Ursache / Kerneinsicht
- Der zugrunde liegende Mechanismus, nicht nur das Symptom

### Das Muster (übertragbar)
- Beim nächsten Mal [ähnliche Situation] werde ich [spezifische Aktion] ausführen.
- Signal zum Erkennen: [welche Beobachtung sagt mir, dass dieses Muster aktiv ist?]

### Verwandt
- [Eintragsname](../pfad/zum/verwandten-eintrag.md)

Eintragstypen

Alle vier Typen verwenden die obige Vorlage. Der Typ bestimmt, welche Abschnitte das meiste Gewicht haben:

TypWann verwendenSchwerpunktBeispieltitel
FehlschlagEtwas ist kaputtgegangen, erforderte Fehlersuche oder NacharbeitUrsache"Konfigurationsvererbung ≠ Verhaltensvererbung über Sitzungen hinweg"
MethodikEin wiederholbarer Prozess ergab sich aus der ArbeitKontext / Muster"PPT → Offenes-Buch-Prüfungsvorbereitung: Dreischichtige Struktur"
MustererkennungEine wiederverwendbare Einsicht über Werkzeuge, Systeme oder DenkenMusterabschnitt"PR-Beschreibungsvorlage: Beschreibe die Lücke, nicht das Feature"
FähigkeitsänderungEine messbare Verbesserung der FähigkeitenKontext (vorher vs. nachher)"Git: Von Clone/Push zu unabhängigem PR mit 12 Commits"

Qualitäts-Checkliste

Bevor du einen Wachstumsprotokoll-Eintrag finalisierst:

  • Benennt der Titel das Muster, nicht das Ereignis?
  • Gibt es einen Satz "Beim nächsten Mal werde ich …"?
  • Ist das "Signal zum Erkennen" spezifisch genug, um das Muster beim nächsten Mal auszulösen?
  • Habe ich vor dem Schreiben in vorhandenen Einträgen nach Duplikaten gesucht? (Bole-Prinzip)
  • Ist die Ursache vom Symptom unterschieden?
  • Sind verwandte Erinnerungen verknüpft?
  • Ist der Eintrag 4-8 Sätze lang? Kürzer = zu oberflächlich; länger = Ereignisse erzählen.

Anti-Patterns

  • Vermeide: "Fehler im Zahlungsmodul behoben" (Ereignis, kein Muster)
  • Vermeide: Den Git-Commit-Nachricht wortwörtlich kopieren (Commits beschreiben, was sich geändert hat; Protokolle extrahieren, warum es wichtig ist)
  • Vermeide: Für jeden Commit einen Eintrag schreiben (nur wenn ein Muster auftaucht)
  • Vermeide: Den übertragbaren Satz auslassen (ohne ihn ist es nur ein Tagebuch – das ist nicht verhandelbar)
  • Vermeide: Dasselbe Muster unter verschiedenen Titeln zu duplizieren (verstößt gegen das Bole-Prinzip – vor dem Schreiben suchen)

Speicherung

Speichere Einträge dort, wo du Notizen aufbewahrst. Übliche Muster:

  • Markdown-Dateien in einem growth-log/-Verzeichnis (eine Datei pro Tag: YYYY-MM-DD.md)
  • Ein dedizierter Abschnitt in Notion, Obsidian oder deiner Notiz-App
  • Einfache Textdateien mit einer einheitlichen Namenskonvention

Wähle eine Konvention und bleibe dabei. Durchsuchbarkeit ist wichtiger als Format.

Falls du Delivery Gate verwendest

Der delivery-gate Stop-Hook prüft anhand von Dateisystem-Zeitstempeln, ob Lerndateien heute geändert wurden. Dieser Skill lehrt was zu schreiben ist – damit die Datei, die Delivery Gate überprüft, tatsächlich nützliche Muster enthält, nicht leere Zeitstempel.

Aufgabe abgeschlossen → Delivery Gate prüft: wurde die Lerndatei heute bearbeitet?
  → Veraltet (keine Datei geändert): blockieren – "Was hast du gelernt?"
  → Aktuell (Datei bearbeitet): bestehen – dieser Skill stellt sicher, dass der Inhalt nützlich ist

Erzwingung ohne Methodik → leere Einträge. Methodik ohne Erzwingung → vergessene Erfassungen. Beide sind eigenständig nützlich; zusammen schließen sie den Kreislauf.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/claude-api

Anthropic Claude API patterns for Python and TypeScript. Covers Messages API, streaming, tool use, vision, extended thinking, batches, prompt caching, and Claude Agent SDK. Use when building applications with the Claude API or Anthropic SDKs.

affaan-m/everything-claude-code

End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.

affaan-m/everything-claude-code

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/everything-claude-code-conventions

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/frontend-design

Create distinctive, production-grade frontend interfaces with high design quality. Use when the user asks to build web components, pages, or applications and the visual direction matters as much as the code quality.

affaan-m/gget

gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs.

affaan-m/literature-review

Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging.

affaan-m/motion-ui

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

affaan-m/project-guidelines-example

Example project-specific skill template based on a real production application.

affaan-m/pubmed-database

Direct PubMed and NCBI E-utilities search workflows for biomedical literature, MeSH queries, PMID lookup, citation retrieval, and API-backed literature monitoring.

affaan-m/scholar-evaluation

Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback.

affaan-m/uspto-database

USPTO patent and trademark data workflow for official record lookup, PatentSearch queries, TSDR checks, assignment data, and reproducible IP research logs.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

Verwandte Skills