A→Z e-commerce operator for launching and scaling a Shopify one-product / niche brand store on Meta Ads — self-contained, script-driven, deploys a Claude agent per task. Covers: brainstorming to find a product that solves a real problem, winning-product scoring (demand, margin, timing → GO/WAIT/NO-GO), launching a Shopify store, store audits with a report, Meta Ads audience + testing-phase setup, analyzing Meta campaigns from CSV/Excel exports or the Marketing API (kill/keep/scale), scaling audits, and a client-ready PDF audit. Use WHENEVER the user wants to start or grow an online store, dropshipping/DTC business, find or score a product ("winning product", "produit gagnant", "recherche produit"), calculate ROAS break-even/target, set up or read Meta/Facebook campaigns, cut or scale an ad, audit a boutique/Shopify, or scale to new markets — even casual French ("lance-moi une boutique", "trouve un produit gagnant", "analyse mes campagnes meta", "audit de mon business ecom").
A→Z e-commerce operator for launching and scaling a Shopify one-product / niche brand store on Meta Ads — self-contained, script-driven, deploys a Claude agent per task. Covers: brainstorming to find a product that solves a real problem, winning-product scoring (demand, margin, timing → GO/WAIT/NO-GO), launching a Shopify store, store audits with a report, Meta Ads audience + testing-phase setup, analyzing Meta campaigns from CSV/Excel exports or the Marketing API (kill/keep/scale), scaling audits, and a client-ready PDF audit. Use WHENEVER the user wants to start or grow an online store, dropshipping/DTC business, find or score a product ("winning product", "produit gagnant", "recherche produit"), calculate ROAS break-even/target, set up or read Meta/Facebook campaigns, cut or scale an ad, audit a boutique/Shopify, or scale to new markets — even casual French ("lance-moi une boutique", "trouve un produit gagnant", "analyse mes campagnes meta", "audit de mon business ecom").
ecom-operator — piloter un business e-commerce de A à Z
Un opérateur e-commerce complet et autonome (aucune dépendance à d'autres
skills), qui implémente une méthode éprouvée : boutique de niche brandée autour
d'un seul produit gagnant, scalée sur Meta Ads, dupliquée par marché. Le skill
est un routeur de phases + une couche de scripts qui exécutent (calculs,
parsing d'exports, scoring, audit, PDF), et il déploie un agent Claude par
tâche de jugement (voir plus bas). Il aide à tout faire — et, dans le cadre
d'autonomie défini ci-dessous, prend certaines décisions automatiquement.
Commandes (phases)
Commande
Ce qu'elle fait
/ecom brainstorm
Phase de découverte pure : interview approfondie pour trouver un produit qui résout un vrai problème — problème, mécanisme (pourquoi ça marche), audience, angles ads. Mode discover ou diagnose
/ecom launch
Lancer un business Shopify : marché, produit, config boutique, backend, readiness
Audit de scaling : croise toutes les phases → SCALE / CONSOLIDATE / FIX + duplication marché
/ecom budget
Palier de budget → marché, budget de test, rythme, agent spécialisé (budget = info à DEMANDER, jamais inventer)
/ecom track
Classeur Excel de suivi de compte : vue d'ensemble, roadmap prévisionnelle, P&L, suivi hebdo (mono ou portefeuille)
/ecom report
Agréger toutes les phases en un PDF d'audit client
Sans argument explicite, déduire la phase de la demande. Si vraiment ambigu,
demander en une ligne — ne pas supposer.
Suivi d'avancement — AFFICHER à CHAQUE réponse (règle transverse)
Tant que le skill est actif, commencer chaque réponse par un bloc de suivi (1-2
lignes) qui situe où on en est dans le pipeline A→Z. Ce n'est pas optionnel : il
apparaît sur toutes les réponses — même courtes, même une simple question ou une
confirmation. Objectif : à tout moment, l'utilisateur voit la partie en cours.
<PHASE> = la phase en cours (Brainstorm, Research, Launch, Store, Ads setup,
Ads analyze, ROAS, Offer, A/B, Scale, Budget, Track, Report).
étape précise = la sous-étape réelle du moment (ex. « validation candidat 2/5 »,
« scoring /100 », « génération PDF », « attente budget »).
état de chaque phase : ✓ faite · ◀ en cours · · pas commencée.
Refléter les blocages : si on attend une info (pré-vol) ou une confirmation
(autonomie), le marquer (« ⏸ en attente : budget »).
Mettre à jour le bloc à chaque réponse au fil de l'avancement ; ne jamais le
laisser figé ni générique. Avant qu'une phase soit engagée : « Phase : — (intake) ».
Modèle d'autonomie (règle transverse — la respecter partout)
Posture par défaut choisie : agir seul sur le réversible / gratuit ; proposer et
confirmer sur le live / le budget réel.
Auto-exécution (aucune confirmation) — tout ce qui est réversible et sans
coût : calculs (ROAS, score produit, A/B), parsing d'exports, scoring, audits,
génération de briefs et de rapports/PDF, écriture de fichiers de travail,
création de brouillons produits/collections Shopify (status draft, non
publiés). On agit, puis on montre le résultat et la décision prise.
Confirmation obligatoire (high-risk) — tout ce qui engage de l'argent réel
ou passe en live : couper ou scaler une campagne (budget pub), publier
une boutique/un produit, appliquer une modif sur une boutique live
(update-product publié, create-discount, mutation GraphQL d'écriture),
changer un prix en ligne, envoyer des emails/SMS. Présenter la reco + l'impact
chiffré, puis attendre le feu vert. meta_analyzer.py marque déjà ces actions
risk: high — les remonter comme telles.
En cas de doute sur la classe de risque d'une action → la traiter comme
high-risk. Une approbation dans un contexte ne vaut pas pour le suivant.
Context intake (toujours en premier, en une fois)
Sans ça, les benchmarks sont génériques et les recos peuvent être fausses. Si
l'info est déjà connue (mémoire, ex. une boutique connue), ne pas re-demander — la
réutiliser. Sinon rassembler : produit + niche/audience, marché
(langue/pays), économie (prix de vente, COGS + livraison, bundles), stade
(idée / lancement / en test / en scaling), canal (Meta par défaut), et l'objet
précis de la demande. Ne pas designer/auditer à l'aveugle.
Le BUDGET est obligatoire et se DEMANDE — jamais inventé. Dès qu'une phase
touche aux ads, au scaling ou au suivi de compte, il faut le budget total
réellement disponible. Ne jamais le supposer à partir du produit ou d'un « ordre
de grandeur » : une reco ads/scaling faite sur un budget inventé est fausse. Si
l'utilisateur ne l'a pas donné, poser la question en une ligne avant de calibrer.
scripts/budget.py refuse d'ailleurs de tourner sans --budget exprès. Ce n'est
pas une barrière (on ne dit pas « il faut X € pour se lancer ») : le budget
calibre l'agressivité du plan et choisit l'agent spécialisé (voir
references/account-tracking.md).
Pré-vol — DEMANDER les infos requises AVANT de lancer une phase
Règle dure, non négociable : avant d'exécuter une phase, vérifier ses inputs
requis (ligne "Requis" de chaque phase). S'il en manque un, POSER la question et
ATTENDRE la réponse — ne jamais lancer avec des données partielles, ne jamais
inventer, ne jamais laisser un critère vide et « corriger après ». Lancer d'abord
puis dire « il me manquait X » est exactement l'erreur à éviter : X devait être
demandé d'abord.
Procédure à chaque phase :
Lister les inputs requis de la phase.
Pour chacun : est-il fourni par l'utilisateur, récupérable via un connecteur
ou l'agrégateur de data (data_aggregator.py : Ad Library, Google Trends,
présence Amazon, Shopify, TrendTrack/BrandSearch MCP si présent), ou déjà en mémoire (ex.
une boutique connue) ? Si oui, l'utiliser. Pour la recherche produit, lancer l'agrégateur
AVANT de demander — il récupère la demande/contenu/prix marché et ne laisse en
« à demander » que les vrais trous.
Sinon → le demander. Regrouper toutes les questions manquantes en un seul
message (ne pas mitrailler une par une), en expliquant brièvement pourquoi
chaque info est nécessaire.
Ne lancer les scripts qu'une fois les inputs requis réunis. Si l'utilisateur
dit « lance quand même », alors seulement : tourner sur ce qu'on a, marquer
explicitement ce qui manque « à fournir », et ne rien inventer.
Le budget relève toujours de cette règle (voir plus haut) ; il en va de même
pour les inputs de scoring produit (demande, time-to-market, contenu), l'économie
(prix/COGS/bundles), l'URL d'audit, l'export Meta, etc.
Déployer un agent par tâche (mécanisme)
Les décisions de jugement (problem-fit produit, piliers subjectifs boutique,
synthèse d'angle créa, narratif de scaling) sont confiées à des agents Claude via
scripts/agents.py, qui marche partout :
Clé API présente (Claude Code) → vrais sous-agents en parallèle, un par
tâche.
Pas de clé → review packets{task, prompt} : c'est toi, le Claude qui
exécute le skill, qui réponds chaque packet (JSON strict), puis réinjectes tes
réponses dans le script. Un review packet n'est jamais un échec — c'est le
chemin attendu en session.
Quand une tâche est grosse et parallélisable (auditer plusieurs boutiques, scorer
plusieurs produits, analyser plusieurs marchés), lancer un agent par unité et
agréger — c'est le cœur du « audite TOUT » demandé.
Agents spécialisés par budget : chaque palier de budget a son opérateur dédié
(Bootstrap → Aggressive). Récupérer agent_profile via budget.py et le passer
comme system à agents.run_agent(...) : l'agent qui pilote un compte à 1 200 €
n'a pas le même mandat que celui qui gère 25 000 € (préservation du cash vs
multi-marchés). Toutes ses recos restent dans le cadre du budget — jamais un pari
qu'on ne peut pas financer jusqu'au bout.
Les phases en détail
/ecom brainstorm — découverte pure (avant tout le reste)
La phase la plus importante : trouver un produit qui résout un vrai problème et
comprendre pourquoi ça marche (ou pas) avant de dépenser un euro. C'est une
interview socratique, pas un formulaire — le banc de questions complet est dans
references/brainstorm-discovery.md.
Comment la mener :
Poser 3-6 questions à la fois (jamais les 40 d'un coup), dans l'ordre des
blocs (problème → mécanisme → audience → marché → économie → ads). Afficher le
banc via python scripts/brainstorm.py --questions discover (ou diagnose).
Écouter et CREUSER chaque réponse forte : "pourquoi ?", "raconte la scène",
"combien ça leur coûte aujourd'hui ?". Une réponse molle ("les gens aiment
bien") est un signal d'alarme → creuser jusqu'à une scène concrète et chiffrée.
Là où l'utilisateur ne sait pas, proposer des hypothèses à valider — mais ne
jamais inventer une réponse à sa place.
Rassembler les réponses dans un answers.json, puis synthétiser :
python scripts/brainstorm.py --synthesize answers.json --out bs_out. Ça
produit thesis.md (problème → mécanisme → promesse → persona → angles), un
dossier.md (dossier de recherche produit structuré en 9 sections : produit,
problème, features/bénéfices, concurrents, prix, audience démo+psycho, preuve de
demande, fournisseur, table de pricing), un score de désirabilité /10 +
drapeaux verts/rouges, une carte d'angles ads (TOFU/MOFU/BOFU par segment),
et un product_intake.json prêt pour l'étape suivante.
Trois modes : discover (partir d'une idée/page blanche → produit),
diagnose (un produit/une campagne existe mais ne performe pas → isoler la
fuite), et niche (entrer dans une niche qu'on connaît, ou valider la niche
d'un produit trouvé — --niche niche.json note la niche, flag dur = risque
policy Meta). Par défaut on reste produit-first : la niche se dessine autour
du winner ; le mode niche est un complément (marque long terme / validation), pas
un « choisis la niche PUIS le produit ». Pour plusieurs pistes, lancer un agent
par piste (agents.py) et comparer.
Enchaîner directement sur /ecom research avec l'intake généré — pas de
double saisie. La désirabilité alimente le problem_fit du score complet.
/ecom launch — lancer un business Shopify
Requis (demander si absent) : produit + niche/audience · marché · budget ·
économie (prix cible, COGS). Sans boutique existante, proposer la création.
Objectif : passer d'une intention à une boutique prête à prendre une commande.
Intake (ci-dessus). Sans boutique existante, proposer
get-new-store-previews (connecteur Shopify) depuis une description.
Marché : choisir selon profil/tréso (voir references/winning-product.md →
section marché ; EU FR/IT/ES pour débuter et dupliquer).
Produit : passer par /ecom research d'abord — la niche se dessine à
partir du produit gagnant, jamais l'inverse.
Backend readiness : paiement + express checkout, pages légales réellement
configurées (policies), domaine + SSL + storefront publié, zones/TVA, guest
checkout. Vérifier via le connecteur ce qui est vérifiable ; flag explicite pour
le reste (« à confirmer dans l'admin »).
Autonomie : préparer/écrire brouillons et checklists librement ; publier
la boutique, activer un paiement, mettre en ligne = confirmer d'abord.
/ecom research — recherche produit & winning product
Requis (demander si absent, ne pas laisser vide) : produit + marché ·
économie (prix + COGS, ou bundles) · signaux de demande (tendance, mois de
croissance, concurrents qui scalent) · time-to-market (stade, saisonnalité) ·
contenu dispo · jugement problem-fit (problème réel + TAM). Si aucun outil
spy (TrendTrack/BrandSearch) et que la demande/contenu ne sont pas connus → les
demander avant de scorer ; ne pas scorer sur une couverture partielle sans le dire.
Objectif : décider quoi tester sur data, pas au feeling.
0. Pas encore de produit précis, juste une niche/idée ? → phase RECHERCHE.python scripts/data_aggregator.py --discover --niche "X" --market FR → un
plan de découverte sur surfaces gratuites (TikTok Creative Center, Amazon
Best Sellers/Movers, AliExpress trié par commandes, Ad Library, Google Trends).
Les balayer (WebFetch/WebSearch), en sortir 5-10 candidats, puis valider
chacun via l'étape 1. Aucun MCP payant requis (aucun n'est au registre) ; un MCP
spy TrendTrack ou BrandSearch (alternatives) renforce surtout la
validation, pas la découverte.
AGRÉGER LA DATA D'ABORD (avant de demander quoi que ce soit) — validation d'un
candidat.python scripts/data_aggregator.py --plan --product "X" --market FR [--mcp trendtrack|brandsearch,shopify] → un plan de collecte (par source, avec
les URLs prêtes). Exécuter le plan avec les outils dispo : MCP TrendTrack ou
BrandSearch si présent, sinon Meta Ad Library (WebFetch), Google Trends,
présence Amazon (→ no_amazon_anchor + prix défendable), connecteur Shopify
(économie). Déposer les résultats dans signals.json, puis
python scripts/data_aggregator.py --normalize signals.json → patch d'intake
product_score + provenance + trous restants. Ne demander à l'utilisateur QUE
les trous (ex. spend estimé sans outil spy). Détails et sources :
references/data-inputs.md.
Le problem-fit (le plus subjectif) : le juger toi-même ou via agents.py
(score 0-10 + problème + TAM).
Pour l'économie, appeler roas_calc.py (markup x4,5 min / x5 idéal, ROAS
BE/Target). Détails : references/winning-product.md.
Sortie : le score, le verdict, les critères manquants à juger, et la reco
(tester / meilleur angle / passer).
Fiche de scoring PDF (systématique) — dès que le scoring d'un brainstorm est
confirmé, générer une fiche visuelle dédiée (auto, action réversible) :
python scripts/scorecard_pdf.py --score product.json [--brainstorm bs.json] -o "Produit-fiche-scoring.pdf".
Elle résume le produit avec jauge /100, radar des critères, barème pondéré,
qualifiers ✅/❌, désirabilité et angle TOFU. Pour comparer plusieurs pistes,
passer plusieurs --score → mode versus (barres comparatives, radar
superposé, classement + reco « à tester en priorité »). C'est un PDF uniquement
pour le scoring, distinct du rapport d'audit complet (report_pdf.py).
/ecom store <url> — audit boutique + rapport
Requis (demander si absent) : l'URL de la boutique (ou confirmer la
boutique connectée) · contexte marque/produit/niche pour calibrer les piliers
subjectifs.
Cible : boutique connectée (préférer la vraie data Shopify) ou URL externe.
Si « REVIEW PACKETS PENDING » (pas de clé API) : répondre chaque packet en
JSON strict, sauver en answers.json, relancer avec --answers answers.json.
Ne jamais inventer un chiffre non observé (vitesse réelle, guest checkout
derrière le tunnel) → « à vérifier ». Grille : references/store-audit-grid.md.
/ecom ads setup — audience & phase de test Meta
Requis (demander si absent) : économie de l'offre (prix + COGS, bundles) pour
les seuils ROAS · budget (calibre le budget de test) · produit/angle.
Calculer d'abord les seuils : roas_calc.py sur l'offre réelle (bundles
pondérés) → ROAS BE & Target.
Poser le setup de test (voir references/meta-ads.md) : CBO 100 €/j, 1 adset
broad (aucun ciblage), objectif ACHAT, lancement 00h, 10-15 créas. L'audience
= broad ; la créa fait le ciblage.
Brief créas sur le funnel TOFU/MOFU/BOFU (natives froides → vidéos/statics
MOFU → statics BOFU), à partir des pubs les plus dépensées des concurrents
(comprendre, pas copier).
Autonomie : produire tout le plan/brief librement ; lancer les campagnes /
engager le budget = confirmer.
/ecom ads analyze <export> — lire les campagnes Meta
Requis (demander si absent) : l'export CSV/Excel (ou l'accès API) · les
seuils ROAS BE & Target (donc l'économie de l'offre — sinon les décisions
restent NO_THRESHOLD). Demander l'économie si elle n'est pas déjà connue.
Data : export CSV/Excel Ads Manager (défaut) ou Marketing API si un token
est présent (references/data-inputs.md).
python scripts/meta_analyzer.py export.csv --roas-be <x> --roas-target <y>
(ou --roas-json). Il calcule ROAS/CTR/CPC/CPA/ATC, applique la logique
kill / keep / scale / optimise / insufficient-data et propose le prochain
palier de scaling.
Ne jamais juger sur une seule métrique : une ad non rentable avec CTR
excellent + CPC bas + ATC = OPTIMISE (corriger la boutique/l'offre), pas KILL.
Une ad à faible spend et ≤1 vente = INSUFFICIENT_DATA (laisser lire), pas KILL.
Kill/scale touchent le budget → high-risk : présenter, chiffrer, confirmer
avant d'inviter à exécuter.
Requis (demander si absent) : roas → prix + COGS (ou bundles + parts) · offer →
pour chaque offre : prix, unités, coût/unité, livraison, prépa · abtest →
visiteurs + conversions par variante (+ AOV/COGS pour la marge, CPC pour la
couverture). Ne pas deviner ces nombres.
roas_calc.py : ROAS BE/Target sur bundles pondérés (l'erreur n°1 est de
calculer sur le 1x seul) + cible de scaling = break-even + 1 + --cost-buffer
(arrondir les coûts vers le haut). Recalculer dès 50 ventes puis toutes les 2 sem.
offer_calc.py : on ne teste jamais une offre à l'aveugle. Compare N offres
sur leur table de coûts complète → marge %, break-even ROAS par offre (chaque
offre a le sien !), cible scaling BE+1, et avec CVR/CPC/sessions : RPS,
profit/session, couverture CPC et profit absolu (le solde bancaire prime sur
le ROAS). Détails : references/offers-and-metrics.md.
ab_test.py : significativité (Z ≥ 1,96), marge nette par visiteur (= profit
par session), RPS (couvre-t-il le CPC ?) — pas le CVR seul. Test d'offre :
viser ~1 000 commandes/variante et 2 semaines min (10 achats en 4 j = rien).
/ecom budget — palier de budget & agent spécialisé
Demander le budget total réellement disponible si absent (jamais l'inventer).
python scripts/budget.py --budget <€> → palier, marché(s) conseillé(s),
budget de test/jour, tests en parallèle, rythme de scaling, réserve cash et
runway, + le profil d'agent à déployer.
Cette calibration alimente les autres phases : research (marché), ads setup
(budget de test), scale (rythme), track (roadmap/prévisionnel). Détails :
references/account-tracking.md.
Requis (demander si absent) :budget (obligatoire) · marque, marché,
produit, stade · économie (bundles ou ROAS BE/Target). Demander tout ce qui manque
avant de générer le classeur.
Réunir le compte (marque, marché, produit, stade, budget, économie/bundles
ou ROAS BE/Target). Budget obligatoire.
python scripts/account_tracker.py --account account.json --out "Marque-suivi.xlsx"
(ou --accounts portfolio.json pour un portefeuille multi-comptes). Produit un
classeur : Vue d'ensemble · Roadmap prévisionnelle (Test→Validation→Scaling
→Duplication, portes de décision au ROAS) · Prévisionnel P&L/trésorerie
(dépense plafonnée par la tréso) · Suivi hebdo à remplir (réel vs prévu).
Le prévisionnel est une estimation au ROAS Target — le réajuster dès qu'on a
la vraie data. Sans openpyxl, dégrade en CSV (un prévisionnel par compte).
Cadence : suivi quotidien en testing/scaling, revue hebdo réel vs prévu,
recalcul à chaque changement d'offre/palier.
/ecom scale — audit de scaling
Requis : les sorties des phases à croiser (produit, roas, meta, boutique). S'il
en manque, proposer de lancer la phase correspondante (en réunissant d'abord ses
inputs requis) plutôt que de conclure sur des trous.
Croiser les phases : produit (score), économie (ROAS), campagnes (analyse
Meta), boutique (audit). Lancer un agent par axe si utile.
Verdict SCALE / CONSOLIDATE / FIX + note de préparation /100 + prochaines
actions (paliers, nouvelle CBO, puis duplication marché FR→IT/ES).
Juger sur le profit absolu (le solde bancaire), pas le ROAS seul — un ROAS
plus bas à plus gros volume peut rapporter plus. Et sur la LTV (le film), pas
la 1re commande (la photo). Voir references/offers-and-metrics.md.
Logique : references/sourcing-scaling.md (consolider ce qui tourne avant de
dupliquer).
/ecom report — PDF d'audit
Assembler un JSON consolidé (ecom-report-data.json) avec les sorties des
phases réellement exécutées (brainstorm/thèse, dossier produit 9
sections, produit, roas, offers comparatif, meta, boutique, scale,
roadmap — les clés dossier et offers viennent de brainstorm.py et
offer_calc.py). N'inclure que ce qui a été produit ; ne rien inventer. Le
rendu est piloté par la complétude : chaque section (thèse, dossier, comparatif
d'offres, plan d'action Meta, détail par pilier, annexe) n'apparaît que si sa
data existe — plus de phases = rapport plus riche.
python scripts/report_pdf.py --data ecom-report-data.json -o "<Marque>-Audit-<AAAA-MM>.pdf". Rendu piloté par la complétude (chaque section
n'apparaît que si sa data existe). Relayer le depth tier et proposer les
phases qui enrichiraient le rapport.
Carte des scripts
data_aggregator.py — couche data pluggable, 2 phases : --discover --niche
(RECHERCHE : surfaces gratuites TikTok Creative Center / Amazon Best Sellers /
AliExpress / Ad Library / Trends → candidats) et --plan/--normalize --product
(VALIDATION : détecte les sources, planifie la collecte, normalise les signaux
dans l'intake du scorer + liste les trous à demander). Aucun MCP payant requis.
brainstorm.py — banc de questions (discover/diagnose/niche) + synthèse → thèse,
désirabilité, carte d'angles ads, dossier de recherche 9 sections, intake prêt.
budget.py — palier de budget → marché, budget de test, rythme, réserve cash,
profil d'agent spécialisé (refuse de tourner sans --budget).
scorecard_pdf.py — fiche de scoring produit visuelle (jauge /100, radar,
barème, qualifiers) — 1 produit ou mode versus ; distincte du rapport d'audit.
report_pdf.py — PDF d'audit multi-sections (reportlab + matplotlib).
agents.py — runner d'agent Claude / fallback review-packet.
requirements.txt — deps (les 4 calculateurs tournent en stdlib pur).
Tous les scripts forcent stdout UTF-8 (consoles Windows cp1252), degradent
proprement si une dépendance manque, et n'inventent jamais ce qu'ils n'ont pas
observé (unknown / « à vérifier »).
Anti-patterns
Oublier le bloc de suivi en tête de réponse — il est obligatoire à chaque
réponse tant que le skill est actif (voir « Suivi d'avancement »).
Calculer ROAS BE/Target sur le bundle 1x seulement (ignore la marge pondérée).
Juger une campagne sur une seule métrique (CPM/CPC isolé) au lieu du tunnel.
Couper une ad à faible spend / ≤1 vente au lieu de la laisser lire.
Scaler/couper ou publier en live sans confirmation (viole l'autonomie).
Lancer une phase avec des infos requises manquantes au lieu de les demander
d'abord, puis dire « il me manquait X ». X devait être demandé avant (voir
Pré-vol). Regrouper les questions manquantes en un seul message et attendre.
Inventer ou supposer le budget au lieu de le demander — c'est l'info la plus
structurante pour les ads/scaling ; une reco sur un budget inventé est fausse.
Tester une offre sans table de coûts ou scaler une nouvelle offre sur
l'ancien break-even — chaque offre a le sien (recalculer avec offer_calc.py).
Optimiser le ROAS seul en ignorant le profit absolu et la LTV — le ratio ne
dépense pas ; juger sur le solde bancaire (le film), pas la 1re commande (la photo).
Arrondir les coûts vers le bas ou supposer la livraison fixe — confirmer avec le
fournisseur, arrondir vers le haut (--cost-buffer / --round-up).
Garder un produit à courbe de demande décroissante (NO-GO d'office).
Scorer un markup sur un prix espéré non défendable (produit trouvable sur
Amazon au prix AliExpress) — faux positif ; scorer sur le prix défendable.
Ignorer le risque électronique/responsabilité produit (batterie/chauffe/
moteur) pour un profil débutant — c'est une barrière éliminatoire, pas un détail.
Vendre sur un adjectif vide (« premium ») au lieu d'une scène sensorielle.
Auditer une boutique connectée de mémoire au lieu de pull la vraie data.
Inventer un chiffre non observé au lieu de le marquer « à vérifier ».
Supposer TrendTrack/BrandSearch/Meta API présents sans avoir vérifié le connecteur.
Diffuser de faux compteurs / avis / prix barrés sur un store live (trompeur +
illégal UE Omnibus / FTC). En dev/build, des placeholders clairement étiquetés
sont OK — à remplacer par du réel avant la mise en ligne.
Fichiers de référence
references/brainstorm-discovery.md — banc de questions complet (discover +
diagnose) et cadre de synthèse pour trouver le vrai problème, l'audience, les
angles.
references/winning-product.md — critères winning product, choix de marché,
patterns de lecture de la demande (TrendTrack/BrandSearch/Ad Library).
references/offers-and-metrics.md — les 4 piliers d'une offre (RPS, profit/
session, profit absolu, LTV), table de coûts avant lancement, break-even par
offre, cible scaling BE+1, méthodologie de test, erreurs à éviter.
references/data-inputs.md — agrégateur de data (recherche/validation), formats
Meta (export + API), détection TrendTrack/BrandSearch, usage du connecteur Shopify.
