Créer un thème enfant WordPress étape par étape

Si vous avez déjà perdu des modifications après une mise à jour de thème, vous avez déjà rencontré la raison n°1 de créer un thème enfant.

Le problème / Le besoin

Vous personnalisez votre site (CSS, fonctions, templates) et tout fonctionne… jusqu’au jour où vous mettez à jour le thème. WordPress remplace alors les fichiers du thème parent par la nouvelle version, et vos changements disparaissent. J’ai souvent vu ça sur des sites Avada ou Divi où quelqu’un a “juste modifié un petit fichier” dans le thème, puis a tout perdu au premier update.

Un thème enfant (child theme) est un thème WordPress qui hérite du thème parent, et qui surcharge uniquement ce que vous ajoutez/modifiez. Le thème parent reste intact et peut être mis à jour sans écraser vos personnalisations.

À la fin, vous saurez :

Créer un thème enfant propre et compatible WordPress 6.9.4 (avril 2026) et PHP 8.1+
Charger correctement les styles (sans “@import”, sans doublons, sans casse de cache)
Ajouter des fonctions en sécurité (hooks, permissions, échappement)
Surcharger un template sans casser les mises à jour

Où coller le code ? Tout le code de cet article va dans votre thème enfant, principalement dans wp-content/themes/votre-theme-enfant/functions.php et dans style.css. Ne modifiez jamais les fichiers de wp-includes ou wp-admin (le “core”).

Pour les fonctions WordPress que vous allez croiser :

Hook : point d’accroche dans l’exécution de WordPress. Il y a des actions (on exécute du code) et des filtres (on modifie une valeur). Référence : Hooks (actions & filters).
add_action() : attache votre fonction à une action. Doc : add_action().
wp_enqueue_scripts : action utilisée pour charger CSS/JS côté front. Doc : wp_enqueue_scripts.
wp_enqueue_style() : enregistre/charge une feuille de style. Doc : wp_enqueue_style().

Résumé rapide

Vous créez un dossier de thème enfant dans wp-content/themes/.
Vous ajoutez style.css avec l’en-tête obligatoire (Template = slug du parent).
Vous ajoutez functions.php pour charger les styles du parent + du child via wp_enqueue_style().
Vous activez le thème enfant dans l’admin WordPress.
Vous testez un override simple : un CSS, puis un template (ex : single.php).
Vous gardez le parent à jour, et vos personnalisations restent en place.

Quand utiliser cette solution

Vous voulez ajouter du CSS “propre” sans dépendre uniquement de l’outil “CSS additionnel”.
Vous devez ajouter quelques fonctions PHP (ex : retirer un élément, ajouter une zone widget, modifier un hook).
Vous voulez surcharger un template (ex : single.php, page.php, header.php) ou ajouter un template-part.
Vous travaillez avec un thème “premium” mis à jour régulièrement (Divi, Avada, Astra, GeneratePress, etc.).
Vous intervenez pour un client : vous voulez une séparation claire entre “vendor” (parent) et “custom” (child).

Quand ne PAS utiliser cette solution

Vous voulez ajouter une fonctionnalité “métier” (CPT, formulaires, shortcodes, API) qui doit survivre à un changement de thème : faites un plugin (ou un mu-plugin). Un thème enfant est lié au thème parent.
Vous ne faites que 2 lignes de CSS : l’outil “CSS additionnel” (Apparence > Personnaliser) peut suffire. Mais attention : selon les thèmes et caches, ce CSS peut être regroupé/minifié différemment.
Vous utilisez un builder et vous ne touchez jamais aux templates : vous pouvez parfois rester sur un thème enfant minimal, voire aucun. Exemple fréquent : Elementor + Hello Elementor. Dans ce cas, votre “custom” est souvent mieux dans un plugin de snippets.
Vous êtes en Full Site Editing (thèmes blocs) et votre personnalisation est surtout du style/variations : regardez d’abord theme.json (mais un thème enfant reste utile si vous devez ajouter PHP).

Prérequis / avant de commencer

Versions cibles :

