gf-compound

Convert failures and review findings into reusable guardrails and lessons.

Updated Apr 25, 2026
One-click install
npx skills add https://github.com/Sailfishc/guanfu --skill gf-compound
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: gf-compound
Source: https://github.com/Sailfishc/guanfu/tree/main/skills/gf-compound
Command: npx skills add https://github.com/Sailfishc/guanfu --skill gf-compound

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Turn failures, review findings, taste mismatches, and process surprises into reusable project memory. A compound note should change future behavior. It must name the guardrail or explain why a guardrail is unnecessary.

Core Features & Use Cases

  • Convert incidents and postmortems into actionable guardrails and lessons.
  • Update the compound index and route to /gf-evolve when the issue recurs or gaps exist.
  • Capture root cause, evidence, and reusable rules to prevent recurrence.

Quick Start

Create a new compound note capturing the failure, the guardrail decision, and the next steps to evolve the skill.

Frequently Asked Questions about gf-compound

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

FAQPage Schema
How do I turn postmortem findings into reusable project knowledge?

You convert incidents into reusable project knowledge by capturing root cause and evidence, then producing a compound note that either names a specific guardrail or explains why one is unnecessary to change future behavior.

What is a compound note in knowledge management?

A compound note in knowledge management is a record that transforms failures, review findings, and taste mismatches into reusable project memory. It must change future behavior by establishing a guardrail or justifying why one is not needed.

How do I document root cause analysis results for code reviews?

Document root cause analysis results for code reviews by capturing the failure and evidence in a compound note, which updates the compound index and routes the issue to process evolution when gaps exist or the issue recurs.

Can I use this approach for process audits and taste mismatches?

Yes, you can use this approach for process audits and taste mismatches. It transforms process surprises and taste mismatches into actionable guardrails and lessons, updating the index to route recurring issues toward process evolution.

When should I create a compound note instead of just fixing the code?

You should create a compound note instead of just fixing the code when a failure reveals a process gap, taste mismatch, or review finding that needs a documented guardrail to prevent recurrence and drive future process improvement.

What's the best way to capture guardrails from incidents?

The best way to capture guardrails from incidents is to create a compound note that records the failure, the guardrail decision, and the next steps to evolve the process, ensuring the root cause and reusable rules are tracked for prevention.