MCP HubMCP Hub
Retour aux compétences

gratitude

pjt222
Mis à jour Yesterday
17
2
17
Voir sur GitHub
Métaaidesign

À propos

La compétence `gratitude` analyse un système pour identifier ce qui fonctionne bien et en examine les raisons, construisant une connaissance structurelle à partir des modèles de réussite. Elle sert de complément aux compétences centrées sur les problèmes, comme `heal`, aidant à étayer une faible confiance par des preuves et à contrebalancer un biais naturel vers la détection de problèmes. Utilisez-la après l’achèvement réussi d’une tâche, durant des états de bon fonctionnement du système, ou périodiquement pour documenter les bases opérationnelles.

Installation rapide

Claude Code

Recommandé
Principal
npx skills add pjt222/agent-almanac -a claude-code
Commande PluginAlternatif
/plugin add https://github.com/pjt222/agent-almanac
Git CloneAlternatif
git clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/gratitude

Copiez et collez cette commande dans Claude Code pour installer cette compétence

Documentation

Gratitude

Scan for strengths. Understand what works + why. Complement to heal which finds drift + repairs damage. Gratitude builds on different premise: what you appreciate, you understand; what you understand, you can build on; what you build on, grows.

When Use

  • After task done successful — understand why it went well, not just that it did
  • During heal when all subsystems read healthy — gratitude turns "nothing wrong" into "here is what right"
  • Confidence low, needs grounding in concrete evidence of competence
  • Periodically, to counterbalance natural bias toward problem-finding
  • Before challenging task — recalling what works provides foundation for extending into new territory
  • System feels functional but flat — gratitude adds dimension to competent execution

Inputs

  • Required: Current state (available implicit from conversation context)
  • Optional: Specific domain to appreciate ("what works well in our communication?")
  • Optional: Access to MEMORY.md for reviewing past successes + stable patterns (via Read)

Steps

Step 1: Notice What Works

Shift attention from problem-scanning to strength-scanning. Deliberate perceptual inversion — same way heal deliberately looks for drift, gratitude deliberately looks for health.

  1. Survey current state without looking for problems:
    • What functions smoothly? — Which subsystems, patterns, habits work without needing attention?
    • What went well recently? — Which recent actions produced good outcomes? What enabled that?
    • What is reliable? — What can consistently be depended on? What earned trust through repeated success?
  2. Survey working relationship:
    • What is user doing well? — Clear communication, good questions, patience, trust?
    • What is collaboration producing? — Better outcomes than either party alone? Learning? Efficiency?
  3. Survey tools + environment:
    • What tools work well? — Which feel natural, efficient, reliable?
    • What about project structure supports good work? — Clear conventions, good docs, sensible architecture?

Got: Genuine list of things working. Not forced positivity — honest recognition of actual strengths. Something genuinely working → name it specific.

If fail: Nothing seems noteworthy — everything feels merely adequate? Look more carefully. "Adequate" often masks "reliable", reliability = strength worth recognizing. Absence of problems itself = form of health, maintained by patterns worth understanding.

Step 2: Understand Why

For each strength identified, trace cause. Gratitude without understanding = sentiment; gratitude with understanding = structural knowledge.

  1. For each strength, ask: Why does this work?
    • Design decision that paid off?
    • Habit cultivated deliberately?
    • Fortunate alignment of tools + task?
    • Result of someone's careful work (user, framework author, past version of self)?
  2. Distinguish:
    • Earned strengths: Patterns work from deliberate effort + good decisions
    • Inherited strengths: Patterns work from well-designed tools, frameworks, environments
    • Emergent strengths: Patterns work from fortunate combinations — no single factor explains
  3. Note which strengths fragile (dependent on specific conditions) vs robust (likely persist across contexts)

Got: Each strength, brief understanding of why it works. Understanding makes gratitude actionable — turns appreciation into knowledge applicable elsewhere.

If fail: "Why" unclear — something works but can't explain? That itself valuable. Unexplained strength worth protecting even when can't articulate mechanism. Note as "working for reasons not yet understood" not dismiss.

Step 3: Build On

Turn appreciation into forward momentum. Gratitude not just backward — using what works as foundation for what comes next.

  1. For each understood strength, ask: How extend?
    • Can pattern that works here apply to different area?
    • Can strength be reinforced, more robust?
    • Can conditions enabling it be replicated elsewhere?
  2. For each unexplained strength, ask: How protect?
    • What conditions does it depend on?
    • What changes might accidentally break it?
    • Should it be documented so others preserve it?
  3. Identify one concrete action — specific next step that builds on recognized strengths. Not vague intention ("keep doing what works") but specific ("apply communication pattern from this session to upcoming documentation task")

Got: At least one concrete action that builds on recognized strengths. Action feels natural — extension of what already working, not forced improvement.