WordPress : 6.9.4 (ou supérieur)
PHP : 8.1+ (recommandé)

À faire avant toute modification :

Sauvegarde fichiers + base de données (ou snapshot si vous êtes sur un hébergeur managé).
Travaillez si possible sur un staging (site de préproduction). Sur des sites avec cache agressif, c’est la différence entre “5 minutes” et “2 heures de panique”.
Accès recommandé : FTP/SFTP ou gestionnaire de fichiers, et accès admin WordPress.

Outils utiles :

Un éditeur de code qui colore la syntaxe (VS Code, PhpStorm).
Un plugin de gestion de fichiers (optionnel), mais je préfère SFTP.
Pour déboguer : activez WP_DEBUG sur staging. Doc : Debugging in WordPress.

Précaution sécurité : un functions.php avec une erreur de syntaxe (un ; manquant) peut faire un fatal error et rendre le site inaccessible. Ayez toujours un accès SFTP pour corriger rapidement.

L’approche naïve (et pourquoi l’éviter)

Le réflexe débutant : modifier directement le thème parent, ou charger le CSS parent avec @import dans le style du thème enfant.

Naïf n°1 : modifier le thème parent

Vous ouvrez wp-content/themes/nom-du-theme/functions.php, vous ajoutez du code… et tout marche. Jusqu’à la mise à jour.

Problème : la mise à jour écrase vos fichiers.
Autre problème : si vous faites une erreur, vous cassez le thème pour tout le monde.

Naïf n°2 : utiliser @import dans style.css

On voit encore des tutos qui proposent :

/*
Theme Name: Mon thème enfant
Template: theme-parent
*/

@import url("../theme-parent/style.css");

Pourquoi c’est un mauvais plan en 2026 :

@import ralentit le chargement (chaîne de requêtes CSS) et complique l’optimisation.
Vous perdez le contrôle sur les dépendances/versioning que WordPress gère via wp_enqueue_style().
Certains thèmes chargent plusieurs CSS (RTL, responsive, modules) : @import ne règle pas le vrai problème.

Référence officielle : WordPress recommande l’enqueue des styles via functions.php. Voir : Child Themes (Theme Handbook).

La bonne approche — tutoriel pas à pas

Objectif : créer un thème enfant minimal, propre, activable, qui charge correctement les styles et vous laisse ajouter vos customisations.

Étape 1 — Identifier le “slug” du thème parent

Le slug est le nom du dossier du thème parent dans wp-content/themes/ (ex : astra, Divi, Avada). Vous en avez besoin pour le champ Template: du thème enfant.

Vérification rapide :

Via FTP/SFTP : regardez le dossier dans wp-content/themes/.
Ou dans WP Admin > Apparence > Thèmes > Détails du thème (selon le thème, le slug n’est pas affiché clairement, donc le dossier reste la source la plus fiable).

Étape 2 — Créer le dossier du thème enfant

Créez un dossier dans wp-content/themes/, par exemple :

wp-content/themes/mon-theme-enfant/

Évitez les espaces et accents dans le nom du dossier.

Étape 3 — Créer style.css (en-tête obligatoire)

Créez wp-content/themes/mon-theme-enfant/style.css.

L’en-tête est obligatoire : c’est ce qui permet à WordPress de reconnaître le thème. Doc : Main Stylesheet (style.css).

Collez ceci (adaptez les valeurs) :

/*
Theme Name: Mon Thème Enfant
Theme URI: https://example.com/
Description: Thème enfant pour personnaliser mon site sans modifier le thème parent.
Author: Votre Nom
Author URI: https://example.com/
Template: mon-theme-parent
Version: 1.0.0
Text Domain: mon-theme-enfant
*/

Point critique : Template: doit correspondre exactement au dossier du thème parent. Si vous mettez le “nom marketing” (ex : “Avada”), ça ne marchera pas.

Étape 4 — Créer functions.php et charger les styles correctement

Créez wp-content/themes/mon-theme-enfant/functions.php.

Ce fichier est chargé automatiquement par WordPress quand le thème enfant est actif. Vous allez vous accrocher à l’action wp_enqueue_scripts pour charger les CSS dans le bon ordre.

