Communitygithub.com

Opérations de notifications unifiées

Gérez les notifications comme un workflow natif ECC sur GitHub, Linear, alertes bureau, hooks et surfaces de communication connectées. À utiliser lorsque le vrai problème est le routage, la déduplication, l'escalade ou l'effondrement de la boîte de réception.

Qu'est-ce que Opérations de notifications unifiées ?

Cette compétence (`unified-notifications-ops`) permet de transformer un système de notifications fragmenté en une surface opérateur unifiée au sein de l'écosystème ECC. Elle est conçue pour les développeurs et les agents IA qui doivent gérer des alertes provenant de multiples sources (GitHub, Linear, hooks locaux, alertes bureau, chat, email) avec une politique de routage, de sévérité et de déduplication cohérente. La compétence propose un pipeline d'événements structuré (capture, classification, routage, collapse, action) et un modèle de sévérité par défaut pour décider ce qui doit interrompre, passer en digest ou être supprimé. Elle est idéale pour les environnements de développement intégrés (Claude Code, Cursor, Codex) où les notifications existantes génèrent du bruit plutôt que de l'action, et préfère une orchestration ECC-native (skills, hooks, agents, MCP) à l'adoption d'outils de notification externes. Le résultat est un plan actionnable incluant l'inventaire des surfaces, le modèle d'événements, le plan de routage et la prochaine étape ECC.

Compatible avec✓Claude Code✓Codex CLI~Cursor✓OpenCode
npx skills add https://github.com/affaan-m/everything-claude-code/tree/main/skills/unified-notifications-ops

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Opérations de notifications unifiées ?

Utilisez cette compétence lorsque le vrai problème n'est pas un ping manquant. Le vrai problème est un système de notifications fragmenté.

Le travail consiste à transformer des événements dispersés en une seule surface opérateur avec :

  • une sévérité claire
  • une propriété claire
  • un routage clair
  • une action de suivi claire

Quand l'utiliser

  • l'utilisateur souhaite une voie de notification unifiée sur GitHub, Linear, hooks locaux, alertes bureau, chat ou email
  • les échecs CI, les demandes de revue, les mises à jour de tickets et les événements opérateur arrivent dans des endroits déconnectés
  • la configuration actuelle crée du bruit au lieu de l'action
  • l'utilisateur souhaite consolider des branches de notification chevauchantes ou des propositions de backlog en une seule voie native ECC
  • l'espace de travail possède déjà des hooks, des MCP ou des outils connectés, mais aucune politique de notification cohérente

Surface privilégiée

Partez de ce qui existe déjà :

  • GitHub : tickets, PR, revues, commentaires et CI
  • Linear : déplacements de tickets/projets
  • événements de hooks locaux et signaux de cycle de session
  • primitives de notification bureau
  • surfaces email/chat connectées lorsqu'elles existent réellement

Préférez une orchestration native ECC plutôt que de demander à l'utilisateur d'adopter un produit de notification séparé.

Règles non négociables

  • ne jamais exposer de tokens, secrets, secrets de webhook ou identifiants internes
  • séparer :
    • source de l'événement
    • sévérité
    • canal de routage
    • action opérateur
  • par défaut, privilégier le digest lorsque le coût de l'interruption est incertain
  • ne pas diffuser chaque événement sur tous les canaux
  • si la vraie solution est un meilleur triage des tickets, une politique de hooks ou un flux de projet, le dire explicitement

Pipeline d'événements

Traitez la voie comme :

  1. Capturer l'événement
  2. Classer l'urgence et le propriétaire
  3. Router vers le bon canal
  4. Effondrer les doublons et le bruit à faible signal
  5. Attacher la prochaine action opérateur

L'objectif est d'avoir moins de notifications, mais de meilleure qualité.

Modèle de sévérité par défaut

ClasseExemplesTraitement par défaut
CritiqueCI de branche principale cassée, problème de sécurité, release bloquée, déploiement échouéinterrompre maintenant
Hauterevue demandée, PR en échec, transfert bloquant pour le propriétairealerte le jour même
Moyennechangements d'état de ticket, commentaires notables, mouvement du backlogdigest ou file d'attente
Faiblesuccès répétés, bruit de routine, marqueurs de cycle redondantssupprimer ou plier

Si l'espace de travail n'a pas de modèle de sévérité, construisez-en un avant de proposer de l'automatisation.

Workflow

1. Inventorier la surface actuelle

Listez :

  • sources d'événements
  • canaux actuels
  • hooks/scripts existants qui émettent des alertes
  • chemins dupliqués pour le même événement
  • cas d'échec silencieux où des éléments importants ne sont pas remontés

Soulignez ce que ECC possède déjà.

