Growth Log
Write growth log entries that extract reusable patterns from completed work — root cause, transferable rule, and a recognizable signal — instead of diary-style event narration, with a 4-8 sentence template and merge-duplicates discipline. Use when capturing what was learned after a complex task, debugging session, failure, or rollback, when reviewing progress over a period, or when a delivery gate asks what was learned.
Get the complete skill folder, including its scripts and reference files.
When to use this skill
Use Growth Log when an AI agent needs a reusable SKILL.md workflow for this job: Write growth log entries that extract reusable patterns from completed work — root cause, transferable rule, and a recognizable signal — instead of diary-style event narration, with a 4-8 sentence template and merge-duplicates discipline. Use when capturing what was learned after a complex task, debugging session, failure, or rollback, when reviewing progress over a period, or when a delivery gate asks what was learned.
When not to use it
Skip Growth Log when the task is outside the education category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/growth-log # Save SKILL.md to ~/.claude/skills/growth-log/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/growth-log/SKILL.md. For a shared project, commit the folder at .claude/skills/growth-log/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Growth Log skill for this task: Use Growth Log when this documented workflow matches the task. Confirm any required inputs or files before making changes.
What supports this recommendation?
70/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 77/100
- Practical detail
- 68/100
- Source evidence
- 63/100
- Source signals
- 70/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# Growth Log Skill
> **The problem:** Most people write "fixed a bug in X" as a learning log. That's a diary entry, not a learning artifact. A real growth log extracts the *pattern* so you recognize it next time. > > **This skill teaches:** How to write learning entries that compound across sessions. Works with any note-taking system — Markdown files, Notion, Obsidian, plain text. Templates are generic; adapt to your setup.
## When to Activate
- After completing a complex task (multi-file, new feature, architecture change) - After a failure, mistake, or "that was harder than expected" moment - When you want to review what you've learned over a period
**When NOT to activate:** Trivial changes (typo fixes, single-line tweaks, config value changes with no debugging). The threshold: *did this task involve debugging, redoing, rollback, or a non-obvious decision?* If yes → write an entry. If no → skip.
## The Three Rules
### Rule 1: Failures > Achievements
A failure is nutritionally denser than a success. One bug that took 2 hours to find teaches more than 3 features that worked first try.
**Bad:** "Successfully implemented the login flow." **Good (web dev):** "Login flow: session token wasn't persisting because the cookie `SameSite` defaulted to `Lax` in Chrome 128+. Pattern: always explicitly set `SameSite=None; Secure` when cross-origin. Signal to recognize: auth breaks after browser upgrade or when crossing origin boundaries." **Good (data pipeline):** "CSV import failed silently on empty rows because `pandas.read_csv(dropna=False)` keeps zero-width rows that `len()` counts as valid. Pattern: always `df.dropna(how='all', inplace=True)` before row-count validation."
### Rule 2: The Bole Principle (伯乐原则)
Before writing a new entry, ask: *"Is this fundamentally the same as something I already recorded?"*
Same root cause, different symptom → **merge**, don't duplicate. New root cause → new entry.
**How to check:** Search existing entries for keywords from your root cause before writing. If you find a match, add your new symptom as an additional example under the existing entry rather than creating a duplicate.
**Example:** "Forgot to update the output index after creating a file" and "Forgot to update skill ratings after a task" — same root cause (no automatic capture trigger). Merge into one entry about "post-task capture gaps."
### Rule 3: Must Be Transferable
Every entry must answer: *"Next time I face a similar situation, what do I do differently?"*
If you can't write that sentence, you haven't extracted the pattern yet.
**How to extract a pattern from a concrete event:** 1. State what happened in one sentence 2. Ask "why?" iteratively until you reach root cause (usually 3-5 whys) 3. Generalize: "What class of problem is this?" (not "Chrome 128 bug" but "browser default change breaking existing behavior") 4. Formulate as: "Next time I see [signal], I will [action]." 5. Name the signal: what specific observable tells you this pattern is active?
## Entry Template
**Scope:** One entry per distinct root cause. Typical length: 4-8 sentences. If it takes >2 minutes to write, you're narrating events. If <30 seconds, you haven't gone deep enough.
```markdown ## [Title: the pattern, not the event]
### Context - What was I trying to do? - What went wrong / what worked surprisingly well?
### Root Cause / Core Insight - The underlying mechanism, not just the symptom
### The Pattern (transferable) - Next time [similar situation], I will [specific action]. - Signal to recognize: [what observable tells me this pattern is active?]
### Related - [entry-name](../path/to/related-entry.md) ```
## Entry Types
All four types use the template above. The type determines which sections carry the most weight:
| Type | When to Use | Emphasis | Example Title | |------|------------|----------|---------------| | **Failure** | Something broke, needed debugging, or required rework | Root Cause | "Config inheritance ≠ behavior inheritance across sessions" | | **Methodology** | A repeatable process emerged from the work | Context / Pattern | "PPT → open-book exam study guide: three-layer structure" | | **Pattern Discovery** | A reusable insight about tools, systems, or thinking | Pattern section | "PR description template: describe the gap, not the feature" | | **Capability Change** | A measurable skill improvement | Context (before vs after) | "Git: from clone/push to independent PR with 12 commits" |
## Quality Checklist
Before finalizing a growth log entry:
- [ ] Does the title name the *pattern*, not the event? - [ ] Is there a "Next time I will..." sentence? - [ ] Is the "Signal to recognize" specific enough to trigger the pattern next time? - [ ] Did I search existing entries for duplicates before writing? (Bole Principle) - [ ] Is the root cause distinguished from the symptom? - [ ] Are related memories cross-linked? - [ ] Is the entry 4-8 sentences? Shorter = too shallow; longer = narrating events.
## Anti-Patterns
- Avoid: "Fixed bug in payment module" (event, not pattern) - Avoid: Copying the git commit message verbatim (commits describe what changed; logs extract why it matters) - Avoid: Writing an entry for every commit (only when a pattern emerges) - Avoid: Skipping the transferable sentence (without it, it's just a diary — this is non-negotiable) - Avoid: Duplicating the same pattern under different titles (violates Bole Principle — search before writing)
## Storage
Store entries wherever you keep notes. Common patterns: - Markdown files in a `growth-log/` directory (one file per day: `YYYY-MM-DD.md`) - A dedicated section in Notion, Obsidian, or your note-taking app - Plain text files with a consistent naming convention
Pick one convention and stick to it. Searchability matters more than format.
## If You Use Delivery Gate
The `delivery-gate` Stop hook checks that learning files were modified today via filesystem timestamps. This skill teaches *what to write* — so the file that delivery-gate checks actually contains useful patterns, not empty timestamps.
``` Task completes → delivery-gate checks: was the learning file touched today? → Stale (no file modified): block — "what did you learn?" → Fresh (file touched): pass — this skill ensures the content is useful ```
Having enforcement without methodology → empty entries. Having methodology without enforcement → forgotten captures. Each is independently useful; together they close the loop.
Intended uses
- Use Growth Log when this documented workflow matches the task.
Implementation notes
- Review the source instructions and adapt inputs before running the workflow.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.