Communitygithub.com

amplitude/builder-skills

Crée des graphiques Amplitude à partir de descriptions en langage naturel, en gérant la sélection d'événements, les filtres, les regroupements et les choix de visualisation. À utiliser lorsque vous savez ce que vous voulez mesurer mais préférez ne pas construire le graphique manuellement.

Qu'est-ce que builder-skills ?

Cette compétence vous permet de créer des graphiques Amplitude en décrivant simplement ce que vous souhaitez mesurer, sans avoir à manipuler manuellement l'interface. Elle guide l'agent (comme Claude Code, Cursor ou Codex) à travers un processus structuré : d'abord, une phase de planification où la requête est décomposée en composants (type de graphique, métrique, événements, filtres, segments). Ensuite, une recherche d'événements est effectuée de manière large pour découvrir toutes les options pertinentes, y compris les événements personnalisés et les métriques agrégées, avant de faire un choix éclairé. L'agent évalue les résultats, sélectionne l'événement le plus approprié (en privilégiant les événements personnalisés qui agrègent des activités connexes) et explique sa décision. Enfin, la définition du graphique est construite avec les paramètres appropriés (type de graphique, intervalle, filtres, regroupements), le graphique est créé via l'API Amplitude, et les résultats sont vérifiés. La compétence supporte tous les types de graphiques Amplitude (segmentation d'événements, entonnoirs, rétention, tableau de données, parcours client, sessions) et inclut des mécanismes de gestion d'erreurs et de validation pour garantir des graphiques précis et pertinents.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/amplitude/builder-skills/tree/HEAD/analytics-skills/skills/create-chart

Demander à votre IA préférée

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

Documentation

Créer un graphique Amplitude

Créez des graphiques à partir de langage naturel en découvrant des événements, en construisant des définitions de graphiques et en vérifiant les résultats.

Planification d'abord (Critique)

Avant tout appel d'outil, décomposez la demande :