2. Décider ce qui mérite une interruption

Pour chaque famille d'événements, répondez :

  • qui doit être informé ?
  • à quelle vitesse doivent-ils être informés ?
  • cela doit-il interrompre, être regroupé en digest, ou simplement journalisé ?

Utilisez ces valeurs par défaut :

  • interrompre pour les événements de release, CI, sécurité et bloquants pour le propriétaire
  • digest pour les mises à jour à signal moyen
  • journalisation seule pour les données de télémétrie et les marqueurs de cycle à faible signal

3. Effondrer les doublons avant d'ajouter des canaux

Cherchez :

  • le même événement PR apparaissant dans GitHub, Linear et les logs locaux
  • des notifications de hook répétées pour le même échec
  • des commentaires ou du bruit de statut qui devraient être résumés plutôt que transférés bruts
  • des canaux qui se dupliquent sans apporter de meilleure action

Préférez :

  • un résumé canonique
  • un propriétaire
  • un canal principal
  • un chemin de repli

4. Concevoir le workflow natif ECC

Pour chaque besoin de notification réel, définissez :

  • source
  • porte
  • forme : alerte immédiate, digest, file d'attente ou tableau de bord uniquement
  • canal
  • action

Si ECC possède déjà la primitive, préférez :

  • une compétence pour le triage opérateur
  • un hook pour l'émission/l'application automatique
  • un agent pour la classification déléguée
  • un MCP/connecteur uniquement lorsqu'un pont réel manque

5. Retourner une conception orientée action

Terminez par :

  • ce qu'il faut conserver
  • ce qu'il faut supprimer
  • ce qu'il faut fusionner
  • ce que ECC devrait encapsuler ensuite

Format de sortie

SURFACE ACTUELLE
- sources
- canaux
- doublons
- lacunes

MODÈLE D'ÉVÉNEMENTS
- critique
- haute
- moyenne
- faible

PLAN DE ROUTAGE
- source -> canal
- pourquoi
- propriétaire opérateur

CONSOLIDATION
- supprimer
- fusionner
- résumés canoniques

PROCHAINE ACTION ECC
- compétence / hook / agent / MCP
- workflow exact à construire ensuite

Règles de recommandation

  • préférez une voie forte à de nombreuses voies faibles
  • préférez les digest pour les mises à jour à signal moyen et faible
  • préférez les hooks lorsque le signal doit être émis automatiquement
  • préférez les compétences opérateur lorsque le travail est du triage, du routage et de la prise de décision par revue
  • préférez project-flow-ops lorsque la cause racine est la coordination du backlog / des PR plutôt que les alertes
  • préférez workspace-surface-audit lorsque l'utilisateur a d'abord besoin d'un inventaire des sources
  • si les notifications de bureau suffisent, n'inventez pas un pont externe inutile

Cas d'utilisation appropriés

  • « Nous avons des alertes GitHub, Linear et hooks locaux, mais aucun flux opérateur unique »
  • « Nos échecs CI sont bruyants et les gens les ignorent »
  • « Je veux une politique de notification unique sur les surfaces Claude, OpenCode et Codex »
  • « Déterminez ce qui doit interrompre plutôt que d'atterrir dans un digest »
  • « Effondrez les idées de PR de notification qui se chevauchent en une seule voie ECC canonique »

Compétences associées

  • workspace-surface-audit
  • project-flow-ops
  • github-ops
  • knowledge-ops
  • customer-billing-ops lorsque la douleur de notification concerne les opérations de facturation/client plutôt que l'ingénierie

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/claude-api

Anthropic Claude API patterns for Python and TypeScript. Covers Messages API, streaming, tool use, vision, extended thinking, batches, prompt caching, and Claude Agent SDK. Use when building applications with the Claude API or Anthropic SDKs.

affaan-m/everything-claude-code

End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.

affaan-m/everything-claude-code

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/everything-claude-code-conventions

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/frontend-design

Create distinctive, production-grade frontend interfaces with high design quality. Use when the user asks to build web components, pages, or applications and the visual direction matters as much as the code quality.

affaan-m/gget

gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs.

affaan-m/literature-review

Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging.

affaan-m/motion-ui

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

affaan-m/project-guidelines-example

Example project-specific skill template based on a real production application.

affaan-m/pubmed-database

Direct PubMed and NCBI E-utilities search workflows for biomedical literature, MeSH queries, PMID lookup, citation retrieval, and API-backed literature monitoring.

affaan-m/scholar-evaluation

Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback.

affaan-m/uspto-database

USPTO patent and trademark data workflow for official record lookup, PatentSearch queries, TSDR checks, assignment data, and reproducible IP research logs.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

Skills associés