Collez ce code dans le functions.php du thème enfant :

<?php
/**
 * Functions du thème enfant.
 *
 * Compatible WordPress 6.9.4+ et PHP 8.1+
 */

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Empêche l'accès direct au fichier.
}

/**
 * Charge les styles du thème parent + du thème enfant.
 *
 * Hook (action) : wp_enqueue_scripts
 * Doc : https://developer.wordpress.org/reference/hooks/wp_enqueue_scripts/
 */
function mon_theme_enfant_enqueue_styles(): void {
	$parent_style_handle = 'parent-style';

	/**
	 * 1) Charge le style du parent.
	 * get_template_directory_uri() pointe vers le thème parent.
	 */
	wp_enqueue_style(
		$parent_style_handle,
		get_template_directory_uri() . '/style.css',
		array(),
		wp_get_theme( get_template() )->get( 'Version' )
	);

	/**
	 * 2) Charge le style du child, dépendant du parent.
	 * get_stylesheet_directory_uri() pointe vers le thème actif (enfant).
	 */
	wp_enqueue_style(
		'child-style',
		get_stylesheet_directory_uri() . '/style.css',
		array( $parent_style_handle ),
		wp_get_theme() ->get( 'Version' )
	);
}
add_action( 'wp_enqueue_scripts', 'mon_theme_enfant_enqueue_styles' );

Ce que fait ce code :

Il charge style.css du parent puis celui du child.
Il utilise la version du thème comme “cache-buster” (paramètre ?ver=), ce qui évite de se battre avec le cache après une mise à jour.

Docs associées :

Étape 5 — (Optionnel mais recommandé) Ajouter une capture d’écran

Ajoutez screenshot.png dans le dossier du thème enfant (idéalement 1200×900). Ce n’est pas obligatoire, mais c’est plus propre dans l’admin.

Étape 6 — Activer le thème enfant

Allez dans WP Admin > Apparence > Thèmes, puis activez “Mon Thème Enfant”.

Si WordPress affiche “Le thème parent est manquant”, c’est presque toujours :

le mauvais slug dans Template:,
ou le thème parent non installé.

Étape 7 — Tester avec un CSS visible

Ajoutez par exemple dans le style.css du thème enfant :

/* Test visuel : bordure sur le header */
header, .site-header {
	outline: 3px solid #d63638;
}

Rafraîchissez, videz le cache si nécessaire, et vérifiez que le style s’applique.

Étape 8 — Surcharger un template (exemple simple)

Un thème enfant peut surcharger un fichier template du parent. Exemple : si vous copiez single.php du parent vers le child, WordPress utilisera celui du child.

Procédure :

Dans le thème parent, repérez single.php (ou header.php).
Copiez-le dans le thème enfant, au même chemin.
Faites une modification minimale (un commentaire HTML) pour confirmer que c’est bien le fichier child qui est chargé.

Attention : surcharger un template vous “fige” sur cette version. Si le parent corrige un bug de sécurité dans ce fichier, vous ne le récupérez pas automatiquement. Je reviens sur ce point dans “Maintenance”.

Code complet

Ci-dessous : une version “prête à vivre” du thème enfant minimal. Vous copiez/collez, vous adaptez les noms, et vous activez.

Arborescence finale

wp-content/themes/mon-theme-enfant/
├─ style.css
├─ functions.php
└─ screenshot.png (optionnel)

style.css

/*
Theme Name: Mon Thème Enfant
Theme URI: https://example.com/
Description: Thème enfant pour personnaliser mon site sans modifier le thème parent.
Author: Votre Nom
Author URI: https://example.com/
Template: mon-theme-parent
Version: 1.0.0
Text Domain: mon-theme-enfant
*/

/* Vos personnalisations CSS à partir d'ici */
:root {
	--mte-accent: #2271b1;
}

a {
	text-decoration-thickness: 2px;
	text-underline-offset: 0.15em;
}

a:hover,
a:focus {
	color: var(--mte-accent);
}

functions.php

