Créer un plugin WordPress avec l’IA n’est plus une utopie en 2025. En octobre dernier, je me suis lancé dans un défi: développer un plugin WordPress professionnel sans écrire une seule ligne de code manuellement.
Le résultat ? ORIA, 15 000 lignes de code générées par intelligence artificielle.
📖 Introduction : Un projet de formation devient une démonstration de compétences
En octobre 2025, je me suis inscrit à la formation Prompt Engineering chez JEDHA avec un objectif pédagogique clair : comprendre les capacités réelles des LLM et transmettre ces compétences à mes étudiants en BTS NDRC, Bachelor et Mastère e-marketing.
Le projet final devait démontrer une maîtrise avancée du prompt engineering appliqué à un cas concret. J’ai choisi de créer ORIA (Assistant d’ORientation IA), un plugin WordPress permettant aux établissements scolaires d’intégrer un conseiller d’orientation intelligent, alimenté par l’IA et basé sur une technologie RAG (Retrieval-Augmented Generation).
- Le défi technique : Concevoir et développer un plugin WordPress production-ready, avec architecture modulaire, multi-LLM (Claude, OpenAI, Mistral), système RAG sémantique avancé, interface d’administration complète et documentation professionnelle.
- La contrainte pédagogique : Ne pas écrire moi-même le code PHP, mais démontrer qu’avec une maîtrise du prompt engineering et des bons outils, on peut piloter l’IA pour générer un logiciel complexe et maintenable.
Résultat : 15 000 lignes de code fonctionnel, 35 fichiers structurés, documentation complète auto-générée, et un plugin déployé en production pour mes étudiants au Lycée Saint Vincent de Paul à Nîmes.
Cet article partage la méthodologie complète, les apprentissages clés, et démontre les nouvelles compétences nécessaires pour créer des solutions logicielles sans coder.
En préambule, voici le plugin ORIA en action et ce qu’il est capable de faire :
🎯 PARTIE 1 : La conception — 70% du travail se fait AVANT la première ligne de code
1.1 — L’erreur fatale des débutants : Demander à l’IA de “créer un plugin”
Scénario typique observé chez mes étudiants :
❌ Prompt débutant :
"Crée-moi un plugin WordPress pour gérer des formations"
Ce qui se passe :
- L’IA génère quelque chose de générique
- Aucune vision d’ensemble
- Code désorganisé dès 300 lignes
- Impossible à faire évoluer
- Abandon du projet après 2 semaines
Pourquoi ça échoue : L’IA n’est pas magique. Elle a besoin d’un cahier des charges précis, exactement comme un développeur junior.
1.2 — La méthodologie qui fonctionne : Concevoir comme un chef de projet
Avant d’ouvrir Claude Code, j’ai passé 2 jours complets à documenter :
📋 Document 1 : Vision produit
# ORIA - Assistant d'Orientation IA
## Problème à résoudre
Les étudiants et lycéens sont perdus dans l'orientation.
Les conseillers humains sont débordés (1 pour 500 élèves).
Les sites web des établissements contiennent l'info mais
personne ne la trouve.
## Solution proposée
Plugin WordPress permettant d'intégrer un assistant IA
qui guide les visiteurs vers la bonne formation selon
leur profil, leurs intérêts et leur situation.
## Différenciation
- Pas un simple chatbot FAQ (FAQ = questions prédéfinies)
- Système RAG sémantique (comprend l'intention, pas juste les mots-clés)
- Multi-LLM (établissement choisit son fournisseur IA)
- Installation en 5 minutes (plugin WordPress standard)
- RGPD-compliant (données en local, pas de tracking externe)
## Marché cible
- Lycées privés (300+ en France)
- Écoles supérieures (CFA, campus, universités)
- Centres de formation professionnelle
## Business model (V2) ou pas ?
- Version FREE : 1 LLM, 50 conversations/mois
- Version PRO : Multi-LLM, illimité, support, white-label
- Prix cible : 99-199€/an par établissement
💡 Pourquoi c’est important : Cette vision guide TOUTES les décisions techniques qui suivent. Là encore, l’IA peut nous aider à structurer les prérequis et attendus.
📋 Document 2 : Spécifications fonctionnelles (8 pages)
Extrait structure :
## 1. ASSISTANT CONVERSATIONNEL
### 1.1 Personas utilisateur
Le système doit proposer 5 profils différents :
**Persona 1 : Lycéen indécis**
- Âge : 16-18 ans
- Situation : Ne sait pas quoi faire après le bac
- Besoins : Exploration large, découverte des métiers
- Ton : Encourageant, pédagogique, sans jargon
- Message d'accueil : "Salut ! 👋 Pas encore décidé pour ton
orientation ? Je suis là pour t'aider à y voir plus clair."
**Persona 2 : Étudiant en réorientation**
- Âge : 19-25 ans
- Situation : Veut changer de filière
- Besoins : Équivalences, passerelles, conseils concrets
- Ton : Direct, factuel, rassurant
[... 3 autres personas détaillés ...]
### 1.2 Interface chatbot
**Positionnement**
- Bottom-right par défaut (configurable)
- Icône : Bulle de dialogue + emoji personnalisable
- Z-index : 9999 (toujours au-dessus)
**Dimensions**
- Desktop : 400px × 600px
- Tablet : 350px × 500px
- Mobile : 100vw × 80vh (plein écran)
[... etc pour 8 pages ...]
Temps passé : 2 jours
Valeur : Évite 2 semaines d’allers-retours avec l’IA
📋 Document 3 : Architecture technique
## STRUCTURE DU PLUGIN
### Principes architecturaux
1. **Séparation des responsabilités** (SRP)
- Une classe = Une responsabilité
- Pas de classe monolithique >500 lignes
2. **Modularité**
- Chaque fonctionnalité = Module indépendant
- Activation/désactivation sans casser le reste
3. **Extensibilité**
- Hooks WordPress à chaque point clé
- Système de filtres pour personnalisation
### Organisation fichiers
oria/
├── oria.php # Bootstrap
├── includes/ # Classes core
│ ├── class-oria-core.php
│ ├── class-oria-options.php
│ └── class-oria-security.php
├── src/
│ ├── admin/ # Back-office
│ ├── frontend/ # Front-end
│ ├── llm/ # Intégrations IA
│ └── rag/ # Système RAG
├── assets/
│ ├── js/
│ └── css/
└── languages/ # i18n
💡 Apprentissage clé : Plus cette documentation est précise, plus le code généré est propre. Un chef de projet ne peut pas diriger sans plan.
1.3 — Best practice : Développer en anglais, traduire ensuite
Décision stratégique prise dès le départ : Tout le code et les commentaires en anglais.
Pourquoi ?
- Meilleure génération de code par l’IA
- Les LLM sont entraînés majoritairement sur du code anglais
- Vocabulaire technique plus précis en anglais
- Moins d’ambiguïtés (ex : “formation” FR = formation/training EN)
- Standards internationaux
- WordPress.org exige des commentaires en anglais
- Contributions open source facilitées
- Réutilisation du code par d’autres développeurs
- Internationalisation facilitée
- Code langue-agnostic dès le départ
- Traduction = fichier .po séparé (propre)
- Pas de chaînes hardcodées en français
Exemple concret :
// ❌ Mauvaise approche (code mixte FR/EN)
class ORIA_Admin {
/**
* Affiche la page des réglages
*/
public function display_settings_page() {
echo '<h1>Réglages ORIA</h1>';
}
}
// ✅ Bonne approche (code EN, i18n pour affichage)
class ORIA_Admin {
/**
* Display the settings page
*
* Renders the main settings interface with tabbed navigation
*
* @since 1.0.0
* @return void
*/
public function display_settings_page() {
echo '<h1>' . esc_html__('ORIA Settings', 'oria') . '</h1>';
}
}
Résultat : Claude Code a généré 100% du code en anglais, avec documentation PHPDoc impeccable, puis a créé automatiquement les fichiers de traduction selon les guidelines WordPress.
🛠️ PARTIE 2 : Les outils — De la frustration à l’efficacité
2.1 — Octobre 2025 : L’enfer du copier-coller
Premier essai avec ChatGPT et Claude via interface web :
Le cycle infernal :
Moi : “Crée-moi une classe PHP pour gérer les embeddings”
ChatGPT : [Génère 200 lignes]
Moi : [Copie dans VS Code]
Test : ❌ Fatal error ligne 47
Moi : [Copie l’erreur, retour ChatGPT]
ChatGPT : “Ah désolé, voici la correction…”
Moi : [Re-copie, re-teste]
Test : ❌ Nouvelle erreur ligne 89
Problèmes identifiés :
- Perte de contexte entre sessions (limite messages)
- Copier-coller manuel = erreurs (encodage, indentation)
- Gestion multi-fichiers impossible (>10 fichiers = chaos)
- Crash navigateur avec gros fichiers PHP (>1000 lignes)
- Pas de versioning intégré
Temps perdu : 3 heures pour une classe, dont 2h de debug.
Conclusion : Cette méthode ne scale pas. Impossible de créer un plugin complexe ainsi.
2.2 — Novembre 2025 : La révolution Claude Code
Découverte de l’outil CLI d’Anthropic, sorti en beta fin 2025.
Installation (2 minutes) :
A noter que si vous préfèrez, et c’est encore plus simple, Claude Code propose son interface cloud que vous pouvez plugger directement sur votre compte GitHub.
# macOS/Linux
curl -fsSL https://claude.ai/install.sh | sh
# Windows PowerShell
irm https://claude.ai/install.ps1 | iex
# Vérification
claude --version
Premier test :
$ cd /mon/projet/wordpress/wp-content/plugins/oria
$ claude code
Claude Code v1.2.0 initialized
Project files detected: 3 files, ~500 lines
Ready to help! What would you like to work on?
> Analyze the current architecture and suggest improvements
[Claude lit tous les fichiers du projet]
Analysis complete. Current structure:
- Single file: oria.php (487 lines)
- Monolithic architecture
- No separation of concerns
Recommendations:
1. Split into modular classes
2. Create src/ directory structure
3. Implement PSR-4 autoloading
Shall I proceed with the refactoring?
> Yes, create the new architecture
[15 minutes later]
✅ Created 12 new files
✅ Moved code to appropriate classes
✅ All tests passing
🤯 Game changer.
2.3 — Ce qui change TOUT avec Claude Code
| Critère | Interface Web | Claude Code CLI |
|---|---|---|
| Contexte projet | ❌ Inexistant | ✅ 200k tokens |
| Gestion fichiers | ❌ Copier-coller | ✅ Modification directe |
| Multi-fichiers | ❌ Un à la fois | ✅ 10+ fichiers simultanés |
| Versioning | ❌ Manuel | ✅ Git intégré |
| Limite messages | ❌ 50-100/jour | ✅ Illimité |
Workflow avec Claude Code :
$ claude code
> Create a RAG system with semantic search.
> Requirements:
> - Generate embeddings for all formations
> - Store in wp_oria_embeddings table
> - Implement cosine similarity search
> - Return top 5 most relevant results
[Claude travaille...]
✅ Created:
- src/rag/class-oria-embeddings.php (420 lines)
- src/rag/class-oria-vector-store.php (350 lines)
- src/rag/class-oria-semantic-search.php (280 lines)
✅ Tests: ALL PASS
Ready to test in WordPress admin.
Temps écoulé : 18 minutes
Équivalent manuel : 2-3 jours de développement
2.4 — Stack complète utilisée pour ORIA
Outil principal : Claude Code (70% du développement)
- Sonnet 4 pour génération de code
- Opus 4 pour architecture complexe
- Contexte de 200k tokens (tout le projet en mémoire)
- Intégration Git native
- Tests automatiques
Usage :
# Architecture initiale
claude code -m "opus-4"
# Développement features
claude code
# Refactoring complexe
claude code -m "opus-4" --context-length=max
Outils complémentaires :
- Claude Sonnet 4.5 (web) – 20%
- Rédaction cahiers des charges
- Documentation utilisateur
- ChatGPT o1 – 5%
- Validation bugs complexes
- Debugging alternatif
- GitHub
- Versioning automatique
- Pull requests auto-générées
- WordPress Plugin Check
- Validation standards WordPress.org
- Détection erreurs sécurité
🎯 PARTIE 3 : Les prompts — La différence entre débutant et expert
3.1 — Anatomie d’un bon prompt pour Claude Code
Un prompt efficace contient 5 éléments obligatoires :
- CONTEXTE (Qui tu es / Quel est le projet)
- OBJECTIF (Que veux-tu accomplir)
- CONTRAINTES TECHNIQUES (Standards, sécurité)
- SPÉCIFICATIONS FONCTIONNELLES (Ce que ça doit faire)
- CRITÈRES DE SUCCÈS (Comment savoir que c’est terminé)
3.2 — Exemples réels : Mauvais vs Bons prompts
EXEMPLE 1 : Création d’une classe admin
❌ Prompt débutant (vague, incomplet)
"Crée-moi une classe pour gérer l'admin du plugin"
Problème : Aucun contexte, pas de specs, aucune contrainte de sécurité.
Résultat : Code générique, non sécurisé, inutilisable.
✅ Bon prompt (structuré, précis)
CONTEXT:
You are a WordPress plugin expert with 10+ years experience.
We're building ORIA, an AI-powered guidance assistant plugin.
OBJECTIVE:
Create the main admin class that handles:
- Settings page with tabbed interface
- Options management (save/retrieve)
- Assets enqueuing (CSS/JS for admin only)
- Metaboxes for custom post types
TECHNICAL CONSTRAINTS:
- WordPress Coding Standards
- PHP 8.0+ (use type declarations)
- All strings must be internationalized (__(), esc_html__())
- Security: nonces on all forms, sanitization on all inputs
- Performance: enqueue assets only on plugin pages
- Namespace: ORIA\Admin
FUNCTIONAL SPECIFICATIONS:
1. Settings Page
- Main menu "ORIA" in WordPress admin
- Subpages: Settings, RAG Diagnostics, System Status
- Settings page has 4 tabs:
* General (bot name, welcome message)
* API Configuration (provider, key, test connection)
* Appearance (colors, position, personas)
* Advanced (fine-tuning, logging)
2. Options Management
- Use WordPress Options API
- Prefix all options with 'oria_'
- Validate before saving
- Provide default values
3. Assets
- admin.css: enqueue only on plugin pages
- admin.js: same condition
- Localize script with ajaxurl and nonce
4. Metaboxes
- Add metabox to 'formation' CPT
- Fields: prerequisites, duration, diploma_level
- Save with proper nonces and validation
SUCCESS CRITERIA:
- No PHP errors with WP_DEBUG enabled
- Settings save/retrieve correctly
- Metaboxes display and save data
- Assets load only on plugin pages
- All strings translatable
DELIVERABLE:
File: includes/class-oria-admin.php
Documentation: PHPDoc on all methods
Résultat avec ce prompt : Classe admin de 350 lignes, propre, documentée, sécurisée, fonctionnelle du premier coup.
EXEMPLE 2 : Intégration API externe (Anthropic)
❌ Prompt débutant
"Fais une classe pour appeler l'API Claude"
Problème : Pas de gestion d’erreurs, pas de rate limiting, clé API hardcodée, aucune abstraction.
✅ Bon prompt (complet et structuré)
CONTEXT:
ORIA plugin needs to support multiple LLM providers (Claude, OpenAI, Mistral).
We need a flexible architecture that allows switching providers without changing code.
OBJECTIVE:
Create an LLM provider system with:
1. Abstract provider interface
2. Claude (Anthropic) implementation
3. Proper error handling and rate limiting
4. Response streaming support
ARCHITECTURE:
Interface: LLM_Provider_Interface
├── Methods:
│ ├── call(string $prompt, array $context, string $persona): array
│ ├── test_connection(): bool
│ └── get_available_models(): array
Class: ORIA_Claude implements LLM_Provider_Interface
├── Properties:
│ ├── private string $api_key (from options)
│ ├── private string $model (configurable)
│ └── private int $max_tokens (configurable)
├── Methods:
│ ├── call(): sends request to Anthropic API
│ ├── build_prompt(): constructs prompt with RAG context
│ ├── handle_error(): logs and returns user-friendly message
│ └── is_rate_limited(): checks if API limit reached
TECHNICAL CONSTRAINTS:
- Use WordPress HTTP API (wp_remote_post)
- Store API key in options, not hardcoded
- Implement exponential backoff for retries
- Cache responses for 5 minutes (transients)
- Log errors to wp_oria_logs table
- Timeout: 30 seconds max
- Max tokens: configurable (default 1500)
ERROR HANDLING:
- Network errors → Graceful fallback message
- Invalid API key → Clear error to admin
- Rate limit → Wait and retry (3 attempts)
- Invalid response → Log and show generic error
SECURITY:
- API key stored encrypted (if possible)
- No API key in logs or error messages
- Validate all responses before use
SUCCESS CRITERIA:
- Successful API call returns structured response
- Errors handled gracefully (no fatal errors)
- Rate limiting works correctly
- Test connection feature functional
- Code works with real API key
DELIVERABLE:
- src/llm/interface-llm-provider.php
- src/llm/class-oria-claude.php
- Unit tests for error scenarios
- Documentation with example usage
Résultat : Système complet avec gestion d’erreurs robuste, rate limiting, fallbacks, logs, et abstraction permettant d’ajouter d’autres providers facilement.
EXEMPLE 3 : Système RAG sémantique
❌ Prompt débutant
"Ajoute une recherche sémantique au plugin"
Problème : “Recherche sémantique” trop vague, rien sur les embeddings, pas de specs BDD, aucune indication de performance.
✅ Bon prompt (exhaustif et technique)
CONTEXT:
ORIA needs semantic search to find relevant formations when users ask questions.
Current system: basic keyword matching (insufficient).
Target: RAG (Retrieval-Augmented Generation) with embeddings.
OBJECTIVE:
Implement a complete RAG system:
1. Generate embeddings for all content (formations, fiches métiers, PDFs)
2. Store embeddings in database
3. Semantic search: find top 5 most similar content
4. Inject results as context in LLM prompts
TECHNICAL ARCHITECTURE:
Class: ORIA_Embeddings
├── Purpose: Generate and manage embeddings
├── Methods:
│ ├── generate(int $post_id): array
│ │ → Calls Anthropic API to get embedding (1536 dimensions)
│ │ → Caches result in wp_oria_embeddings table
│ ├── regenerate_all(): void
│ │ → Batch processing with progress tracking
│ ├── should_regenerate(int $post_id): bool
│ │ → Compare content hash, regenerate if changed
Class: ORIA_Vector_Store
├── Purpose: Database operations for embeddings
├── Methods:
│ ├── save(int $post_id, array $embedding): bool
│ ├── get(int $post_id): array|null
│ ├── search(array $query_embedding, int $limit): array
│ │ → Cosine similarity calculation
│ │ → Returns top N results with scores
│ ├── delete(int $post_id): bool
Class: ORIA_Semantic_Search
├── Purpose: High-level search interface
├── Methods:
│ ├── find_relevant_content(string $query): array
│ │ → Generate embedding for query
│ │ → Search in vector store
│ │ → Return WP_Post objects with scores
│ ├── build_context_for_llm(array $results): string
│ │ → Format results as prompt context
FUNCTIONAL REQUIREMENTS:
1. Embedding Generation
- Trigger: On post save (formation, fiche métier)
- Content to embed: Title + excerpt + content + metadata
- Format: Single text string, max 8000 characters
- Storage: JSON array (1536 floats)
2. Similarity Search
- Algorithm: Cosine similarity
- Formula: similarity = dot(A, B) / (norm(A) * norm(B))
- Threshold: Return only results with score > 0.7
- Limit: Top 5 results
3. Performance
- Embeddings generation: Batch process (10 posts at a time)
- Cache: Never regenerate if content unchanged (use hash)
- Database: Index on post_id for fast lookup
- Search: Must return in < 500ms
4. Admin Interface
- Page: ORIA → RAG Diagnostics
- Display: Number of embeddings per post type
- Actions: "Generate All", "Force Reindex"
- Progress bar during batch processing
DATABASE TABLE:
CREATE TABLE wp_oria_embeddings (
id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
post_id bigint(20) unsigned NOT NULL,
content_hash varchar(64) NOT NULL,
embedding longtext NOT NULL,
created_at datetime NOT NULL,
PRIMARY KEY (id),
KEY post_id (post_id),
KEY content_hash (content_hash)
);
SECURITY & ERROR HANDLING:
- API failures → Log error, continue with next post
- Invalid embeddings → Skip and log
- Database errors → Transaction rollback
- Rate limiting → Respect Anthropic API limits
SUCCESS CRITERIA:
- Query "formations en marketing" returns BTS NDRC, Bachelor Marketing
- Embeddings regenerate only when content changes
- Admin page shows accurate counts
- Search completes in < 500ms
- No memory leaks during batch processing
DELIVERABLE:
- src/rag/class-oria-embeddings.php
- src/rag/class-oria-vector-store.php
- src/rag/class-oria-semantic-search.php
- src/admin/class-oria-rag-diagnostics-page.php
- Database migration script
- PHPDoc documentation
Résultat avec ce prompt : Système RAG complet, performant, avec interface admin, gestion d’erreurs, et cache intelligent. Fonctionnel du premier coup après tests.
3.3 — Patterns de prompts gagnants
Après 50+ sessions Claude Code, voici les patterns systématiques qui fonctionnent :
Pattern 1 : Spécifier le rôle et l’expertise
CONTEXT:
You are a WordPress security expert specializing in plugin development.
You follow OWASP guidelines and WordPress Security Handbook.
→ Claude adopte le niveau d’expertise approprié et génère du code sécurisé.
Pattern 2 : Donner des exemples d’utilisation
USAGE EXAMPLE:
// User asks: "Quelles formations en commerce ?"
$search = new ORIA_Semantic_Search();
$results = $search->find_relevant_content("formations en commerce");
// Expected results:
// [
// { post: WP_Post(BTS NDRC), score: 0.89 },
// { post: WP_Post(Bachelor Commerce), score: 0.85 },
// { post: WP_Post(Licence Pro Vente), score: 0.78 }
// ]
$context = $search->build_context_for_llm($results);
// Returns formatted string for LLM prompt
→ Claude comprend exactement le format attendu et génère le code correspondant.
Pattern 3 : Spécifier les tests à créer
TEST SCENARIOS:
1. Happy path
- Input: Valid query "formations marketing"
- Expected: 3-5 relevant results, scores > 0.7
2. Edge cases
- Empty query → Return empty array, no errors
- No results found → Return empty array with message
- API failure → Fallback to keyword search
3. Performance
- 100 embeddings in DB → Search < 500ms
- 1000 embeddings → Search < 1000ms
4. Security
- SQL injection attempts → Properly escaped
- XSS in query → Sanitized before storage
→ Claude génère du code défensif et crée les tests correspondants.
💡 Tips bonus :
– L’IA peut même vous aider à concevoir les bons prompts
– Commencez le prompt, donnez le au LLM qui va le retravailler, l’ajuster et/ou l’étoffer
– Relisez le et validez si OK !
🔧 PARTIE 4 : La traduction et la documentation — 100% automatisées
4.1 — Stratégie i18n : Développer en anglais, traduire proprement
Décision prise dès le début : Tout le code en anglais, traduction française via fichiers .po/.mo.
Avantages de cette approche :
- Code propre et maintenable
- Pas de mélange FR/EN dans le code
- Standards internationaux respectés
- Contribution open source facilitée
- Traduction professionnelle
- Fichiers .po révisables par des traducteurs
- Outils comme Poedit utilisables
- Séparation claire code/contenu
- Multi-langue facile
- Ajouter une langue = créer un .po
- Pas besoin de modifier le code
- WordPress gère automatiquement
Prompt donné à Claude Code pour la traduction :
TASK: Generate complete French translation for ORIA plugin
CONTEXT:
All code is in English with proper i18n functions (__(), _e(), etc.).
We need professional French translation following WordPress guidelines.
REQUIREMENTS:
1. Create translation template (.pot file)
- Extract all translatable strings from PHP files
- Include translator comments
- Proper headers (Plugin name, version, etc.)
2. Create French translation (.po file)
- Translate ALL strings to professional French
- Respect WordPress translation style guide
- No informal "tu" (use "vous")
- Technical terms: keep English in parentheses if ambiguous
3. Compile .mo file
- Binary format for production use
STYLE GUIDE:
Technical terms:
- "Settings" → "Réglages" (WordPress standard)
- "Dashboard" → "Tableau de bord"
- "Plugin" → "Extension" (official WP FR term)
- "Shortcode" → Keep "Shortcode" (no translation)
- "Embedding" → Keep "Embedding" (technical term)
Tone:
- Professional, clear, concise
- Active voice preferred
- Instructions: use infinitive ("Configurer l'API" not "Configurez")
WordPress UI consistency:
- Match core WordPress French translations
- Check glossary: https://translate.wordpress.org/locale/fr/default/glossary
DELIVERABLE:
- languages/oria.pot (template)
- languages/oria-fr_FR.po (translation)
- languages/oria-fr_FR.mo (compiled)
- Translation memory file for future updates
Résultat : Claude Code a généré :
- 450 chaînes traduites
- Respect total des conventions WordPress
- Compilation .mo automatique
- Fichier prêt pour WordPress.org
Temps : 12 minutes (vs 2-3 jours manuellement)
4.2 — Documentation auto-générée : La killer feature
Ce qui m’a le plus impressionné : Claude Code génère une documentation technique magnifique, uniquement en lisant le code (tout y est : Le CSS, les ancres internes, tooltips, notices, etc.). Que ce soit la doc interne, Readme, inline…
Prompt utilisé :
Generate complete technical documentation by analyzing the codebase.
CONTEXT:
ORIA is a WordPress plugin for AI-powered guidance assistant.
We need documentation that meets WordPress.org standards and developer needs.
OBJECTIVE:
Create comprehensive documentation by analyzing the codebase:
1. readme.txt (WordPress.org format)
- Plugin header (name, tags, requires, tested up to)
- Short description (150 chars max)
- Long description with features list
- Installation instructions
- FAQ section (10+ questions)
- Screenshots descriptions
- Changelog (reverse chronological)
- Upgrade notices
2. README.md (GitHub format)
- Overview with badges (version, license, WP compatibility)
- Features list with emojis
- Requirements (PHP, WordPress, dependencies)
- Installation (manual + composer if applicable)
- Configuration guide
- Usage examples with code snippets
- API documentation (hooks, filters)
- Troubleshooting section
- Contributing guidelines
- License information
3. Technical documentation (/docs/)
- ARCHITECTURE.md: Complete architecture overview
* Component diagram
* Class hierarchy
* Data flow
* Database schema
- API.md: All public methods documentation
* Parameters
* Return values
* Usage examples
- HOOKS.md: All WordPress hooks reference
* Actions with parameters
* Filters with usage
- SECURITY.md: Security considerations
* Nonce usage
* Data sanitization
* Capability checks
- CHANGELOG.md: Detailed version history
4. Inline documentation
- PHPDoc blocks for all classes
- PHPDoc blocks for all methods
- Inline comments for complex logic
- @since tags for version tracking
REQUIREMENTS:
Format specifications:
- readme.txt: Follow WordPress.org format exactly
* Use === for H2, == for H3
* Contributors, donate link, tags format
* Stable tag, requires at least, tested up to
- README.md: GitHub Markdown with badges
- docs/*.md: GitHub Flavored Markdown
- PHPDoc: WordPress coding standards
Content quality:
- Clear and concise
- Beginner-friendly for readme.txt
- Technical but accessible for README.md
- Developer-focused for /docs/
- Real examples, not placeholders
- SEO-optimized descriptions
WordPress.org specific:
- Tags: max 5, most relevant
- Short description: exactly what it does
- Installation: step-by-step, numbered
- FAQ: anticipate user questions
- Screenshots: describe what users see
SUCCESS CRITERIA:
- readme.txt passes WordPress.org validation
- README.md displays perfectly on GitHub
- All docs are accurate (reflect actual code)
- No broken links or missing sections
- PHPDoc generates clean API documentation
- Non-developers can install and use the plugin
- Developers can extend the plugin
DELIVERABLES:
- readme.txt (root directory)
- README.md (root directory)
- docs/ARCHITECTURE.md
- docs/API.md
- docs/HOOKS.md
- docs/SECURITY.md
- docs/CHANGELOG.md
- All PHP files with complete PHPDoc
Format: Markdown, ready for GitHub
Résultat : 3 fichiers de documentation professionnelle
📄 ARCHITECTURE.md (extrait)
# ORIA Plugin Architecture
## Overview
ORIA follows a modular architecture with clear separation of concerns.
The plugin is structured using PSR-4 autoloading and WordPress best practices.
## Core Components
### 1. Initialization Layer
- `oria.php`: Main plugin file (bootstrap)
- `includes/class-oria-core.php`: Core initialization
- Handles: Activation, deactivation, table creation
### 2. Admin Layer (`src/admin/`)
- Settings pages with tabbed interface
- Metaboxes for custom post types
- Asset management (CSS/JS enqueuing)
- AJAX handlers for admin actions
### 3. Frontend Layer (`src/frontend/`)
- Chatbot rendering
- Shortcode implementation
- Public-facing styles and scripts
### 4. LLM Integration Layer (`src/llm/`)
- Provider abstraction (interface)
- Multiple LLM implementations:
* Anthropic Claude (primary)
* OpenAI GPT
* Mistral AI
### 5. RAG System (`src/rag/`)
- Embeddings generation (Anthropic API)
- Vector storage (MySQL)
- Semantic search (cosine similarity)
- Context building for prompts
## Data Flow
User Query
↓
Frontend Chatbot (AJAX)
↓
AJAX Handler
↓
Semantic Search (RAG)
↓
[Retrieve top 5 relevant formations]
↓
LLM Provider (Claude/OpenAI/Mistral)
↓
[Generate response with context]
↓
Response to User
↓
Store in Conversation History
💡 Valeur de cette documentation :
– Onboarding d’un nouveau dev : 2h au lieu de 2 jours
– Maintenance facilitée (je comprends mon propre code 6 mois après)
– Crédibilité professionnelle (documentation = sérieux)
📊 PARTIE 5 : Résultats et apprentissages
5.1 — Les chiffres d’ORIA
| Métrique | Valeur |
|---|---|
| Temps de développement | 3 semaines (temps réel) |
| Temps IA actif | ~12 heures de sessions |
| Budget IA | ~35€ (API Anthropic) + ChatGPT+ |
| Lignes de code | 15 137 lignes |
| Fichiers créés | 35 fichiers |
| Classes PHP | 15 classes |
| Fonctions | 124 fonctions |
| Hooks WordPress | 47 hooks |
| Tables BDD | 3 tables custom |
| Traductions | 456 chaînes FR |
| Documentation | 12 pages markdown |
| Code compris par moi | ~18% 😅 |
5.2 — Ce que j’ai appris sur le prompt engineering
Apprentissage #1 : La conception vaut 10× l’exécution
- 2 jours de specs = 2 semaines économisées en développement
- Un cahier des charges précis = code propre dès le début
- Itérer sur des specs = gratuit. Itérer sur du code = coûteux.
Apprentissage #2 : L’IA n’est pas magique, c’est un collaborateur junior++
- Elle a besoin de directives claires
- Elle fait des erreurs (mais moins qu’un humain)
- Elle doit être testée et validée
- Elle excelle dans l’exécution, pas la stratégie
Apprentissage #3 : Le bon outil change tout
- Interface web = copier-coller = enfer
- Claude Code = intégration native = productivité ×10
Apprentissage #4 : La documentation est une compétence IA sous-estimée
- Claude Code génère de meilleure doc que 90% des devs
- C’est lui qui m’a appris des patterns que je ne connaissais pas
- La doc auto-générée est à jour (elle lit le code actuel)
5.3 — Ce que ça change pour mes étudiants
Au Lycée Saint Vincent de Paul (Mastère), j’enseigne maintenant :
- Méthodologie de conception avant le code
- Apprendre à décomposer un problème
- Rédiger des specs fonctionnelles
- Penser en architecture modulaire
- Prompt engineering appliqué au développement
- Structurer ses demandes
- Itérer intelligemment
- Tester et valider
- Utilisation professionnelle des LLM
- Claude Code pour les projets complexes
- ChatGPT pour le prototypage rapide
- Quand utiliser quel outil ?
Exemple de projet étudiant à venir:
Demander à mes étudiant en Mastère de créer un plugin WordPress de gestion de témoignages clients en 1 semaine, avec interface admin complète, shortcode responsive, et modération intégrée.
Sans formation dev PHP. Juste en appliquant la méthodologie ORIA.
5.4 — Le potentiel pour la communauté WordPress
Vision 2025-2026 : WordPress devient LA plateforme no-code par excellence.
Pourquoi WordPress est idéal pour le no-code IA :
- Architecture standardisée
- Hooks, filtres, CPT = patterns connus de l’IA
- WordPress Coding Standards = référence claire
- Documentation extensive = training data
- Écosystème gigantesque
- 43% du web = marché énorme
- 60 000+ plugins = références infinies
- Millions d’utilisateurs = distribution facile
- Barrière technique effondrée
- Créer un plugin = accessible aux non-devs
- Tests simplifiés (WordPress.org guidelines)
- Distribution clé en main (wp.org + marketplaces)
Opportunités émergentes :
- Créateurs de plugins de niche (micro-SaaS)
- Consultants “Chef d’orchestre IA” (piloter l’IA pour les clients)
- Formateurs en no-code IA (énorme demande)
- Agences spécialisées (solutions WordPress sur-mesure rapides)
🎯 Conclusion : Le métier évolue, les compétences aussi
Ce que ORIA démontre
1. Le code n’est plus la barrière
En 2025, savoir coder PHP n’est plus un prérequis pour créer des plugins WordPress. La vraie compétence devient :
- Savoir concevoir (architecture, specs)
- Savoir guider l’IA (prompt engineering)
- Savoir valider (tests, sécurité)
2. Le prompt engineering est une discipline à part entière
Ce n’est pas “taper des questions dans ChatGPT”. C’est :
- Structurer sa pensée
- Décomposer les problèmes
- Communiquer précisément avec un système non-humain
- Itérer intelligemment
| Dev traditionnel | Prompt Engineering |
|---|---|
| Écrire le code | Décrire le code |
| Débugger ligne par ligne | Expliquer le problème |
| 6 mois de formation | 3 semaines de pratique |
| Compétence technique | Compétence méthodologique |
3. La valeur se déplace vers l’expertise métier
Avant : “Je suis développeur PHP senior”
Valeur : Maîtrise technique
Maintenant : “Je suis expert orientation scolaire + prompt engineer”
Valeur : Expertise métier + capacité à créer des solutions
L’IA réduit l’avantage du dev pur. Elle amplifie l’avantage de l’expert métier qui sait utiliser l’IA.
Mes recommandations pour les formateurs WordPress
Si vous formez au développement WordPress :
- Intégrez le prompt engineering dès maintenant
- Ne pas enseigner QUE le code manuel
- Apprendre à piloter l’IA = compétence essentielle 2026+
- Changez le focus pédagogique
- Moins : syntaxe PHP, détails techniques
- Plus : architecture, sécurité, conception
- Valorisez l’expertise métier
- Un bon cahier des charges >= un bon développeur
- La conception devient la vraie compétence
- Préparez vos étudiants au futur
- En 2026, tout le monde saura utiliser l’IA pour coder
- La différence se fera sur la qualité de la conception
Le futur des créateurs WordPress
2025-2027 : Fenêtre d’opportunité exceptionnelle
Pourquoi MAINTENANT :
- ✅ L’IA est mature (génère du code pro)
- ✅ Peu de gens le maîtrisent encore
- ✅ Le marché n’est pas saturé
- ✅ WordPress est la plateforme idéale
Dans 2-3 ans :
- ❌ Tout le monde utilisera l’IA
- ❌ La concurrence sera forte
- ❌ La différenciation sera difficile
Conseil : Agissez maintenant. Créez, expérimentez, partagez.
ORIA : Quel avenir pour ce plugin No Code ?
A court terme, le plugin sera disponible sur :
- WPFormation.com (version PRO en finalisation de développement)
Objectifs :
- Démocratiser l’accès à l’orientation IA
- Montrer ce qui est possible avec le no-code
- Créer une communauté de créateurs WordPress + IA
Pour aller plus loin
Formations :
- JEDHA – Prompt Engineering (ma formation de base)
- Cours-ndrc.fr – IA appliquée au e-marketing (mes cours)
Outils :
- Claude Code (CLI) – L’outil principal
- WordPress Plugin Check – Validation
- Poedit – Traductions
Ressources :
- WordPress Plugin Handbook (developer.wordpress.org)
- Anthropic Documentation (docs.anthropic.com)
- WPFormation (YouTube)
Une dernière chose
Si vous avez lu jusqu’ici, vous avez compris que créer un plugin WordPress sans coder n’est pas de la “triche”. C’est une nouvelle façon de travailler, qui nécessite des compétences différentes mais tout aussi exigeantes.
L’IA ne remplace pas les développeurs.
Elle transforme le métier de développeur.
Ceux qui l’adopteront tôt auront un avantage compétitif énorme. Ceux qui la rejetteront seront dépassés.
À vous de choisir votre camp.
📧 Contact & Questions
Des questions sur ORIA ou la méthodologie ?
- 💬 Commentaires ci-après
- 📧 [email protected]
- 💼 LinkedIn : Fabrice Ducarme
Vous voulez tester ORIA ?
- 🤖 Démo live : polesup-vincentdepaul30.com/bot
- 🎥 Vidéo commentée du back-office : Google Drive
Intéressé par une formation ?
- 🎓 Cours NDRC : cours-ndrc.fr
- 📚 Formations WordPress : wpformation.com/formations
Si cet article vous a aidé, partagez-le ci-dessous avec votre réseau.
#WordPress #IA #PromptEngineering #NoCode #ClaudeCode
