lesson-learned

Extract software engineering lessons from git history and diffs.

Updated May 15, 2026
One-click install
npx skills add https://github.com/JBonfim/skill-developer --skill lesson-learned-jbonfim
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: lesson-learned
Source: https://github.com/JBonfim/skill-developer/tree/main/.agents/skills/lesson-learned
Command: npx skills add https://github.com/JBonfim/skill-developer --skill lesson-learned-jbonfim

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It turns recent code changes into concrete software engineering lessons so you can learn from what you already shipped instead of repeating the same trade-offs blindly.

Core Features & Use Cases

  • Git-history-driven reflection: analyzes real commit messages and diffs rather than generic advice.
  • Principle-mapped takeaways: connects observed patterns to named engineering principles (for example SOLID, DRY, KISS, YAGNI) using a curated reference.
  • Scope-aware analysis: supports feature-branch vs main behavior, configurable commit ranges/SHAs, and working-tree changes.
  • Action-oriented output: produces 1–3 code-grounded lessons with what happened, why it matters, and a next step for future work.

Quick Start

Ask for an engineering takeaway after your latest PR or debugging work (for example: “What is the lesson here from these recent commits?”).

Frequently Asked Questions about lesson-learned

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I extract engineering lessons from git commit history?▼

You can extract engineering lessons from git commit history by analyzing recent diffs and commit messages to identify patterns, then mapping those observations to named software principles like SOLID or DRY for actionable takeaways.

What is the best way to reflect on code changes after a refactor?▼

The best way to reflect on code changes after a refactor is to review the git diff and connect the specific modifications to software engineering principles. This yields 1-3 code-grounded lessons with a next step for future work.

Can I analyze working tree changes or specific commit SHAs for code review takeaways?▼

Yes, you can analyze working tree changes or specific commit SHAs for code review takeaways. The analysis supports configurable commit ranges, specific commit SHAs, and uncommitted working-tree changes to generate reflective engineering lessons.

How do git diff analysis tools map code changes to software principles?▼

Git diff analysis tools map code changes to software principles by loading a curated engineering principles catalog, evaluating observed patterns in the diff against this reference, and producing specific, code-grounded takeaways mapped to principles like KISS or YAGNI.

When should I generate engineering takeaways from my codebase?▼

You should generate engineering takeaways from your codebase after feature work, debugging sessions, or refactoring. Applying this reflective analysis anytime you want to learn from specific commits helps you avoid repeating the same trade-offs blindly.