<?php
/**
 * Functions du thème enfant.
 *
 * Compatible WordPress 6.9.4+ et PHP 8.1+
 */

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Empêche l'accès direct au fichier.
}

/**
 * Charge les styles du thème parent + du thème enfant.
 */
function mon_theme_enfant_enqueue_styles(): void {
	$parent_style_handle = 'parent-style';

	// Charge le style principal du parent.
	wp_enqueue_style(
		$parent_style_handle,
		get_template_directory_uri() . '/style.css',
		array(),
		wp_get_theme( get_template() )->get( 'Version' )
	);

	// Charge le style du thème enfant (dépend du parent).
	wp_enqueue_style(
		'child-style',
		get_stylesheet_directory_uri() . '/style.css',
		array( $parent_style_handle ),
		wp_get_theme() ->get( 'Version' )
	);
}
add_action( 'wp_enqueue_scripts', 'mon_theme_enfant_enqueue_styles', 20 );

/**
 * Exemple concret : ajoute une classe CSS au <body>.
 *
 * Un filtre (filter) modifie une valeur et doit la retourner.
 * Doc : https://developer.wordpress.org/reference/hooks/body_class/
 */
function mon_theme_enfant_body_class( array $classes ): array {
	$classes[] = 'theme-enfant-actif';
	return $classes;
}
add_filter( 'body_class', 'mon_theme_enfant_body_class' );

Explication du code

Ce que WordPress fait en coulisses (version simple)

Quand vous activez un thème enfant :

WordPress charge d’abord les fichiers du thème parent (templates, fonctions).
Ensuite, il charge le thème enfant, qui peut :
ajouter du CSS/JS,
ajouter des fonctions,
surcharger des templates (si un fichier existe dans le child, il prend le dessus).

Actions vs filtres (la différence qui évite des bugs)

Une action sert à faire quelque chose à un moment donné. Exemple : charger des fichiers CSS/JS. Avec add_action(), vous “branchez” votre fonction sur un moment précis.

Un filtre sert à modifier une valeur. Exemple : ajouter une classe à body_class. Avec add_filter(), votre fonction reçoit une valeur, la modifie, puis doit la retourner. J’ai vu des débutants utiliser add_action() sur un filtre : ça ne plante pas toujours, mais ça donne des comportements incohérents.

Pourquoi wp_enqueue_style() est la bonne méthode

wp_enqueue_style() permet à WordPress :

d’éviter les doublons,
de gérer les dépendances (le child dépend du parent),
d’ajouter des versions (?ver=) pour le cache,
de laisser les plugins de perf/minification travailler proprement.

Doc : wp_enqueue_style().

Pourquoi on utilise get_template_* et get_stylesheet_*

get_template_directory_uri() pointe vers le dossier du parent.
get_stylesheet_directory_uri() pointe vers le dossier du thème actif (donc le child si un child est actif).

La confusion entre les deux est un classique : si vous utilisez get_template_directory_uri() pour charger le CSS du child, vous chargez… le parent, et vous vous demandez pourquoi vos modifications n’apparaissent pas.

Pourquoi la priorité 20 sur wp_enqueue_scripts

Beaucoup de thèmes chargent leurs styles à priorité 10 (valeur par défaut). Mettre 20 vous place “après”, ce qui réduit les cas où votre child est chargé trop tôt. Ce n’est pas magique, mais en pratique ça évite des surprises sur des thèmes complexes.

Variantes et cas d’usage

Variante 1 — Ajouter un fichier CSS séparé (plus propre que tout dans style.css)

Si votre CSS devient gros, gardez style.css surtout pour l’en-tête, et créez assets/css/custom.css.

Arborescence :

mon-theme-enfant/
├─ style.css
├─ functions.php
└─ assets/css/custom.css

Ajoutez dans functions.php du thème enfant :