1. Identifiez les composants du graphique :

  • Type de graphique et métrique (ce qui est mesuré)
  • Période de temps (par défaut : 30 derniers jours si non spécifié)
  • Événement principal (l'action comptée)
  • Conditions de segment (filtres/groupes d'utilisateurs)
  • Filtres, regroupements, ventilations
  • Étapes de l'entonnoir (si analyse de conversion)

2. Planifiez les recherches d'événements :

  • UNE recherche par concept d'événement distinct
  • Ne combinez jamais plusieurs concepts en une seule recherche
  • Exemple : "achat" et "inscription" nécessitent des recherches séparées

3. Planifiez les appels d'outils parallèles :

  • Obtenir le contexte, rechercher des événements, trouver des cohortes peuvent être exécutés ensemble
  • Attendez les résultats avant de construire la définition

Découverte d'événements (Critique : Découverte d'abord)

IMPORTANT : Jetez un filet large avant de préciser

Lorsque la demande de l'utilisateur est ambiguë ou peut correspondre à plusieurs événements :

  1. Recherchez d'abord LARGEMENT pour découvrir les options pertinentes
  2. Examinez les résultats pertinents – recherchez les événements associés, les événements personnalisés, les méta-événements
  3. Présentez les options à l'utilisateur OU expliquez votre logique de sélection
  4. Essayez de ne pas supposer qu'un seul événement est la seule réponse sans exploration

Recherchez des événements :

Amplitude:search avec entity_types=['EVENT', 'CUSTOM_EVENT']
  • Recherchez UN concept à la fois
  • Utilisez d'abord des termes de recherche larges (p. ex., "IA", pas seulement "chat IA")
  • ✓ Bon : "l'utilisateur finalise un achat"
  • ✗ Mauvais : "événements d'inscription ou d'achat"

Prenez des décisions éclairées, puis expliquez :

  1. Recherchez largement pour découvrir toutes les options
  2. Examinez les résultats et identifiez l'approche la plus complète/précise
  3. Faites votre meilleur jugement (préférez les événements personnalisés agrégés aux événements uniques)
  4. Expliquez toujours : "J'ai trouvé les options X, Y, Z. J'ai choisi [X] parce que [raison]. Cela inclut/exclut [périmètre]."
  5. L'utilisateur peut corriger si votre hypothèse était erronée

Critères de décision :

  • Préférez les événements personnalisés qui agrègent des activités connexes (p. ex., "[2026] Métrique d'activation [événements IA uniquement]")
  • Si aucun événement agrégé n'existe, choisissez l'événement d'interaction principal
  • Considérez ce que signifie "utilisateur actif" pour ce domaine produit
  • Par défaut, optez pour un périmètre plus large, sauf si l'utilisateur spécifie un focus étroit

Exemples :

  • ❌ MAUVAIS : L'utilisateur demande "utilisateurs IA hebdomadaires" → choisir immédiatement "ai-chat : envoyer un message" sans exploration, sans explication
  • ✅ BON : L'utilisateur demande "utilisateurs IA hebdomadaires" → rechercher "IA", trouver Ask AI, Agents, Visibilité, événement personnalisé agrégé. Répondre : "J'ai trouvé une activité IA dans Ask AI, Agents et Visibilité. J'utilise l'événement personnalisé '[2026] Métrique d'activation [événements IA uniquement]' qui inclut toutes les interactions des produits IA. Cela vous donne le nombre total d'utilisateurs IA sur toutes les fonctionnalités. Faites-moi savoir si vous souhaitez vous concentrer sur un produit IA spécifique à la place."

Vérifiez avant d'utiliser :

  • Obtenez des graphiques existants utilisant l'événement via la recherche
  • Vérifiez que l'événement a un volume réel (pas nul/obsolète)
  • Recherchez des événements personnalisés qui agrègent une activité connexe
  • Si les résultats sont nuls, recherchez des alternatives

Obtenez les propriétés :

Amplitude:get_event_properties pour les noms/valeurs de propriétés exacts

Trouvez des cohortes :

Amplitude:search avec entity_types=['COHORT']
Amplitude:get_cohorts pour obtenir les définitions complètes

Sélection du type de graphique

Type de graphiqueQuand l'utiliser
eventsSegmentationCompter les événements/utilisateurs dans le temps, tendances, comparaisons, KPI, distributions, analyses de propriétés
funnelsAnalyse de conversion en plusieurs étapes avec une séquence connue, analyse des points d'abandon, temps entre des événements spécifiques, métriques de temps de conversion
retentionComportement de retour des utilisateurs, courbes de rétention de cohorte, analyse de désabonnement
dataTableV2Comparaisons tabulaires, classements, ventilations multidimensionnelles
customerJourneyExploration de parcours, découverte de parcours inconnus des utilisateurs, comparaison des parcours convertis vs abandonnés
sessionsDurée des sessions, fréquence des sessions, temps passé par utilisateur, distributions de longueur de session

Référence rapide

eventsSegmentation - Le plus polyvalent. À utiliser pour :

  • Décomptes d'utilisateurs (DAU, WAU, MAU) avec la métrique uniques
  • Totaux d'événements, moyennes, sommes de propriétés
  • Percentiles, distributions, formules
  • Séries temporelles avec fenêtres glissantes

Périmètre d'agrégation (eventsSegmentation) :

  • PROPSUM(A) / metric: "sums" = Somme globale sur TOUS les événements
  • metric: "frequency" = Distribution des décomptes d'événements par utilisateur (combien d'utilisateurs l'ont fait 1x, 2x, 3x)
  • Pour la "distribution de la somme de propriétés par utilisateur" : Amplitude ne supporte pas cela directement. Utilisez metric: "frequency" pour les distributions de nombre d'événements, ou utilisez dataTableV2 groupé par user_id avec PROPSUM, puis exportez pour une analyse externe.

funnels - Analyse de conversion avec étapes prédéfinies. À utiliser pour :

  • Taux de conversion étape par étape lorsque vous connaissez la séquence attendue
  • Séquences ordonnées ou non
  • Temps de conversion (temps médian entre les événements)
  • Événements d'exclusion, fenêtres de conversion
  • Événements qui se chevauchent : Pour trouver les utilisateurs qui ont effectué plusieurs événements (dans n'importe quel ordre), utilisez un entonnoir avec "ordre quelconque" et réglez la fenêtre de conversion pour correspondre à la plage de dates du graphique
  • Remarque : Si vous souhaitez découvrir les parcours empruntés par les utilisateurs, utilisez plutôt customerJourney

retention - Comportement de retour. À utiliser pour :

  • Courbes de rétention sur N jours ou glissantes
  • Analyse de cohorte (nouveaux vs utilisateurs connus)
  • Modèles événement de départ → événement de retour

dataTableV2 - Données tabulaires. À utiliser pour :

  • Ventilations par dimensions (pays, plateforme, etc.)
  • Comparaisons multi-métriques au format tableau

customerJourney - Exploration et découverte de parcours. À utiliser pour :

  • Comprendre les parcours réels empruntés par les utilisateurs (vs les parcours attendus dans les entonnoirs)
  • Analyser les parcours commençant par, se terminant par ou entre deux événements spécifiques
  • Comparer côte à côte les parcours des utilisateurs convertis et abandonnés
  • Découvrir des modèles de navigation inattendus ou des points de friction
  • Explorer la fréquence, la similarité ou le temps moyen de réalisation d'un parcours
  • Combler l'écart entre les parcours clients idéaux et le comportement réel des utilisateurs

sessions - Métriques d'engagement basées sur les sessions. À utiliser pour :

  • Analyse de la durée des sessions (longueur moyenne, temps passé, distributions)
  • Fréquence des sessions (sessions moyennes par utilisateur, sessions totales)
  • Temps passé par utilisateur dans le temps
  • Événements effectués au sein des sessions (événements moyens par session)
  • Comparaison du comportement des sessions entre segments d'utilisateurs

Métriques spéciales :

  • Décomptes d'utilisateurs : metric: "uniques"
  • Décomptes d'événements : metric: "totals"
  • Sommes de propriétés : metric: "sums" avec la propriété dans group_by
  • Taux/pourcentages : À utiliser lors de la comparaison de groupes de tailles différentes

Méta-événements :

  • _active : Tout événement actif (DAU, MAU)
  • _new : Nouveaux utilisateurs (premier événement)
  • _any_revenue_event : Événements de revenu

Structure de la définition du graphique

Paramètres de base (tous types de graphiques) :

{
  "name": "Titre descriptif du graphique",
  "projectId": "12345",
  "definition": {
    "app": "12345",
    "type": "eventsSegmentation",
    "params": {
      "range": "30 derniers jours",
      "events": [{
        "event_type": "Achat finalisé",
        "filters": [],
        "group_by": []
      }],
      "metric": "uniques",
      "countGroup": "User",
      "interval": 1,
      "segments": [{"conditions": []}]
    }
  }
}

Paramètres clés :

  • countGroup : "User" (utilisateurs uniques) ou "Event" (occurrences d'événements)
  • interval : 1 (quotidien), 7 (hebdomadaire), 30 (mensuel)
  • segments : Filtres/groupes d'utilisateurs (tableau vide = tous les utilisateurs)

Filtres d'événements (logique OU inline) :

"filters": [{
  "group_type": "User",
  "subprop_key": "country",
  "subprop_op": "is",
  "subprop_type": "event",
  "subprop_value": ["États-Unis", "Canada"]
}]

Segments d'utilisateurs (conditions logique ET) :

"segments": [{
  "name": "Utilisateurs actifs",
  "conditions": [{
    "type": "property",
    "group_type": "User",
    "prop_type": "user",
    "prop": "plan",
    "op": "is",
    "values": ["Pro", "Enterprise"]
  }]
}]

Segments de cohorte : Recherchez la cohorte, obtenez l'ID, puis :

"segments": [{
  "name": "Ma cohorte",
  "conditions": [{
    "type": "cohort",
    "group_type": "User",
    "cohort_id": "abc123",
    "op": "is_in"
  }]
}]

Workflow : Créer un graphique

  1. Obtenez le contexte :
Amplitude:get_context (pour projectId)
  1. Découvrez les événements (RECHERCHE LARGE d'abord) :
Amplitude:search pour chaque concept distinct
- Utilisez d'abord des termes de recherche larges
- Recherchez tous les événements, événements personnalisés, cohortes associés
- Examinez TOUS les résultats avant de sélectionner
  1. Évaluez et décidez :
  • Passez en revue tous les événements et événements personnalisés découverts
  • Prenez une décision éclairée (préférez les événements agrégés)
  • Préparez une explication claire de ce que vous avez trouvé et de votre choix
  1. Trouvez des graphiques similaires (voir exemples) :
Amplitude:search entity_types=['CHART'] query="concept similaire"
Amplitude:get_charts pour voir la structure de définition
  1. Obtenez les propriétés si nécessaire :
Amplitude:get_event_properties
  1. Construisez la définition en utilisant les noms découverts
  • Expliquez la logique de sélection de l'événement dans la réponse
  1. Créez le graphique :
Amplitude:query_dataset avec la définition complète
  1. Vérifiez les résultats - confirmez que les données ont du sens

  2. Sauvegardez le graphique :

Amplitude:save_chart_edits avec editId de query_dataset

Gestion des erreurs

Si query_dataset échoue :

  • Lisez attentivement le message d'erreur
  • Problèmes courants : noms d'événements incorrects, filtres invalides, mauvais types de paramètres
  • Corrigez la définition et réessayez
  • Vérifiez d'abord que les événements existent via la recherche

Si les résultats sont nuls :

  • Vérifiez que les filtres ne sont pas trop restrictifs
  • Vérifiez que l'événement a des données (recherchez des graphiques l'utilisant)
  • Essayez une période de temps plus large
  • Vérifiez les conditions de segment

Meilleures pratiques

Nommage :

  • Inclure la métrique + le contexte temporel : "Utilisateurs actifs hebdomadaires des 90 derniers jours"
  • Pas : "WAU" ou "Utilisateurs"

Périodes de temps :

  • Par défaut : "30 derniers jours"
  • Utilisez des plages inclusives pour des périodes spécifiques
  • Énoncez explicitement la plage interprétée

Vérification :

  • Vérifiez toujours que l'événement existe avant de l'utiliser
  • Consultez les graphiques similaires pour comprendre l'utilisation de l'événement
  • Confirmez les propriétés avec get_event_properties

Comparaisons :

  • Utilisez des segments pour comparer des groupes d'utilisateurs sur le même graphique
  • Utilisez des taux/pourcentages pour des groupes de tailles différentes

Incluez toujours :

  • L'URL du graphique dans la réponse
  • Ce que montre le graphique
  • Les principaux insights des données initiales
  • La méthodologie utilisée

Individual skills in this repo

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

amplitude/builder-skills

Performs deep analysis of a specific Amplitude chart to explain trends, anomalies, and likely drivers. Use when a metric looks unusual, investigating a spike or drop, or understanding the "why" behind numbers.

amplitude/builder-skills

Deeply analyze Amplitude dashboards by analyzing key charts, surfacing top areas for concern and takeaways, identify anomalies, then explain changes using customer feedback trends.

amplitude/builder-skills

Designs A/B tests with proper metrics and variants, analyzes running or completed experiments, and interprets results with statistical rigor. Use when setting up experiments, checking experiment status, analyzing results, or making ship decisions.

amplitude/builder-skills

Synthesizes customer feedback into actionable themes including feature requests, bugs, pain points, and praise. Use when planning product roadmap, understanding user sentiment, investigating specific issues, or preparing voice-of-customer reports.

amplitude/builder-skills

Analyze MCP server usage instrumented with Amplitude's MCP Analytics SDK: break usage and errors down by tool, read the rationales within each tool to see what callers are trying to do, and produce a prioritized write-up of actionable fixes. Use this skill whenever the user asks to understand how their MCP server is being used, what agents/users are trying to do with it, why tool calls are failing, what to fix or improve in their MCP server, or asks for an "MCP usage report", "tool error analysis", "intent analysis", "rationale clustering", or "MCP insights". Also trigger when the user mentions [MCP]-prefixed events, tool rationale, tool call errors, or just finished instrumenting their MCP server and wants to see what the data says. Requires the Amplitude MCP connector.

amplitude/builder-skills

Read lost deals and churned accounts from your CRM, extract reasons clustered by theme (missing features, pricing, competitors, UX), and write a prioritized weekly analysis with product improvement recommendations. Use before roadmap planning or to build the case for prioritizing retention work.

amplitude/builder-skills

Guide an Amplitude user through building a custom agent by suggesting use cases grounded in their role and data, shaping the idea into a well-formed spec, and generating a ready-to-run Global Agent deeplink that creates it. Use to create, build, or set up a custom agent, automate a recurring analysis, or put a repeated report on a schedule.

amplitude/builder-skills

Builds comprehensive Amplitude dashboards from requirements or goals, organizing charts into logical sections with appropriate layouts. Use when creating a complete dashboard from scratch or assembling existing charts into a cohesive view.

amplitude/builder-skills

Monitors all active and recently completed experiments across Amplitude projects, triages them by importance, then runs deep analysis and reporting on the most impactful ones. Use when the user asks to "check on experiments", "experiment status", "experiment review", "what experiments are running", or wants a periodic experiment health report.

amplitude/builder-skills

Pull Intercom tickets and Slack support messages from the past 7 days, classify each signal, enrich with CRM data (ARR, plan, renewal), score by customer value and churn risk, and output a tiered priority report saved to Drive. Use when you need a fast, data-driven view of what support signals matter most.

amplitude/builder-skills

Use this skill whenever a user wants to improve existing pages on their website to get cited more by AI models — whether they say "our pages aren't getting cited", "improve this page for AI visibility", "which of our pages should we update", "make this article more cite-worthy", "our competitors are getting cited instead of us", "update our content for AI search", or any variation where the goal is improving an existing asset rather than creating something new. This skill pulls owned pages from AI Visibility, identifies which ones have citation potential but are underperforming, compares them against the external pages that are winning citations on the same topics, and produces section-level rewrites or a full-page update — then pushes the revision to the CMS as a draft. Trigger even if the user just says "help me get cited more" or "why is [competitor] getting cited instead of us".

amplitude/builder-skills

Use this skill whenever a user wants to win AI citations on prompts that competitors currently dominate — whether they say "competitors are getting cited instead of us", "we're losing on these prompts", "how do I outrank [competitor] in AI answers", "find prompts where we should be winning", "create content to beat [competitor]", or any variation where the goal is capturing AI share on prompts a competitor currently owns. This skill pulls competitor visibility data from AI Visibility, identifies the specific prompts where competitors win and Amplitude is absent, clusters them by intent, and produces targeted comparison pages, alternatives content, or rebuttal assets — then pushes drafts to CMS. Trigger on any mention of competitor, prompt hijack, outrank, or "why is [competitor] getting cited instead of us".

amplitude/builder-skills

Use this skill whenever a user wants to turn AI Visibility data into published content — whether they say "find content gaps", "what should we write about", "which topics have low visibility", "help me get cited by AI models", "create a blog post from our AI Visibility gaps", "we're losing to competitors on these prompts", or any variation where they want to go from AI visibility weakness to a draft article, landing page, or FAQ. This skill connects directly to Amplitude AI Visibility data (topics, prompts, visibility scores, citations, competitor data, full LLM responses and sources) and produces a publish-ready content brief plus full article draft. If the user mentions CMS (WordPress, Webflow, Contentful, Sanity, HubSpot, Ghost, Shopify), also trigger this skill to push the draft directly. Trigger even if they just say something vague like "what content should we create?" in an AI Visibility context.

amplitude/builder-skills

Use this skill whenever a user wants to test content variants before publishing to find which one will get cited most by AI models — whether they say "which version of this content will perform better", "test this article before we publish", "simulate how AI will respond to this content", "which angle should we use", "generate content variants and pick the winner", "run a simulation before publishing", or any variation where the goal is data-driven content selection rather than gut-feel publishing. This skill takes an identified content opportunity, generates 2–3 distinct variants with different angles or structures, scores them against actual AI model responses from AI Visibility, references the Simulate Changes feature for pre-publish validation, and produces a clear recommendation on which variant to publish — then pushes the winner to CMS. Trigger on any mention of "simulate", "test variants", "which performs better", "A/B content", or "before we publish".

amplitude/builder-skills

Use this skill whenever a user wants to understand which external sources are being cited by AI models on topics relevant to their brand, and wants to create content that will outrank those sources — whether they say "what sources are AI models citing", "why is [third-party site] being cited instead of us", "we want to be the definitive source on X", "build something that gets cited more than G2 or TechRadar", "create an authoritative asset", or any variation where the goal is producing a new reference asset (definition page, benchmark, methodology, glossary, comparison hub) designed to beat existing top-cited sources. This skill analyzes AI Visibility source data, reverse-engineers what makes top-cited pages authoritative, and produces a superior source asset — then pushes it to CMS as a draft. Trigger on any mention of "sources", "third-party citations", "authoritative content", "definitional pages", or "outrank".

amplitude/builder-skills

Instrument a Node/TypeScript MCP server with Amplitude's @amplitude/mcp-analytics SDK so tool calls, sessions, and rationale are tracked as Amplitude events. Use this skill whenever the user wants to add Amplitude analytics to their MCP server, mentions "MCP Analytics", "@amplitude/mcp-analytics", "instrument my MCP server", "track MCP tool calls", "add rationale to my MCP tools", or wants agent traffic (Claude, Cursor, ChatGPT) attributed back to Amplitude. Also use for adding UTM tagging to MCP-returned links, or for troubleshooting identity/user_id mismatches between MCP events and web/mobile Amplitude data.

amplitude/builder-skills

Instruments a pull request with Amplitude analytics that conform to the project's existing taxonomy. Reads the tracking plan via the Amplitude MCP server (events, properties, naming conventions), analyzes the PR diff to find the few user actions genuinely worth tracking, detects the codebase's SDK and tracking patterns, and adds instrumentation that matches both. Optionally (opt-in) stages new events and properties on an Amplitude tracking-plan branch for data-governance review. Use when asked to "instrument this PR", "add analytics to this change", "add tracking", "add Amplitude events", "instrument this feature", or "what should I track here".

amplitude/builder-skills

Diagnoses product health by cross-referencing Amplitude analytics (dashboards, charts, funnels, feedback, AI agent analytics), optionally Datadog (errors, latency, stack traces), and optionally Slack (qualitative feedback, bug reports, feature requests). Identifies what's broken, what's working, and what to do about it — with root causes, not just symptoms. Use when asked to "diagnose my product", "what's going on", "product health check", "what's broken", "where are users struggling", "give me a product diagnosis", or "what should I focus on".

amplitude/builder-skills

Turn one or more meeting transcripts, notes, or Slack threads into concise takeaways and clear action items with DRIs. Works with a single meeting or a batch from the whole week.

amplitude/builder-skills

Summarizes B2B account health by analyzing usage patterns, engagement trends, risk signals, and expansion opportunities. Use for customer success reviews, renewal preparation, QBRs, or account prioritization.

Skills associés