done

Analyze git diffs and logs to codify session learnings into actionable artifacts.

13|3|Updated Mar 2, 2026
One-click install
npx skills add https://github.com/phrazzld/agent-skills --skill done-phrazzld
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: done
Source: https://github.com/phrazzld/agent-skills/tree/main/core/done
Command: npx skills add https://github.com/phrazzld/agent-skills --skill done-phrazzld

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill addresses the challenge of capturing and acting upon learnings from development sessions, ensuring that valuable insights are not lost and are instead used to improve future work.

Core Features & Use Cases

  • Session Retrospective: Facilitates a structured review of a completed work session.
  • Codification of Learnings: Identifies friction points, bugs, and insights, then codifies them into actionable artifacts like updated documentation, new hooks, or agent configurations.
  • Feedback Loop: Captures implementation feedback for GitHub issues to inform future planning.
  • Use Case: After a complex debugging session, use /done to document the root cause, the fix, and any new patterns discovered, ensuring the team doesn't repeat the same mistake.

Quick Start

Run the done skill to capture learnings from the last coding session.

Frequently Asked Questions about done

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

FAQPage Schema
How do I capture development learnings from a git history after a session?

To capture development learnings, you can run a structured session retrospective that analyzes git diffs and logs. This process categorizes findings into predefined buckets and systematically codifies them into actionable artifacts like updated documentation or new hooks.

What is the best way to document root causes and fixes after debugging?

The best way to document root causes is using a retrospective workflow that identifies friction points and bugs. It codifies these insights into updated documentation, new hooks, or agent configurations to prevent the team from repeating the same mistake.

How do I create a feedback loop for future planning based on git logs?

You create a feedback loop by capturing implementation feedback directly from your session retrospective and git logs. This feedback is then routed to GitHub issues to inform future planning and workflow improvement.

Can I automatically codify session insights into hooks and agent configurations?

Yes, you can codify session insights into hooks and agent configurations. The retrospective process takes categorized findings from your git history and systematically writes them into relevant files like memory, documentation, or agent settings.

Does session retrospective codification work without external dependencies?

Session retrospective codification works without external dependencies. It relies solely on internal scripts and reference components to analyze your local git diffs and logs, categorize the findings, and generate actionable artifacts.