function mon_theme_enfant_enqueue_styles(): void {
	$parent_style_handle = 'parent-style';

	wp_enqueue_style(
		$parent_style_handle,
		get_template_directory_uri() . '/style.css',
		array(),
		wp_get_theme( get_template() )->get( 'Version' )
	);

	// Style "racine" du child (en-tête + éventuellement quelques variables).
	wp_enqueue_style(
		'child-style',
		get_stylesheet_directory_uri() . '/style.css',
		array( $parent_style_handle ),
		wp_get_theme() ->get( 'Version' )
	);

	// CSS custom séparé (chargé en dernier).
	wp_enqueue_style(
		'child-custom',
		get_stylesheet_directory_uri() . '/assets/css/custom.css',
		array( 'child-style' ),
		wp_get_theme() ->get( 'Version' )
	);
}

Variante 2 — Ajouter du JavaScript proprement

Créez assets/js/custom.js, puis enqueue :

function mon_theme_enfant_enqueue_scripts(): void {
	wp_enqueue_script(
		'child-custom-js',
		get_stylesheet_directory_uri() . '/assets/js/custom.js',
		array(), // Dépendances (ex: array('jquery')) si nécessaire
		wp_get_theme() ->get( 'Version' ),
		true // true = en footer
	);
}
add_action( 'wp_enqueue_scripts', 'mon_theme_enfant_enqueue_scripts', 20 );

Évitez de “coller du JS” directement dans un template. Sur des sites avec cache/minification, c’est souvent la source de bugs intermittents.

Variante 3 — Ajouter une fonctionnalité qui a besoin d’un formulaire (nonce + permissions)

Un thème enfant peut contenir du code “fonctionnel”, mais dès que vous manipulez des données (soumission formulaire), vous devez gérer :

permissions (capabilities),
nonce (jeton anti-CSRF),
sanitization (nettoyage des entrées),
escaping (échappement des sorties).

Doc sécurité : Plugin Security (les principes s’appliquent aussi aux thèmes).

Si vous avez ce besoin, je conseille souvent de basculer la fonctionnalité dans un plugin, même si le thème enfant “peut le faire”. C’est plus durable.

Compatibilité Divi 5 / Elementor / Avada

Divi 5

Divi (y compris Divi 5) est typiquement utilisé avec un thème enfant, surtout si vous ajoutez du CSS global ou des fonctions. Deux points que je rencontre souvent :

Divi charge beaucoup de CSS/JS : si votre CSS ne “prend pas”, vérifiez l’ordre de chargement et la spécificité CSS.
Si vous mettez du CSS dans Divi (options du thème / customizer) et aussi dans le child, vous pouvez créer des conflits difficiles à relire.

Approche recommandée : variables + règles globales dans le child, ajustements “par page” dans Divi.

Elementor

Avec Elementor, le thème enfant sert surtout à :

ajouter CSS global,
ajouter des zones (hooks) si le thème parent en expose,
ajouter des templates PHP si vous utilisez encore une partie “thème” classique.

Piège courant : “mon CSS ne marche pas” alors qu’Elementor injecte des styles inline très spécifiques. Dans ce cas, utilisez des sélecteurs plus précis ou chargez votre CSS après (ce que fait déjà la priorité 20).

Avada (Fusion Builder)

Avada est l’un des thèmes où le thème enfant est quasi obligatoire dès que vous touchez au code. J’ai souvent vu :

des overrides de templates qui deviennent obsolètes après une grosse mise à jour Avada,
des problèmes de cache (Avada + plugin cache + CDN) qui masquent vos changements.

Conseil pratique : après modifications, videz :

le cache Avada,
le cache de votre plugin (si présent),
et éventuellement le cache CDN.

Vérifications après mise en place

Le thème enfant apparaît dans Apparence > Thèmes avec votre nom et (idéalement) une capture.
Le site s’affiche sans erreurs.
Votre test CSS (outline rouge) est visible.
Dans le code source HTML, vous voyez deux CSS chargés : parent puis child (l’ordre exact dépend du thème, mais le child doit être après).

Tableau de diagnostic (symptômes fréquents)