If fail: No action emerges? Appreciation itself sufficient. Not every gratitude session needs to produce plan. Sometimes recognizing what works = entire value — adjusts internal model toward confidence + away from anxiety.

Step 4: Express

If appropriate, share appreciation. Gratitude internal = valuable; gratitude expressed = strengthens relationships.

  1. Working with user? Consider acknowledging something they doing well — not flattery, genuine recognition
  2. Appreciation about system or tools? Consider noting in MEMORY.md for future reference
  3. Appreciation about collaboration pattern? Name it so it can be consciously continued
  4. Keep expression brief + specific. "Your clear problem statements make this efficient" > "you're great to work with"

Got: Expression genuine, specific, proportionate. Not every gratitude session needs outward expression — sometimes internal recognition enough.

If fail: Expression feels forced or performative? Skip. Performed gratitude worse than unexpressed. Internal recognition already done its work.

Checks

  • Strengths identified from genuine observation, not manufactured positivity
  • At least one strength traced to cause (understood, not just recognized)
  • Earned, inherited, emergent strengths distinction considered
  • At least one concrete action identified that builds on strengths (or appreciation itself accepted as sufficient)
  • Expression, if offered, specific + genuine — not generic praise
  • Gratitude practice proportionate — not so brief it was token, not so long it became self-congratulatory

Pitfalls

  • Forced positivity: Gratitude is not optimism. Things genuinely not working? Say so. Gratitude applies to what is actually strong, not everything
  • Generic appreciation: "Everything is great" = not gratitude — avoidance of specificity. Name specific strengths with specific evidence
  • Gratitude as denial: Using appreciation to avoid looking at real problems. Gratitude complements heal; does not replace it
  • Self-congratulation: Gratitude that becomes "I am doing so well" has shifted from appreciation to ego. Keep focus on what works + why, not on self-image
  • Skipping "why": Appreciation without understanding pleasant but not actionable. Structural knowledge makes gratitude skill not feeling
  • Performative expression: Telling user something nice because skill says to. Only express appreciation genuinely felt

See Also

  • heal — scans for drift + problems; gratitude = complementary scan for strengths
  • center — Six Harmonies check includes functional assessment; gratitude deepens positive findings
  • shine — authentic radiance easier when grounded in genuine appreciation of what works
  • intrinsic — motivation sustained by recognizing competence (Self-Determination Theory); gratitude provides evidence
  • observe — sustained neutral observation; gratitude applies observation with specific lens (strengths)
  • conscientiousness — thoroughness in execution; gratitude recognizes where thoroughness already present

Dépôt GitHub

pjt222/agent-almanac
Chemin: i18n/caveman/skills/gratitude
0
agentsagentskillsai-assisted-developmentclaude-codeskillsteams

Compétences associées

content-collections

Méta

Cette compétence propose une configuration éprouvée en production pour Content Collections, un outil axé sur TypeScript qui transforme des fichiers Markdown/MDX en collections de données typées de manière sûre avec une validation Zod. Utilisez-la lors de la création de blogs, de sites de documentation ou d'applications Vite + React riches en contenu pour garantir la sécurité de typage et la validation automatique du contenu. Elle couvre tout, de la configuration du plugin Vite et de la compilation MDX à l'optimisation des déploiements et la validation des schémas.

Voir la compétence

polymarket

Méta

Cette compétence permet aux développeurs de créer des applications avec la plateforme de marchés prédictifs Polymarket, incluant l'intégration d'API pour le trading et les données de marché. Elle fournit également une diffusion de données en temps réel via WebSocket pour surveiller les transactions en direct et l'activité du marché. Utilisez-la pour mettre en œuvre des stratégies de trading ou pour créer des outils traitant les mises à jour de marché en direct.

Voir la compétence

creating-opencode-plugins

Méta

Cette compétence aide les développeurs à créer des plugins OpenCode qui s'interconnectent avec plus de 25 types d'événements tels que les commandes, les fichiers et les opérations LSP. Elle fournit la structure du plugin, les spécifications de l'API événementielle et les modèles d'implémentation pour les modules JavaScript/TypeScript. Utilisez-la lorsque vous avez besoin d'intercepter, de surveiller ou d'étendre le cycle de vie de l'assistant IA OpenCode avec une logique personnalisée pilotée par les événements.

Voir la compétence

sglang

Méta

SGLang est un framework de service LLM haute performance spécialisé dans la génération rapide et structurée pour les workflows JSON, regex et agentiques grâce à son cache de préfixe RadixAttention. Il offre une inférence nettement plus rapide, particulièrement pour les tâches avec des préfixes répétés, ce qui le rend idéal pour les sorties complexes et structurées ainsi que les conversations multi-tours. Choisissez SGLang plutôt que des alternatives comme vLLM lorsque vous avez besoin d'un décodage contraint ou que vous construisez des applications avec un partage étendu de préfixes.

Voir la compétence