Symptôme	Cause probable	Vérification	Solution
Le thème enfant n’apparaît pas	En-tête `style.css` manquant ou mal formé	Ouvrez `style.css` et vérifiez les champs	Corrigez l’en-tête, surtout `Theme Name` et `Template`
“Le thème parent est manquant”	`Template:` ne correspond pas au dossier du parent	Comparez `Template:` avec `wp-content/themes/`	Mettez le bon slug, respectez la casse
Le CSS du child ne s’applique pas	Cache, mauvais enqueue, ou CSS trop peu spécifique	Inspecteur navigateur > onglet Network/CSS	Videz les caches, vérifiez `wp_enqueue_style`, ajustez les sélecteurs
Écran blanc / erreur critique	Erreur PHP dans `functions.php`	Logs serveur / mode debug	Corrigez la syntaxe via SFTP, restaurez la sauvegarde si besoin

Si ça ne marche pas

1) Vérifiez le champ Template

C’est la cause n°1. Il doit être le dossier du thème parent. Exemple : Template: Divi est souvent faux si le dossier s’appelle Divi (parfois oui), mais sur d’autres thèmes le nom affiché et le dossier diffèrent.

2) Vérifiez que vous éditez le bon fichier

Erreur classique : vous modifiez wp-content/themes/mon-theme-enfant/functions.php… mais vous avez activé un autre thème enfant, ou le site pointe sur un autre environnement.

Dans WP Admin, regardez le thème actif.
Ajoutez temporairement un marqueur (ex : une classe theme-enfant-actif via body_class) et vérifiez dans l’inspecteur.

3) Activez le debug sur staging

Sur un fatal error, vous avez besoin d’un message précis. Utilisez WP_DEBUG sur staging. Doc : Debug WordPress.

4) Videz les caches (vraiment)

J’ai souvent croisé le scénario : “ça ne marche pas” → on corrige le code → “ça ne marche toujours pas” → en fait c’est le cache navigateur + cache plugin + CDN.

Faites un rechargement forcé (Ctrl+F5).
Videz le cache du plugin.
Si vous avez Cloudflare/CDN, purgez.

5) Vérifiez la version PHP

Si votre hébergement est en PHP 7.4/8.0, certains snippets modernes (typage : void, etc.) peuvent casser. En 2026, visez PHP 8.1+. Référence : PHP Supported Versions.

Pièges et erreurs courantes

Erreur	Cause	Solution
Code collé dans le mauvais fichier	Vous avez collé le code dans le parent ou dans un plugin de snippets	Collez-le dans `wp-content/themes/mon-theme-enfant/functions.php` (et activez le thème enfant)
`Parse error: syntax error, unexpected ...`	Point-virgule manquant, accolade en trop, parenthèse oubliée	Revenez à la dernière modification, comparez avec le code fourni, utilisez un éditeur avec validation
Le CSS ne se charge pas	Mauvais chemin (`/assets/css`), ou fichier absent	Vérifiez l’URL dans l’inspecteur réseau, corrigez le chemin
Hook inadapté	Vous chargez des styles sur `init` au lieu de `wp_enqueue_scripts`	Utilisez `add_action('wp_enqueue_scripts', ...)`
Conflit avec cache/minification	Le cache combine et sert une ancienne version	Purger cache plugin/CDN, incrémenter `Version` du thème enfant
Tester en production sans sauvegarde	Pression / “petit changement”	Staging + sauvegarde + accès SFTP avant tout
Permaliens “bizarres” après surcharge de templates	Réécritures / règles non régénérées (cas limites)	Réglages > Permaliens > Enregistrer (sans changer)
Code d’un ancien tutoriel incompatible	Utilise `@import`, ou des pratiques obsolètes	Revenez à `wp_enqueue_style()` et aux docs WP actuelles

Conseils sécurité, performance et maintenance

Sécurité

Ne mettez pas de logique sensible (auth, paiements, traitement de formulaires) uniquement dans un thème enfant si vous pouvez l’éviter : préférez un plugin.
Si vous ajoutez des formulaires, utilisez nonce + capabilities + sanitization + escaping. Doc : Nonces.

Performance

Évitez @import dans le CSS.
Évitez de charger 5 fichiers CSS “custom” si un seul suffit. Chaque fichier peut coûter une requête (même si HTTP/2 aide).
Versionnez vos assets (vous le faites déjà via wp_get_theme()->get('Version')). Quand vous changez un fichier, incrémentez Version dans l’en-tête du thème enfant.

Maintenance

Gardez une liste de ce que vous surchargez (templates copiés). Le jour où le parent se met à jour, vous comparez et vous décidez si vous devez reporter des changements.
Si vous surchargez un template, relisez les changelogs du thème parent à chaque mise à jour (souvent sur le site de l’éditeur ou dans le package).
Si votre thème enfant grossit (beaucoup de fonctionnalités), migrez progressivement vers un plugin custom. C’est une évolution saine.

Ressources

FAQ

Est-ce que je dois créer un thème enfant si j’utilise seulement un page builder ?

Pas toujours. Si vous ne faites que de la mise en page dans Divi/Elementor/Avada, vous pouvez parfois vous en passer. Dès que vous ajoutez du CSS global durable, des scripts, ou des modifications PHP, le thème enfant devient un filet de sécurité.

Quelle différence entre “CSS additionnel” et CSS dans un thème enfant ?

Le “CSS additionnel” est pratique et rapide. Le thème enfant est plus maintenable (versionné, exportable, réutilisable, reviewable). Sur des sites clients, je préfère le thème enfant (ou un plugin) pour garder un historique clair.

Mon thème parent n’a pas de style.css “classique”. Je fais comment ?

Certains thèmes chargent plusieurs CSS (ou un CSS généré). Dans ce cas, charger /style.css du parent peut ne pas suffire. Regardez dans le parent : cherchez wp_enqueue_style( dans son functions.php pour identifier le handle/les fichiers réellement chargés. Ensuite, chargez votre CSS child en dépendance du handle principal du parent.

Pourquoi mon CSS child est chargé mais ne s’applique pas ?

Deux causes fréquentes : (1) la spécificité CSS (le thème/builder gagne), (2) le cache. Inspectez l’élément, regardez quelle règle “gagne”, puis ajustez le sélecteur. Évitez !important sauf en dernier recours.

Est-ce que je peux ajouter du PHP “comme un plugin” dans le thème enfant ?

Oui, techniquement. Mais si la fonctionnalité doit rester même si vous changez de thème, faites un plugin. Le thème enfant est idéal pour ce qui dépend du design/templates.

Comment surcharger un template sans me faire piéger par les mises à jour ?

Surchargez le moins possible. Si vous devez modifier un petit bout, cherchez d’abord un hook/filtre offert par le thème parent. Si vous copiez un template entier, notez-le et comparez-le à chaque mise à jour du parent.

Est-ce que le thème enfant impacte le SEO ?

Indirectement seulement. Un thème enfant bien fait n’ajoute pas de “pénalité”. Par contre, si vous ajoutez du CSS/JS lourd ou si vous cassez le balisage (titres, schema, etc.) via un template, là oui, vous pouvez impacter les performances et la structure.

Dois-je créer un thème enfant pour un thème bloc (FSE) ?

Si vous personnalisez surtout styles et templates blocs, vous pouvez parfois préférer un thème bloc personnalisé (ou des variations). Mais si vous avez besoin de PHP (hooks, enqueue, logique), le thème enfant reste pertinent.

Je vois une “Erreur critique sur ce site” après avoir modifié functions.php. Que faire ?

Connectez-vous en SFTP, renommez temporairement le dossier du thème enfant (ex : mon-theme-enfant_OFF) pour forcer WordPress à repasser sur un autre thème, puis corrigez l’erreur. Ensuite, remettez le nom normal et réactivez.

Puis-je créer le thème enfant via l’admin WordPress ?

Il existe des plugins qui le font, mais je préfère la création manuelle : vous comprenez ce que vous déployez, et vous évitez les thèmes enfants “bizarres” avec des enqueues inutiles.

Comment tester ce code proprement sans casser mon site ?

Faites-le sur staging, activez WP_DEBUG, faites une modification CSS visible, puis une modification PHP minimale (ex : body_class). Une fois validé, déployez en production, puis videz les caches.