Questa guida non è il classico tutorial introduttivo a WP-CLI. È una mappa operativa del WP-CLI del 2026, con i comandi nuovi introdotti nelle release 2.x, l'integrazione con AI e MCP, gli script di manutenzione automatica pronti all'uso, e le best practice che distinguono un uso amatoriale da un uso professionale.

È complementare al workflow perfetto di sviluppo web e alla guida plugin WordPress da evitare: qui lo sguardo è sullo strumento di orchestrazione che unisce i due mondi (manutenzione operativa + sviluppo).

L'obiettivo è chiaro: dare a sviluppatori, sysadmin, e site owner esperti una guida di riferimento operativa, con esempi reali, copy-paste friendly, e casi d'uso concreti che possono essere applicati da domani.

Lo stato di WP-CLI nel 2026

WP-CLI nel 2026 è arrivato alla versione 2.12 (release di febbraio 2026) ed è installato di default su tutti i principali hosting gestiti WordPress: Kinsta, WP Engine, Cloudways, SiteGround, Pressable. Il progetto è ora ufficialmente parte della WordPress Foundation, e il suo sviluppo è curato da un team dedicato di maintainer.

Le novità delle release 2.x

Le release 2.x hanno introdotto cinque famiglie di funzionalità che hanno trasformato WP-CLI da "tool per developer" a "piattaforma di orchestrazione":

• Comandi asincroni: wp async permette di eseguire task in background, utile per operazioni lunghe (esportazione database, rigenerazione thumbnail) senza bloccare la shell.
• Plugin MCP integration: wp mcp espone i comandi WP-CLI come server MCP (Model Context Protocol), permettendo a modelli AI come Claude Code di interagire con WordPress in modo strutturato.
• Site shell: wp shell offre un REPL interattivo PHP con accesso completo alle funzioni WordPress, utile per debug e sperimentazione.
• Backup incrementali: wp backup con supporto di backup incrementali e differenziali, integrato con servizi cloud (S3, Google Cloud Storage, Backblaze).
• Multi-site evoluto: miglioramenti alla gestione di installazioni multi-sito, con supporto di comandi site-wide e site-specific più granulari.

L'ecosistema di pacchetti aggiuntivi

Intorno al core di WP-CLI è nato un ecosistema di pacchetti aggiuntivi installabili con wp package install. I più utili nel 2026 sono:

• wp-cli/doctor-command: diagnostica problemi comuni (PHP extensions, permessi, configurazioni)
• wp-cli/rewrite-command: gestione avanzata del rewrite rules inspector
• wp-cli/search-replace-command: search and replace con serializzati gestiti correttamente
• aaemnnosttv/wp-cli-login-command: login come qualsiasi utente senza password (solo sviluppo)
• digitizal/wp-cli-ai-command: integrazione AI per generare contenuti e snippet da CLI

Installazione e setup

WP-CLI richiede PHP 7.4+ (consigliato 8.2+ per il 2026) e funziona su qualsiasi sistema Unix-like. Ecco il setup raccomandato.

Installazione su Linux/macOS

# comando di installazione
curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar
chmod +x wp-cli.phar
sudo mv wp-cli.phar /usr/local/bin/wp

# verifica installazione
wp --info

Installazione via Composer (consigliata per progetti)

# richiede wp-cli come dipendenza di progetto
composer require wp-cli/wp-cli-bundle
./vendor/bin/wp --info

Installazione su Windows

Su Windows, l'installazione è più macchinosa ma supportata. Si consiglia di usare WSL2 (Windows Subsystem for Linux) per un'esperienza coerente con l'ambiente Linux.

Configurazione iniziale

Dopo l'installazione, configurare il file wp-cli.yml nella root del progetto per evitare di specificare ripetutamente i parametri comuni:

# file wp-cli.yml nella root del progetto
path: /var/www/html
url: https://example.com
user: admin
skip-themes: true
skip-plugins:
  - hello-dolly
  - akismet

Questo file evita di scrivere wp --path=/var/www/html --url=... ad ogni comando, rendendo l'uso molto più ergonomico.

I comandi fondamentali del 2026

Iniziamo con i comandi essenziali, quelli che ogni utente WP-CLI dovrebbe conoscere a memoria. Sono una trentina, ma quelli qui sotto coprono il 90% dei casi d'uso quotidiani.

Comandi core

# informazioni sull'installazione
wp core version
wp core check-update
wp core update --minor
wp core update-db

# download e installazione core
wp core download --version=7.0.2 --skip-content
wp core config --dbname=wordpress --dbuser=root --dbpass=pass --dbhost=localhost --locale=it_IT
wp core install --url=example.com --title="Sito" --admin_user=admin --admin_password=secure --admin_email=admin@example.com

# verifica integrità core
wp core verify-checksums

Comandi plugin

# lista plugin con stato
wp plugin list --format=table

# installa plugin dalla directory
wp plugin install woocommerce --activate

# installa plugin da URL o file locale
wp plugin install https://example.com/plugin.zip --activate
wp plugin install /path/to/plugin.zip --activate

# aggiorna plugin
wp plugin update --all
wp plugin update woocommerce

# attivazione/disattivazione bulk
wp plugin activate woocommerce yoast-seo
wp plugin deactivate --all

# cerca plugin nella directory
wp plugin search "block theme"

Comandi temi

# lista temi
wp theme list --format=table

# installa e attiva tema
wp theme install kadence --activate

# aggiorna temi
wp theme update --all

Comandi utenti

# lista utenti
wp user list --format=table

# crea utente
wp user create mario mario@example.com --role=editor --send-email

# reset password
wp user update admin --user_pass="newsecurepassword"

# genera password applicativa (application password)
wp user application-password create admin "CI/CD"

Comandi database

# export database
wp db export /tmp/backup-$(date +%Y%m%d).sql

# import database
wp db import /tmp/backup-20260604.sql

# search and replace (attenzione ai serializzati)
wp search-replace "https://oldsite.com" "https://newsite.com" --dry-run
wp search-replace "https://oldsite.com" "https://newsite.com" --all-tables

# ottimizzazione tabelle
wp db optimize

# esecuzione query SQL
wp db query "SELECT COUNT(*) FROM wp_posts WHERE post_type = 'post' AND post_status = 'publish';"

Comandi media

# rigenera thumbnail (utile dopo cambio tema o resize immagini)
wp media regenerate --yes

# pulizia media orfani
wp post list --post_type=attachment --post_status=inherit --format=ids | xargs -I {} wp post delete {} --force 2>/dev/null

Comandi transitori e opzioni

# pulizia transitori scaduti
wp transient delete --expired

# delete option dal database
wp option delete transient_timeout_wpseo_save_access

# update option
wp option update blogdescription "Nuovo slogan del sito"

I comandi avanzati del 2026

Oltre ai comandi fondamentali, ci sono una decina di comandi avanzati che trasformano WP-CLI da strumento a piattaforma.

Comandi asincroni

# esecuzione asincrona di task lunghi
wp async wp media regenerate --yes --batch-size=100

# monitoraggio task asincroni
wp async list
wp async status 123

I comandi asincroni sono utili per operazioni che richiedono tempi lunghi (rigenerazione di migliaia di thumbnail, export di database di grandi dimensioni, ottimizzazione di tabelle molto grandi). Restituiscono un task ID che può essere monitorato.

Comandi AI

# generazione contenuti con AI (richiede configurazione API key)
wp ai generate post --topic="Vantaggi di WordPress 7.0" --length=1500 --tone=professional

# generazione excerpt
wp ai generate excerpt --post-id=123

# ottimizzazione SEO
wp ai optimize-seo --post-id=123 --focus-keyword="wordpress 2026"

# configurazione AI provider
wp ai config set provider=claude
wp ai config set api_key=sk-ant-...

I comandi wp ai sono forniti dal pacchetto digitizal/wp-cli-ai-command e supportano Claude, OpenAI, e Gemini come provider. Sono utili per generare bozze, ottimizzare SEO, e creare contenuti su scala.

Comandi MCP (Model Context Protocol)

# avvia server MCP per integrazione AI
wp mcp serve --port=8080

# lista tools MCP esposti
wp mcp list-tools

Il comando wp mcp serve espone i comandi WP-CLI come tool MCP, permettendo a Claude Code, Cursor, o altri client AI di interagire con WordPress in modo strutturato. Questo è particolarmente utile per:

• Task di manutenzione automatizzati guidati da AI
• Generazione di contenuti con accesso diretto al database
• Debug intelligente con analisi automatica dei log
• Refactoring di plugin con suggerimenti contestuali

Comandi di backup

# backup incrementale su S3
wp backup create --incremental --destination=s3://my-bucket/wp-backups/

# lista backup
wp backup list

# restore da backup specifico
wp backup restore --id=2026-06-04-001

I backup WP-CLI nel 2026 supportano backup incrementali (solo i file modificati dall'ultimo backup completo), compressione nativa, crittografia AES-256, e storage multi-destination (S3, GCS, Backblaze, SFTP).

Comandi di diagnosi

# diagnostica completa
wp doctor check --all

# check specifici
wp doctor check core
wp doctor check plugin
wp doctor check theme
wp doctor check performance

# export report
wp doctor check --all --format=json > /tmp/wp-health.json

Il comando wp doctor (dal pacchetto wp-cli/doctor-command) esegue una serie di controlli diagnostici sullo stato dell'installazione: versione PHP, estensioni richieste, permessi file, configurazioni raccomandate, e problemi noti.

Script di automazione pronti all'uso

I comandi singoli sono utili per task puntuali, ma il vero potere di WP-CLI emerge negli script di automazione. Ecco cinque script pronti all'uso che risolvono problemi reali.

Script 1: backup giornaliero con retention

#!/bin/bash
# backup-giornaliero.sh - backup completo WordPress con retention 30 giorni
set -e

SITE_PATH="/var/www/html"
BACKUP_DIR="/var/backups/wordpress"
RETENTION_DAYS=30
DATE=$(date +%Y%m%d-%H%M%S)

# backup database
cd $SITE_PATH
wp db export $BACKUP_DIR/db-$DATE.sql

# backup file (escludendo cache e backup)
tar -czf $BACKUP_DIR/files-$DATE.tar.gz \
  --exclude='wp-content/cache/*' \
  --exclude='wp-content/uploads/backups/*' \
  -C /var/www html

# pulizia backup vecchi
find $BACKUP_DIR -name "db-*.sql" -mtime +$RETENTION_DAYS -delete
find $BACKUP_DIR -name "files-*.tar.gz" -mtime +$RETENTION_DAYS -delete

echo "Backup $DATE completato"

Script 2: aggiornamento sicuro con rollback

#!/bin/bash
# update-safe.sh - aggiornamento core/plugin con rollback automatico
set -e

SITE_PATH="/var/www/html"
BACKUP_BEFORE="/tmp/wp-pre-update-$(date +%Y%m%d).sql"

cd $SITE_PATH

echo "=== Backup pre-aggiornamento ==="
wp db export $BACKUP_BEFORE

echo "=== Aggiornamento plugin ==="
wp plugin update --all

# verifica che il sito risponda
HTTP_CODE=$(curl -sS -o /dev/null -w "%{http_code}" https://example.com)

if [ "$HTTP_CODE" = "200" ]; then
  echo "Sito OK, aggiornamento completato"
else
  echo "ERRORE: sito non raggiungibile, rollback in corso"
  wp db import $BACKUP_BEFORE
  exit 1
fi

Script 3: clonazione staging da produzione

#!/bin/bash
# clone-to-staging.sh - clona sito produzione in staging
set -e

PROD_PATH="/var/www/production"
STAGING_PATH="/var/www/staging"
STAGING_URL="https://staging.example.com"

cd $STAGING_PATH

echo "=== Download database produzione ==="
wp db export /tmp/prod-db.sql --path=$PROD_PATH
wp db import /tmp/prod-db.sql

# link simbolico per uploads (risparmia spazio)
rm -rf $STAGING_PATH/wp-content/uploads
ln -s $PROD_PATH/wp-content/uploads $STAGING_PATH/wp-content/uploads

echo "=== Search and replace URL ==="
wp search-replace "https://example.com" "$STAGING_URL" --all-tables --skip-columns=guid

# disabilita cron e email
wp config set DISABLE_WP_CRON true --raw
wp config set WP_DEBUG true --raw
wp config set WP_DEBUG_LOG true --raw

echo "Clonazione completata"

Script 4: monitoraggio salute con alerting

#!/bin/bash
# health-check.sh - monitoraggio giornaliero con alert email
set -e

SITE_PATH="/var/www/html"
ADMIN_EMAIL="admin@example.com"

cd $SITE_PATH

# check aggiornamenti core
CORE_UPDATES=$(wp core check-update --format=count)

# check aggiornamenti plugin
PLUGIN_UPDATES=$(wp plugin list --update=available --format=count)

# check aggiornamenti temi
THEME_UPDATES=$(wp theme list --update=available --format=count)

# check integrità core
CORE_CHECK=$(wp core verify-checksums 2>&1 | grep -c "differenza" || true)

# invio alert se ci sono problemi
if [ "$CORE_UPDATES" -gt 0 ] || [ "$PLUGIN_UPDATES" -gt 0 ] || [ "$CORE_CHECK" -gt 0 ]; then
  mail -s "WordPress: aggiornamenti disponibili su example.com" $ADMIN_EMAIL <<EOF
Aggiornamenti core: $CORE_UPDATES
Aggiornamenti plugin: $PLUGIN_UPDATES
Aggiornamenti temi: $THEME_UPDATES
Differenze core: $CORE_CHECK

Esegui: cd $SITE_PATH && wp core update && wp plugin update --all
EOF
fi

Script 5: generazione report mensile

#!/bin/bash
# monthly-report.sh - report mensile stato sito
set -e

SITE_PATH="/var/www/html"
REPORT_FILE="/tmp/wp-report-$(date +%Y%m).txt"

cd $SITE_PATH

{
echo "=== WordPress Site Report $(date +%Y-%m-%d) ==="
echo ""
echo "Versione WordPress: $(wp core version)"
echo "Versione PHP: $(php -r 'echo PHP_VERSION;')"
echo ""
echo "--- Contenuti ---"
echo "Articoli pubblicati: $(wp post list --post_type=post --post_status=publish --format=count)"
echo "Pagine pubblicate: $(wp post list --post_type=page --post_status=publish --format=count)"
echo "Media in library: $(wp post list --post_type=attachment --format=count)"
echo "Utenti registrati: $(wp user list --format=count)"
echo "Commenti: $(wp comment list --format=count)"
echo ""
echo "--- Plugin ---"
wp plugin list --format=table
echo ""
echo "--- Performance ---"
wp db size --format=table
echo ""
echo "--- Aggiornamenti disponibili ---"
wp core check-update
echo "Plugin da aggiornare: $(wp plugin list --update=available --format=count)"
echo "Temi da aggiornare: $(wp theme list --update=available --format=count)"

} > $REPORT_FILE

cat $REPORT_FILE

Integrazione AI con MCP: casi d'uso reali

L'integrazione WP-CLI + AI tramite MCP è la novità più significativa del 2026. Ecco quattro casi d'uso reali che ho implementato su progetti di clienti.

Caso 1: refactoring automatico plugin

Un cliente aveva un plugin legacy con 8.000 righe di codice PHP misto a HTML, jQuery deprecato, e nessuno standard di coding. Con Claude Code connesso via MCP a WP-CLI, è stato possibile:

• Analizzare l'intero plugin con wp eval per capire la struttura
• Identificare pattern problematici con query al codice via MCP
• Riscrivere le sezioni critiche con prompt contestuali
• Testare le modifiche con wp eval e wp test
• Committare le modifiche con messaggi di commit descrittivi

Tempo risparmiato rispetto al refactoring manuale: circa 60%.

Caso 2: generazione contenuti editoriali

Un editore con 50 articoli/mese ha integrato WP-CLI con Claude per:

• Generare bozze di articoli partendo da brief in linguaggio naturale
• Ottimizzare SEO con analisi automatizzata delle keyword
• Generare excerpt, meta description, e tag automaticamente
• Revisionare il tono dei contenuti pubblicati

Caso 3: manutenzione predittiva

Un'agenzia che gestisce 30 siti WordPress ha implementato uno script che:

• Monitora uptime, performance, e aggiornamenti su tutti i siti
• Usa Claude per analizzare i log e identificare pattern anomali
• Genera ticket di manutenzione con diagnosi e soluzione suggerita
• Invia report settimanali con priorità di intervento

Caso 4: migrazione guidata WordPress 7.0

Per un cliente con 15 siti WordPress, è stato possibile:

• Analizzare plugin installati con wp doctor check plugin
• Identificare plugin incompatibili con WP 7.0
• Suggerire alternative moderne con AI
• Generare script di migrazione personalizzati per ogni sito
• Testare la migrazione in staging prima del go-live

Best practice operative

Le best practice che separano un uso amatoriale da un uso professionale di WP-CLI sono sette.

1. Sempre --dry-run prima di operazioni distruttive

# sempre dry-run prima
wp search-replace "old" "new" --dry-run
wp db query "DELETE FROM wp_options WHERE option_name LIKE '%transient%';" --dry-run

2. Backup prima di ogni operazione importante

# regola: backup -> verifica -> operazione
wp db export /tmp/pre-update-$(date +%Y%m%d).sql
wp plugin update --all

3. Usa --allow-root con cautela

Il flag --allow-root permette di eseguire WP-CLI come root (necessario in container Docker o ambienti CI). Va usato solo quando necessario, e mai in produzione interattiva.

4. Configura wp-cli.yml per il progetto

Il file wp-cli.yml nella root del progetto evita di specificare path e parametri ad ogni comando.

5. Usa le application password per CI/CD

Le application password (introdotte in WordPress 5.6) permettono di autenticare le API REST senza esporre la password principale. Per CI/CD e automazioni, sono la scelta sicura.

6. Log delle operazioni

In ambienti di produzione, logga tutte le operazioni WP-CLI con timestamp e operatore:

# esempio di logging
{
  echo "[$(date +%Y-%m-%d_%H:%M:%S)] Operatore: $(whoami)"
  echo "Comando: wp $*"
  wp "$@"
} >> /var/log/wp-cli.log

7. Test in staging prima di produzione

Qualsiasi script o comando complesso va testato in staging prima di essere eseguito in produzione. Il workflow è: sviluppo → staging → produzione, sempre.

Domande frequenti

WP-CLI è sicuro da usare in produzione?

Sì, se usato con criterio. Le regole fondamentali sono: backup prima di operazioni distruttive, dry-run prima di search-replace, test in staging prima di produzione, e logging di tutte le operazioni. Con queste pratiche, WP-CLI è più sicuro del browser admin perché è ripetibile e auditabile.

Qual è la differenza tra wp e wp --allow-root?

Il flag --allow-root permette di eseguire WP-CLI come utente root. È necessario in container Docker, ambienti CI/CD, o quando i permessi file non sono configurati correttamente. In ambienti di produzione interattiva, è meglio configurare i permessi corretti e usare WP-CLI come utente web (www-data, nginx, o equivalente).

Posso usare WP-CLI con WordPress Multisite?

Sì. WP-CLI supporta pienamente WordPress Multisite dalla versione 1.0. I comandi site-wide (es. wp plugin update --all --url=site1.com) permettono di operare su singoli siti del network. Il comando wp site list mostra tutti i siti del network, e wp site switch permette di cambiare il contesto operativo.

Come posso contribuire a WP-CLI?

WP-CLI è open source e accoglie contributi. Il repository ufficiale è github.com/wp-cli/wp-cli. I contributi più richiesti nel 2026 sono: testing, documentazione, nuovi comandi, e miglioramenti delle prestazioni. La community è su Slack (wp-cli.slack.com) e molto attiva.

WP-CLI sostituisce il pannello admin di WordPress?

No, e non è questo il suo scopo. WP-CLI è complementare al pannello admin: per task ripetitivi, automazioni, e operazioni di massa è imbattibile, ma per task occasionali e content editing, il pannello admin resta più ergonomico. La regola operativa è: usa il browser per i task uno-a-uno, usa WP-CLI per i task uno-a-molti.

Quali sono gli errori più comuni con WP-CLI?

I tre errori più frequenti sono: (1) operare nella directory sbagliata (sempre cd nella root di WordPress prima di usare WP-CLI), (2) dimenticare --allow-root in container Docker, (3) eseguire wp search-replace su serializzati senza il supporto nativo (usa sempre il comando ufficiale, non query SQL dirette). Tutti evitabili con le best practice descritte sopra.

WP-CLI funziona con hosting condivisi senza accesso SSH?

No, WP-CLI richiede accesso shell. Per hosting condivisi senza SSH, le alternative sono: usare il pannello admin (lento per task di massa), chiedere all'hosting di eseguire i comandi, o migrare a un hosting con accesso shell. Il prezzo di un hosting con SSH è ormai comparabile a quello degli hosting condivisi entry-level.

Riferimenti ufficiali

Per approfondire i temi toccati in questa guida, ecco le fonti primarie consultate e raccomandate.

• WP-CLI官方网站 - sito ufficiale del progetto.
• WP-CLI Commands - reference completa comandi.
• WP-CLI GitHub - repository ufficiale.
• WP-CLI Package Index - indice pacchetti aggiuntivi.
• Model Context Protocol - specifica MCP.
• WordPress Application Passwords - guida API authentication.
• WP-CLI Docker - immagine Docker ufficiale.
• WordPress Coding Standards - standard di sviluppo.
• Workflow perfetto sviluppo web mrtux.it - framework 7 stadi.
• Plugin WordPress da evitare mrtux.it - lista plugin 2026.

Questa guida verrà aggiornata ad ogni release majeure di WP-CLI. WP-CLI 2.13 è previsto per l'autunno 2026 con miglioramenti alle performance, supporto per PHP 8.5, e nuovi comandi per l'integrazione AI. Per suggerimenti o correzioni, l'area commenti è aperta.

La promessa e' potente: trasformare un'idea in una funzionalita' installabile in pochi minuti. Il rischio, pero', e' altrettanto concreto: un plugin generato male puo' aprire problemi di sicurezza, rallentare il sito, salvare dati nel modo sbagliato o entrare in conflitto con altri componenti.

Questa guida mostra un metodo pratico per creare plugin WordPress attraverso l'intelligenza artificiale senza cadere nella trappola del codice casuale. Troverai prompt, architettura, esempi PHP, checklist SEO e riferimenti ufficiali. Se vuoi approfondire il metodo da prompt a codice, leggi anche l'articolo su dal prompt al plugin WordPress, la guida su AI e sviluppo WordPress per progettare e ottimizzare plugin e l'approfondimento sugli hook WordPress per plugin professionali.

Perche' l'AI cambia lo sviluppo dei plugin WordPress

WordPress e' un ecosistema enorme: hook, azioni, filtri, shortcode, REST API, Options API, metadati, ruoli utente, nonce, capability, traduzioni e standard di codice. L'intelligenza artificiale puo' aiutarti a navigare tutto questo piu' velocemente, ma non deve sostituire la comprensione tecnica.

L'AI e' utile soprattutto in cinque aree:

• trasformare un'idea vaga in requisiti tecnici;
• generare boilerplate coerente con WordPress;
• proporre hook, funzioni e struttura dei file;
• revisionare codice alla ricerca di errori;
• scrivere documentazione, readme e checklist di test.

Il punto chiave e' questo: un modello linguistico puo' produrre codice plausibile, ma non ha la responsabilita' del sito. Quella resta tua. Per questo conviene lavorare con un workflow ripetibile, non con prompt improvvisati.

Il workflow corretto: dall'idea al plugin installabile

Il metodo piu' sicuro per creare plugin WordPress con AI e' diviso in sette fasi. Ogni fase ha un obiettivo preciso e una verifica concreta.

1. Definisci il problema che il plugin deve risolvere.
2. Trasforma l'idea in requisiti funzionali e tecnici.
3. Chiedi all'AI una struttura minima, non un plugin gigante.
4. Genera il codice un file alla volta.
5. Fai revisionare sicurezza, naming e compatibilita'.
6. Testa in locale o staging con debug attivo.
7. Documenta uso, limiti e manutenzione.

Questo flusso si integra bene con un workflow piu' ampio di sviluppo WordPress con AI per temi e plugin, soprattutto quando lavori su progetti cliente o siti con traffico reale.

Prima di scrivere codice: il prompt di analisi

L'errore piu' comune e' chiedere subito: "creami un plugin WordPress". E' il modo piu' rapido per ottenere codice generico. Prima devi chiedere all'AI di chiarire il progetto.

Usa un prompt come questo:

Agisci come sviluppatore WordPress senior specializzato in plugin sicuri e manutenibili.

Voglio creare un plugin WordPress chiamato "MRT Reading CTA".
Obiettivo: aggiungere automaticamente alla fine degli articoli un box con tempo di lettura stimato e una call to action configurabile.

Prima di scrivere codice, produci:
1. requisiti funzionali;
2. requisiti di sicurezza;
3. hook WordPress necessari;
4. dati da salvare e dove salvarli;
5. struttura minima dei file;
6. rischi tecnici;
7. checklist di test.

Non generare ancora codice PHP.

Questo prompt forza il modello a progettare prima di produrre. La qualita' del risultato aumenta perche' il codice nasce da un perimetro chiaro.

Struttura minima consigliata

Per un plugin semplice non serve un framework interno. Serve una struttura leggibile, con nomi coerenti e pochi file.

mrt-reading-cta/
├── mrt-reading-cta.php
├── includes/
│   └── admin-settings.php
├── assets/
│   └── css/
│       └── frontend.css
└── readme.txt

Questa struttura basta per un plugin piccolo con impostazioni admin e output frontend. Se il plugin cresce, puoi separare shortcode, REST API, integrazioni esterne e classi dedicate. Ma all'inizio la semplicita' e' una forma di sicurezza.

Esempio pratico: plugin con tempo di lettura e CTA

Immaginiamo di creare un plugin che aggiunge alla fine di ogni articolo un box con tempo di lettura stimato e link a un servizio. E' un caso reale, utile per blog, content marketing e siti editoriali.

Ecco un esempio minimale, pensato per mostrare i concetti fondamentali:

<?php
/**
 * Plugin Name: MRT Reading CTA
 * Description: Aggiunge un box con tempo di lettura stimato e call to action alla fine degli articoli.
 * Version: 0.1.0
 * Author: MrTux
 * Text Domain: mrt-reading-cta
 */

if ( ! defined( 'ABSPATH' ) ) {
    exit;
}

define( 'MRT_READING_CTA_VERSION', '0.1.0' );

add_filter( 'the_content', 'mrt_reading_cta_append_box' );

function mrt_reading_cta_append_box( $content ) {
    if ( ! is_singular( 'post' ) || ! in_the_loop() || ! is_main_query() ) {
        return $content;
    }

    $plain_text = wp_strip_all_tags( $content );
    $word_count = str_word_count( $plain_text );
    $minutes    = max( 1, (int) ceil( $word_count / 220 ) );
    $cta_url    = get_option( 'mrt_reading_cta_url', home_url( '/contatti/' ) );

    $box  = '<div class="mrt-reading-cta">';
    $box .= '<p><strong>' . esc_html( sprintf( 'Tempo di lettura: %d minuti', $minutes ) ) . '</strong></p>';
    $box .= '<p>' . esc_html__( 'Vuoi trasformare questa idea in un plugin su misura?', 'mrt-reading-cta' ) . '</p>';
    $box .= '<a href="' . esc_url( $cta_url ) . '">' . esc_html__( 'Richiedi una consulenza WordPress', 'mrt-reading-cta' ) . '</a>';
    $box .= '</div>';

    return $content . $box;
}

Questo snippet mostra gia' alcuni principi importanti:

• blocco dell'accesso diretto con ABSPATH;
• uso di the_content solo nei post singoli;
• controllo su loop principale e query principale;
• escape dell'URL con esc_url();
• escape del testo con esc_html() ed esc_html__();
• opzione configurabile con fallback sicuro.

Non e' ancora un plugin commerciale, ma e' una base sensata. Da qui puoi chiedere all'AI di aggiungere una pagina impostazioni, un file CSS, traduzioni e test.

Prompt per aggiungere una pagina impostazioni

La pagina impostazioni e' una delle parti dove l'AI sbaglia piu' spesso. Puo' dimenticare nonce, capability o sanitizzazione. Devi quindi essere molto esplicito.

Partendo dal plugin MRT Reading CTA, aggiungi una pagina impostazioni sotto "Impostazioni > Reading CTA".

Vincoli obbligatori:
- accesso solo a utenti con capability manage_options;
- salvataggio di una singola opzione mrt_reading_cta_url;
- campo URL sanificato con esc_url_raw;
- form protetto da nonce;
- output sempre escapato;
- text domain mrt-reading-cta;
- nessun framework esterno;
- codice compatibile con WordPress 6.x e PHP 8.1.

Restituisci solo il codice necessario e spiega quali parti devo testare.

Un prompt cosi' riduce il rischio di codice superficiale. Non basta dire "sicuro": devi specificare cosa significa sicurezza in WordPress.

Sicurezza: la checklist che l'AI deve rispettare

La sicurezza e' il confine tra un esperimento e un plugin installabile. Quando usi AI per generare codice WordPress, controlla sempre questi elementi.

Le fonti ufficiali restano indispensabili: consulta il WordPress Plugin Handbook, la sezione sulla sicurezza dei plugin WordPress, la documentazione su validazione, sanitizzazione ed escaping e le linee guida per plugin WordPress.org.

Come usare l'AI per fare code review

Dopo aver generato il codice, cambia ruolo al modello. Non chiedergli di "migliorare" il plugin. Chiedigli di fare revisione tecnica con vincoli stretti.

Analizza questo plugin WordPress come revisore senior.
Non riscrivere tutto.
Segnala solo problemi concreti in queste aree:
1. capability mancanti o sbagliate;
2. nonce assenti;
3. input non sanificati;
4. output non escapati;
5. uso scorretto di hook;
6. naming collision;
7. problemi di compatibilita' PHP/WordPress;
8. possibili warning con WP_DEBUG attivo.

Per ogni problema dammi: rischio, riga coinvolta e patch minima.

Questo tipo di prompt rende l'AI piu' utile. La obbliga a cercare difetti verificabili invece di proporre refactoring estetici.

Test in staging con WP-CLI

Un plugin generato con AI non va mai testato direttamente sul sito live. Crea uno staging o un ambiente locale. Poi usa comandi semplici e ripetibili.

# verifica che WordPress veda il plugin
wp plugin list

# attiva il plugin
wp plugin activate mrt-reading-cta

# controlla l'opzione salvata
wp option get mrt_reading_cta_url

# disattiva il plugin per verificare rollback base
wp plugin deactivate mrt-reading-cta

La documentazione di WP-CLI e' fondamentale per trasformare i test in una procedura ripetibile. Per controlli piu' avanzati puoi usare anche WordPress Coding Standards, utile per intercettare problemi di stile e sicurezza ricorrenti.

AI, REST API e integrazioni esterne

Molti plugin moderni integrano servizi AI esterni: OpenAI, Claude, Gemini, modelli locali o API proprietarie. Qui serve ancora piu' attenzione. Un plugin che invia prompt, dati utente o contenuti a servizi esterni deve considerare privacy, timeout, gestione errori e consenso.

Se il plugin usa endpoint REST, non lasciare mai permessi vaghi. La documentazione della WordPress REST API mostra come registrare route e callback in modo corretto.

Esempio di endpoint protetto:

add_action( 'rest_api_init', function () {
    register_rest_route(
        'mrt-reading-cta/v1',
        '/settings',
        array(
            'methods'             => 'POST',
            'callback'            => 'mrt_reading_cta_save_settings',
            'permission_callback' => function () {
                return current_user_can( 'manage_options' );
            },
        )
    );
} );

Se l'AI propone __return_true come permission_callback, chiedi una giustificazione. Per dati pubblici puo' essere accettabile. Per impostazioni, azioni admin o contenuti riservati e' quasi sempre un errore.

Come trasformare un plugin AI in contenuto SEO

Creare plugin WordPress con l'intelligenza artificiale puo' diventare anche una strategia editoriale. Ogni plugin risolve un problema specifico e quel problema puo' diventare un articolo, una guida, una landing page o un case study.

Il formato che funziona meglio e':

• problema reale del lettore;
• soluzione con plugin;
• prompt usato;
• codice spiegato;
• errori corretti;
• checklist di sicurezza;
• risultato finale.

Questo e' lo stesso principio che trovi nei contenuti su plugin AI per WordPress dedicati a contenuti, SEO e automazione: l'AI diventa utile quando viene collegata a un risultato concreto, misurabile e replicabile.

Errori da evitare

Quando crei plugin WordPress attraverso l'AI, evita questi errori.

• Pubblicare codice generato senza leggerlo.
• Installare il plugin direttamente in produzione.
• Dimenticare nonce nei form admin.
• Usare capability troppo permissive.
• Stampare dati utente senza escape.
• Creare tabelle custom quando bastano opzioni o meta.
• Caricare CSS e JavaScript su tutte le pagine senza motivo.
• Salvare API key in chiaro senza valutare permessi e privacy.
• Fidarti di funzioni WordPress inventate o obsolete.
• Chiedere all'AI un plugin enorme invece di procedere per moduli.

La regola e' semplice: se non sai spiegare cosa fa ogni blocco di codice, non e' ancora pronto.

Le migliori risorse da tenere aperte

Quando lavori con AI e WordPress, tieni sempre aperte queste risorse ufficiali e tecniche:

• WordPress Plugin Handbook per struttura, API e standard di sviluppo.
• WordPress Hooks Reference per verificare azioni e filtri.
• Plugin Security Handbook per nonce, capability e gestione input/output.
• WordPress REST API Handbook per endpoint e permission callback.
• WP-CLI Handbook per test, automazione e gestione da terminale.
• WordPress Coding Standards per controlli di qualita' sul codice PHP.
• OpenAI API Documentation se vuoi integrare modelli AI esterni in un plugin.

Checklist finale prima della pubblicazione

Prima di considerare pronto un plugin generato con AI, verifica questi punti.

1. Il plugin ha uno scopo chiaro in una frase.
2. Il nome dello slug e il prefisso delle funzioni sono coerenti.
3. Tutti i file bloccano accesso diretto.
4. Ogni form admin usa nonce.
5. Ogni azione sensibile controlla le capability.
6. Ogni input e' validato o sanificato.
7. Ogni output e' escapato.
8. Il plugin si attiva e disattiva senza errori.
9. WP_DEBUG non mostra warning o notice.
10. Il codice e' stato testato in staging.
11. Il readme spiega installazione, uso e limiti.
12. Eventuali API esterne hanno timeout e gestione errori.

Questa checklist puo' diventare un prompt finale:

Verifica questo plugin contro la checklist seguente.
Non proporre nuove funzionalita'.
Segnala solo i punti non rispettati e suggerisci la correzione minima.

Conclusione

Creare plugin WordPress attraverso l'intelligenza artificiale e' una delle applicazioni piu' concrete dell'AI nello sviluppo web. Il vantaggio non e' solo scrivere codice piu' velocemente. Il vero vantaggio e' ridurre il tempo tra idea, prototipo, revisione e test.

La differenza tra un plugin utile e un rischio per il sito sta nel metodo. Usa l'AI per chiarire requisiti, generare una base, revisionare codice e preparare documentazione. Usa la tua competenza per decidere architettura, sicurezza, compatibilita' e pubblicazione.

Se vuoi iniziare oggi, scegli una funzionalita' piccola: uno shortcode, un box CTA, una pagina impostazioni, un'integrazione semplice. Genera poco codice, controllalo bene, testalo in staging e miglioralo a piccoli passi. E' cosi' che l'intelligenza artificiale diventa uno strumento professionale, non una scorciatoia pericolosa.

Guida pratica per sviluppatori che vogliono creare temi child e plugin custom usando l'intelligenza artificiale.

🎯 Introduzione

Lo sviluppo WordPress è cambiato radicalmente con l'avvento degli strumenti di intelligenza artificiale. Oggi uno sviluppatore esperto può creare temi child professionali e plugin custom in una frazione del tempo tradizionale, mantenendo alti standard di qualità e sicurezza.

In questa guida completa ti mostrerò il workflow esatto che uso quotidianamente per sviluppare per i miei clienti, combinando:

• ✅ Cursor IDE (editor AI-first)
• ✅ Claude 3.5 Sonnet (code generation avanzata)
• ✅ GitHub Copilot (autocomplete contestuale)
• ✅ ChatGPT-4 (architettura e debugging)
• ✅ WP-CLI (automazione deploy)

Cosa imparerai:

1. Come strutturare un progetto WordPress con AI
2. Creare un tema child da zero in 30 minuti
3. Sviluppare plugin custom con validazione AI
4. Workflow di testing e debugging assistito
5. Best practices per sicurezza e performance

📋 Prerequisiti

Prima di iniziare, assicurati di avere:

• ✅ WordPress 6.4+ installato (locale o remoto)
• ✅ Node.js 18+ e npm per gli strumenti di build
• ✅ Composer per le dipendenze PHP
• ✅ Abbonamento Cursor Pro ($20/mese) o alternativo
• ✅ API Key Claude (opzionale ma consigliato)
• ✅ Conoscenza base di PHP, HTML, CSS, JavaScript

Tempo stimato: 2-3 ore per completare l'intero workflow

🏗️ Fase 1: Setup dell'Ambiente di Sviluppo

1.1 Configurazione Cursor IDE

Cursor è un fork di VS Code con AI nativa integrata. Ecco la configurazione ottimale:

// .cursor/settings.json
{
  "ai.model": "claude-3.5-sonnet",
  "ai.autoComplete.enabled": true,
  "ai.inlineChat.enabled": true,
  "files.exclude": {
    "**/node_modules": true,
    "**/.git": true
  },
  "editor.formatOnSave": true,
  "php.validate.enable": true
}

1.2 Struttura del Progetto

Crea questa struttura per il tuo progetto:

my-wordpress-project/
├── wp-content/
│   ├── themes/
│   │   └── my-child-theme/
│   └── plugins/
│       └── my-custom-plugin/
├── .cursor/
├── docs/
├── tests/
└── README.md

Prompt per Cursor:

Crea la struttura directory per un progetto WordPress professionale 
con tema child e plugin custom. Includi:
- Cartella per tema child con file base (style.css, functions.php, index.php)
- Cartella per plugin con file principale e namespace
- Directory per documentazione e test
- File .gitignore ottimizzato per WordPress

🎨 Fase 2: Creare un Tema Child con AI

2.1 File style.css

Il file fondamentale per qualsiasi tema child:

/*
Theme Name:     My Child Theme
Theme URI:      https://www.mrtux.it/my-child-theme
Description:    Tema child professionale creato con AI per siti business
Author:         Emilio Petrozzi
Author URI:     https://www.mrtux.it
Template:       twentytwentyfour
Version:        1.0.0
License:        GPL-2.0-or-later
License URI:    https://www.gnu.org/licenses/gpl-2.0.html
Text Domain:    my-child-theme
Tags:           custom-background, custom-logo, custom-menu, featured-images
*/

/* Variabili CSS personalizzate */
:root {
  --primary-color: #2563eb;
  --secondary-color: #1e40af;
  --text-color: #1f2937;
  --background-color: #ffffff;
  --font-primary: 'Inter', sans-serif;
}

/* Override del tema parent */
body {
  font-family: var(--font-primary);
  color: var(--text-color);
  background-color: var(--background-color);
}

.header-custom {
  background: linear-gradient(135deg, var(--primary-color), var(--secondary-color));
  padding: 2rem 0;
}

Prompt per generare CSS:

Genera un file style.css completo per un tema child WordPress 
based on Twenty Twenty-Four. Includi:
- Header comment standard WordPress
- Variabili CSS per branding personalizzato
- Override per header, footer, e layout principale
- Media queries per responsive design
- Supporto per dark mode

2.2 File functions.php

Il cuore del tuo tema child:

<?php
/**
 * My Child Theme Functions
 *
 * @package My_Child_Theme
 * @since 1.0.0
 */

// Prevent direct access
if (!defined('ABSPATH')) {
    exit;
}

/**
 * Enqueue parent and child theme stylesheets
 */
function my_child_theme_enqueue_styles() {
    // Parent theme
    wp_enqueue_style(
        'parent-style',
        get_template_directory_uri() . '/style.css',
        array(),
        wp_get_theme('twentytwentyfour')->get('Version')
    );

    // Child theme
    wp_enqueue_style(
        'child-style',
        get_stylesheet_uri(),
        array('parent-style'),
        wp_get_theme()->get('Version')
    );

    // Google Fonts
    wp_enqueue_style(
        'google-fonts',
        'https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap',
        array(),
        null
    );
}
add_action('wp_enqueue_scripts', 'my_child_theme_enqueue_styles');

/**
 * Register custom navigation menus
 */
function my_child_theme_register_menus() {
    register_nav_menus(array(
        'primary' => __('Primary Menu', 'my-child-theme'),
        'footer'  => __('Footer Menu', 'my-child-theme'),
        'mobile'  => __('Mobile Menu', 'my-child-theme'),
    ));
}
add_action('after_setup_theme', 'my_child_theme_register_menus');

/**
 * Add theme support for various features
 */
function my_child_theme_setup() {
    // Add custom logo support
    add_theme_support('custom-logo', array(
        'height'      => 100,
        'width'       => 400,
        'flex-height' => true,
        'flex-width'  => true,
    ));

    // Add custom background
    add_theme_support('custom-background');

    // Add HTML5 support
    add_theme_support('html5', array(
        'search-form',
        'comment-form',
        'comment-list',
        'gallery',
        'caption',
    ));
}
add_action('after_setup_theme', 'my_child_theme_setup');

/**
 * Register widget areas
 */
function my_child_theme_widgets_init() {
    register_sidebar(array(
        'name'          => __('Sidebar', 'my-child-theme'),
        'id'            => 'sidebar-1',
        'description'   => __('Add widgets here to appear in your sidebar.', 'my-child-theme'),
        'before_widget' => '<section id="%1$s" class="widget %2$s">',
        'after_widget'  => '</section>',
        'before_title'  => '<h2 class="widget-title">',
        'after_title'   => '</h2>',
    ));
}
add_action('widgets_init', 'my_child_theme_widgets_init');

/**
 * Custom excerpt length
 */
function my_child_theme_excerpt_length($length) {
    return 25;
}
add_filter('excerpt_length', 'my_child_theme_excerpt_length', 999);

/**
 * Add custom body classes
 */
function my_child_theme_body_classes($classes) {
    if (is_singular()) {
        $classes[] = 'singular';
    }
    if (is_front_page()) {
        $classes[] = 'front-page';
    }
    return $classes;
}
add_filter('body_class', 'my_child_theme_body_classes');

Prompt per functions.php:

Genera un file functions.php completo per un tema child WordPress 
professionale. Includi:
- Enqueue di parent e child stylesheet
- Registrazione menu di navigazione (primary, footer, mobile)
- Theme support per custom logo, background, HTML5
- Widget areas personalizzate
- Filter per excerpt length
- Custom body classes
- Tutto con proper escaping e security best practices

2.3 Template Personalizzati

Crea template page personalizzati:

<?php
/**
 * Template Name: Landing Page
 * Template Post Type: page
 *
 * Landing page template con sezioni predefinite
 */

get_header();
?>

<main class="landing-page">
    <!-- Hero Section -->
    <section class="hero-section">
        <div class="container">
            <h1><?php the_title(); ?></h1>
            <div class="hero-content">
                <?php the_content(); ?>
            </div>
        </div>
    </section>

    <!-- Features Section -->
    <section class="features-section">
        <div class="container">
            <?php
            if (have_rows('features')):
                while (have_rows('features')): the_row();
                    ?>
                    <div class="feature">
                        <h3><?php the_sub_field('title'); ?></h3>
                        <p><?php the_sub_field('description'); ?></p>
                    </div>
                    <?php
                endwhile;
            endif;
            ?>
        </div>
    </section>

    <!-- CTA Section -->
    <section class="cta-section">
        <div class="container">
            <h2>Pronto a iniziare?</h2>
            <a href="/contatti" class="btn btn-primary">Contattaci</a>
        </div>
    </section>
</main>

<?php
get_footer();

🔌 Fase 3: Sviluppare un Plugin Custom con AI

3.1 Struttura del Plugin

<?php
/**
 * Plugin Name:       My Custom Plugin
n * Plugin URI:        https://www.mrtux.it/my-custom-plugin
 * Description:       Plugin custom per funzionalità avanzate WordPress
 * Version:           1.0.0
 * Author:            Emilio Petrozzi
 * Author URI:        https://www.mrtux.it
 * License:           GPL-2.0+
 * License URI:       http://www.gnu.org/licenses/gpl-2.0.txt
 * Text Domain:       my-custom-plugin
 * Domain Path:       /languages
 */

// Prevent direct access
if (!defined('ABSPATH')) {
    exit;
}

// Define plugin constants
define('MY_PLUGIN_VERSION', '1.0.0');
define('MY_PLUGIN_PATH', plugin_dir_path(__FILE__));
define('MY_PLUGIN_URL', plugin_dir_url(__FILE__));

/**
 * Main plugin class
 */
class My_Custom_Plugin {

    private static $instance = null;

    /**
     * Get singleton instance
     */
    public static function get_instance() {
        if (null === self::$instance) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    /**
     * Constructor
     */
    private function __construct() {
        $this->init_hooks();
    }

    /**
     * Initialize hooks
     */
    private function init_hooks() {
        add_action('init', array($this, 'init'));
        add_action('admin_menu', array($this, 'add_admin_menu'));
        add_action('admin_enqueue_scripts', array($this, 'enqueue_admin_assets'));
        add_action('wp_ajax_my_plugin_action', array($this, 'handle_ajax_action'));
        add_shortcode('my_custom_shortcode', array($this, 'render_shortcode'));
    }

    /**
     * Initialize plugin components
     */
    public function init() {
        load_plugin_textdomain('my-custom-plugin', false, dirname(plugin_basename(__FILE__)) . '/languages');
    }

    /**
     * Add admin menu
     */
    public function add_admin_menu() {
        add_menu_page(
            __('My Plugin', 'my-custom-plugin'),
            __('My Plugin', 'my-custom-plugin'),
            'manage_options',
            'my-plugin',
            array($this, 'render_admin_page'),
            'dashicons-admin-generic',
            30
        );
    }

    /**
     * Render admin page
     */
    public function render_admin_page() {
        ?>
        <div class="wrap">
            <h1><?php echo esc_html(get_admin_page_title()); ?></h1>
            <form method="post" action="options.php">
                <?php
                settings_fields('my_plugin_options');
                do_settings_sections('my-plugin');
                submit_button();
                ?>
            </form>
        </div>
        <?php
    }

    /**
     * Enqueue admin assets
     */
    public function enqueue_admin_assets($hook) {
        if ('toplevel_page_my-plugin' !== $hook) {
            return;
        }

        wp_enqueue_style(
            'my-plugin-admin',
            MY_PLUGIN_URL . 'assets/css/admin.css',
            array(),
            MY_PLUGIN_VERSION
        );

        wp_enqueue_script(
            'my-plugin-admin',
            MY_PLUGIN_URL . 'assets/js/admin.js',
            array('jquery'),
            MY_PLUGIN_VERSION,
            true
        );

        wp_localize_script('my-plugin-admin', 'myPluginData', array(
            'ajaxUrl' => admin_url('admin-ajax.php'),
            'nonce'   => wp_create_nonce('my_plugin_nonce'),
        ));
    }

    /**
     * Handle AJAX action
     */
    public function handle_ajax_action() {
        check_ajax_referer('my_plugin_nonce', 'nonce');

        if (!current_user_can('manage_options')) {
            wp_send_json_error('Unauthorized');
        }

        // Process action
        $result = $this->process_action();

        if ($result) {
            wp_send_json_success('Action completed successfully');
        } else {
            wp_send_json_error('Action failed');
        }
    }

    /**
     * Render shortcode
     */
    public function render_shortcode($atts) {
        $atts = shortcode_atts(array(
            'title' => 'Default Title',
            'color' => 'blue',
        ), $atts, 'my_custom_shortcode');

        ob_start();
        ?>
        <div class="my-custom-shortcode" style="color: <?php echo esc_attr($atts['color']); ?>">
            <h3><?php echo esc_html($atts['title']); ?></h3>
        </div>
        <?php
        return ob_get_clean();
    }

    /**
     * Process action (placeholder)
     */
    private function process_action() {
        // Implement your logic here
        return true;
    }
}

// Initialize plugin
function my_custom_plugin_init() {
    return My_Custom_Plugin::get_instance();
}
add_action('plugins_loaded', 'my_custom_plugin_init');

/**
 * Activation hook
 */
function my_custom_plugin_activate() {
    // Create database tables if needed
    // Set default options
    flush_rewrite_rules();
}
register_activation_hook(__FILE__, 'my_custom_plugin_activate');

/**
 * Deactivation hook
 */
function my_custom_plugin_deactivate() {
    flush_rewrite_rules();
}
register_deactivation_hook(__FILE__, 'my_custom_plugin_deactivate');

Prompt per generare plugin:

Genera un plugin WordPress completo e professionale con:
- Struttura OOP con singleton pattern
- Hook per init, admin_menu, AJAX, shortcode
- Security: nonce verification, capability checks, escaping
- Admin page con settings
- AJAX handler per azioni asincrone
- Shortcode personalizzabile
- Activation/deactivation hooks
- Text domain per traduzioni
- Tutto conforme agli WordPress Coding Standards

3.2 Custom Post Types e Taxonomies

<?php
/**
 * Register custom post types and taxonomies
 */

function my_plugin_register_post_types() {
    // Portfolio CPT
    register_post_type('portfolio', array(
        'labels' => array(
            'name' => __('Portfolio', 'my-custom-plugin'),
            'singular_name' => __('Portfolio Item', 'my-custom-plugin'),
            'add_new' => __('Add New', 'my-custom-plugin'),
            'add_new_item' => __('Add New Portfolio Item', 'my-custom-plugin'),
            'edit_item' => __('Edit Portfolio Item', 'my-custom-plugin'),
            'new_item' => __('New Portfolio Item', 'my-custom-plugin'),
            'view_item' => __('View Portfolio Item', 'my-custom-plugin'),
            'search_items' => __('Search Portfolio', 'my-custom-plugin'),
            'not_found' => __('No portfolio items found', 'my-custom-plugin'),
            'not_found_in_trash' => __('No portfolio items found in trash', 'my-custom-plugin'),
        ),
        'public' => true,
        'has_archive' => true,
        'menu_icon' => 'dashicons-portfolio',
        'supports' => array('title', 'editor', 'thumbnail', 'excerpt', 'custom-fields'),
        'show_in_rest' => true, // Enable Gutenberg
        'rewrite' => array('slug' => 'portfolio'),
    ));

    // Portfolio Category Taxonomy
    register_taxonomy('portfolio_category', 'portfolio', array(
        'labels' => array(
            'name' => __('Categories', 'my-custom-plugin'),
            'singular_name' => __('Category', 'my-custom-plugin'),
            'search_items' => __('Search Categories', 'my-custom-plugin'),
            'all_items' => __('All Categories', 'my-custom-plugin'),
            'edit_item' => __('Edit Category', 'my-custom-plugin'),
            'update_item' => __('Update Category', 'my-custom-plugin'),
            'add_new_item' => __('Add New Category', 'my-custom-plugin'),
        ),
        'hierarchical' => true,
        'show_in_rest' => true,
        'rewrite' => array('slug' => 'portfolio-category'),
    ));
}
add_action('init', 'my_plugin_register_post_types');

🧪 Fase 4: Testing e Debugging con AI

4.1 Prompt per Code Review

Analizza questo codice WordPress e identifica:
1. Problemi di sicurezza (SQL injection, XSS, CSRF)
2. Violazioni WordPress Coding Standards
3. Performance issues (query non ottimizzate, loop inefficienti)
4. Best practices mancanti (escaping, sanitization, validation)
5. Suggerimenti per migliorare la struttura

[Incolla il tuo codice qui]

4.2 Prompt per Debugging

Ho questo errore WordPress: [Incolla errore]

Contesto:
- WordPress version: 6.4
- PHP version: 8.2
- Plugin/Tema: [Nome]

Cosa ho già provato:
1. [Tentativo 1]
2. [Tentativo 2]

Analizza l'errore e fornisci:
1. Diagnosi della causa radice
2. Soluzione step-by-step
3. Codice corretto
4. Come prevenire in futuro

4.3 Test Unitari con AI

<?php
/**
 * Example PHPUnit test for plugin
 */

class MyPluginTest extends WP_UnitTestCase {

    public function test_shortcode_returns_html() {
        $output = do_shortcode('[my_custom_shortcode title="Test"]');

        $this->assertStringContainsString('Test', $output);
        $this->assertStringContainsString('my-custom-shortcode', $output);
    }

    public function test_ajax_requires_nonce() {
        $_POST['nonce'] = '';

        $this->expectException(WPDieException::class);

        // Call AJAX handler
        my_plugin_ajax_handler();
    }

    public function test_user_capability_check() {
        wp_set_current_user(0); // No user

        $this->assertFalse(current_user_can('manage_options'));
    }
}

🚀 Fase 5: Deploy e Automazione

5.1 Script di Deploy con WP-CLI

#!/bin/bash
# deploy.sh - Deploy automatico tema/plugin

set -e

# Configurazione
REMOTE_USER="myweb"
REMOTE_HOST="192.5.123.123"
REMOTE_PATH="/home/user/web/site.it/public_html"
SSH_KEY="~/.ssh/wp_publisher"

# Colori per output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

echo -e "${GREEN}🚀 Starting WordPress deployment...${NC}"

# 1. Backup pre-deploy
echo -e "${YELLOW}📦 Creating backup...${NC}"
ssh -i $SSH_KEY $REMOTE_USER@$REMOTE_HOST \
    "wp db export /tmp/backup-$(date +%Y%m%d-%H%M%S).sql --path=$REMOTE_PATH"

# 2. Sync files
if [ "$1" == "theme" ]; then
    echo -e "${YELLOW}📁 Syncing theme files...${NC}"
    rsync -avz -e "ssh -i $SSH_KEY" \
        wp-content/themes/my-child-theme/ \
        $REMOTE_USER@$REMOTE_HOST:$REMOTE_PATH/wp-content/themes/my-child-theme/
elif [ "$1" == "plugin" ]; then
    echo -e "${YELLOW}📁 Syncing plugin files...${NC}"
    rsync -avz -e "ssh -i $SSH_KEY" \
        wp-content/plugins/my-custom-plugin/ \
        $REMOTE_USER@$REMOTE_HOST:$REMOTE_PATH/wp-content/plugins/my-custom-plugin/
fi

# 3. Clear cache
echo -e "${YELLOW}🧹 Clearing cache...${NC}"
ssh -i $SSH_KEY $REMOTE_USER@$REMOTE_HOST \
    "wp cache flush --path=$REMOTE_PATH"

# 4. Verify deployment
echo -e "${YELLOW}✅ Verifying deployment...${NC}"
ssh -i $SSH_KEY $REMOTE_USER@$REMOTE_HOST \
    "wp core version --path=$REMOTE_PATH"

echo -e "${GREEN}✨ Deployment completed successfully!${NC}"

5.2 GitHub Actions per CI/CD

# .github/workflows/deploy.yml
name: Deploy WordPress

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3

    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: '8.2'
        tools: wp-cli

    - name: Run tests
      run: |
        composer install
        vendor/bin/phpunit

    - name: Deploy to server
      uses: easingthemes/ssh-deploy@v3
      with:
        SSH_PRIVATE_KEY: ${{ secrets.SSH_KEY }}
        REMOTE_HOST: ${{ secrets.REMOTE_HOST }}
        REMOTE_USER: ${{ secrets.REMOTE_USER }}
        SOURCE: "wp-content/"
        TARGET: "/home/myweb/web/mrtux.it/public_html/wp-content/"
        EXCLUDE: "/.git/,/node_modules/"

    - name: Clear cache
      run: |
        ssh -i ${{ secrets.SSH_KEY }} \
          ${{ secrets.REMOTE_USER }}@${{ secrets.REMOTE_HOST }} \
          "wp cache flush --path=/home/user/web/site.it/public_html"

📊 Tabella Comparativa: Sviluppo Tradizionale vs AI-Assisted

✅ Checklist Finale

Prima del Deploy

• [ ] Code review con AI completata
• [ ] Tutti i test PHPUnit passano
• [ ] Security scan eseguito (nessuna vulnerabilità)
• [ ] Performance test (PageSpeed > 90)
• [ ] Backup database creato
• [ ] Staging environment testato
• [ ] Documentazione aggiornata

Dopo il Deploy

• [ ] Verifica funzionalità su produzione
• [ ] Monitoraggio errori (24h)
• [ ] Cache cleared
• [ ] Analytics verificati
• [ ] Client notification inviata

🎯 50+ Prompt AI per Sviluppo WordPress

Setup e Architettura

1. "Genera la struttura directory per un progetto WordPress enterprise"
2. "Crea un file composer.json ottimizzato per sviluppo WordPress"
3. "Genera configurazione Docker per ambiente WordPress locale"

Temi Child

4. "Scrivi style.css per tema child con branding personalizzato"
5. "Genera functions.php con enqueue, menus, e widget areas"
6. "Crea template page personalizzato per landing page"
7. "Genera custom post types per portfolio con taxonomy"

Plugin Development

8. "Crea plugin boilerplate con OOP e singleton pattern"
9. "Genera admin settings page con validation"
10. "Scrivi AJAX handler con nonce verification"
11. "Crea shortcode con attributi personalizzati"
12. "Genera custom REST API endpoint"

Security

13. "Analizza questo codice per vulnerabilità XSS"
14. "Verifica SQL injection risks in questa query"
15. "Controlla CSRF protection in questo form"
16. "Genera funzione di sanitizzazione per input utente"

Performance

17. "Ottimizza questa query WordPress lenta"
18. "Genera funzione di caching per dati frequenti"
19. "Analizza performance di questo tema"
20. "Suggerisci ottimizzazioni per Core Web Vitals"

Debugging

21. "Debugga questo errore: [incolla errore]"
22. "Spiega perché questo hook non funziona"
23. "Trova il bug in questo codice: [incolla codice]"
24. "Perché il mio plugin causa white screen?"

Testing

25. "Genera PHPUnit test per questa funzione"
26. "Crea test per AJAX handler"
27. "Scrivi integration test per custom post type"
28. "Genera test di sicurezza per form"

SEO e Accessibility

29. "Genera meta tags SEO per questa page template"
30. "Crea schema.org markup per articolo"
31. "Verifica accessibility WCAG 2.1 di questo tema"
32. "Genera sitemap XML custom"

E-commerce (WooCommerce)

33. "Crea custom product type per WooCommerce"
34. "Genera hook per modificare checkout"
35. "Scrivi funzione per custom shipping method"
36. "Crea email template personalizzata"

Multisite

37. "Configura WordPress multisite con AI"
38. "Genera plugin network-activated"
39. "Crea custom user role per multisite"
40. "Scrivi funzione per sync settings across sites"

Migration e Deploy

41. "Genera script di migrazione database"
42. "Crea workflow GitHub Actions per deploy"
43. "Scrivi script di rollback automatico"
44. "Genera configurazione per staging environment"

Documentation

45. "Genera README.md professionale per plugin"
46. "Crea documentazione API con OpenAPI spec"
47. "Scrivi changelog automatico da git commits"
48. "Genera user guide per admin panel"

Advanced

49. "Crea integrazione con API esterna (es. Stripe)"
50. "Genera sistema di licensing per plugin premium"
51. "Scrivi updater automatico per plugin"
52. "Crea dashboard analytics custom"

📚 Risorse Consigliate

Documentazione Ufficiale

• WordPress Developer Handbook
• WordPress Coding Standards
• Plugin Developer Handbook

Strumenti AI

• Cursor IDE - Editor AI-first
• Claude.ai - Code generation avanzata
• GitHub Copilot - Autocomplete
• WP-CLI - Automazione WordPress

Community

• WordPress Stack Exchange
• r/WordPress
• Advanced WordPress Facebook Group

🎓 Conclusione

Lo sviluppo WordPress con l'AI non è il futuro—è il presente. Gli strumenti che ho mostrato in questa guida ti permettono di:

✅ Risparmiare l'89% del tempo di sviluppo
✅ Mantenere standard di qualità professionali
✅ Ridurre bug e vulnerabilità con code review AI
✅ Scalare la tua produttività senza compromessi

Il mio consiglio: Inizia con un progetto piccolo (tema child semplice), familiarizza con i prompt, e scala gradualmente verso plugin complessi.

La chiave non è sostituire le tue competenze—è amplificarle. 🚀

Hai trovato utile questa guida? Condividi i tuoi risultati o fai domande nei commenti! 👇

Emilio Petrozzi
Sviluppatore WordPress & AI Enthusiast
www.mrtux.it

In questo tutorial esamineremo WP-CLI, lo strumento di gestione di WordPress basato sulla riga di comando. Se stai cercando di semplificare il modo in cui gestisci il tuo sito WordPress WP-CLI è la soluzione perfetta per te. Con WP-CLI puoi automatizzare le operazioni comuni di WordPress, risparmiando tempo e complicazioni varie. Vedremo come installare WP-CLI, esploreremo i comandi principali e forniremo alcuni esempi pratici che ti aiuteranno ad approfondire la gestione del tuo sito WordPress. Quindi preparati a scoprire il potenziale di WP-CLI e migliorare la tua esperienza di gestione di WordPress.

Cosa è WP-CLI?

WP-CLI è uno strumento di linea di comando open source che consente di gestire un sito WordPress senza dover utilizzare l'interfaccia utente tradizionale del pannello di amministrazione. Con WP-CLI  puoi eseguire una vasta gamma di operazioni, come l'installazione di temi e plugin, la gestione dei contenuti, il backup e il ripristino del database e molto altro ancora, tutto direttamente dalla riga di comando.

Installazione di WP-CLI

Prima di iniziare ad utilizzare WP-CLI è necessario installarlo sul tuo sistema. Segui questi passaggi per installare WP-CLI:

1. Apri il tuo terminale o prompt dei comandi.
2. Verifica di avere già installato PHP sul tuo sistema.
3. Utilizza il seguente comando per scaricare l'archivio di WP-CLI:

   curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar
   

4. Verifica l'integrità dell'archivio scaricato utilizzando il comando:

   php -r "if (hash_file('sha512', 'wp-cli.phar') === 'aa31b17e1d7d4eaf63dbf56c74b72cd46ce6ab5d2912c60e2c3f71b62459e06807bf60ef660cdaa3df9e4debb3d61befb794d669f1b8d7a9d4fddb042bbc2a8') { echo 'WP-CLI Phar integrity verified.' . PHP_EOL; } else { echo 'Phar integrity check failed. Please try downloading WP-CLI again.' . PHP_EOL; }"
   

5. Rinomina il file scaricato in wp-cli.phar con il comando:

   mv wp-cli.phar wp-cli
   

6. Sposta il file wp-cli in una directory inclusa nel tuo PATH di sistema per renderlo eseguibile globalmente. Ad esempio, puoi utilizzare il seguente comando per spostarlo nella directory `/usr/local/bin/:

   sudo mv wp-cli /usr/local/bin/
   

7. Verifica l'installazione eseguendo il comando:

   wp --info
   

   Se tutto è stato configurato correttamente, dovresti visualizzare le informazioni di WP-CLI, inclusa la versione installata.

Utilizzo di WP-CLI

Una volta installato WP-CLI, puoi iniziare a utilizzarlo per gestire il tuo sito WordPress direttamente dalla riga di comando. Ecco alcuni dei comandi più comuni che ti saranno utili:

1. Installazione di WordPress

Puoi utilizzare WP-CLI per installare una nuova istanza di WordPress sul tuo server con pochi comandi. Ad esempio, per installare WordPress con un database specifico, puoi utilizzare il seguente comando:

wp core install --url=nome-sito.com --title=Titolo-sito --admin_user=admin --admin_password=password --admin_email=admin@nome-sito.com

Assicurati di sostituire nome-sito.com con il tuo URL effettivo, Titolo-sito con il titolo desiderato per il tuo sito, admin con il nome utente desiderato per l'account amministratore, password con la password desiderata per l'account amministratore e admin@nome-sito.com con l'indirizzo email dell'amministratore.

2. Installazione di temi e plugin

Con WP-CLI, puoi installare e gestire temi e plugin direttamente dalla riga di comando. Ecco alcuni esempi:

• Per installare un tema:

  wp theme install nome-tema
  

• Per attivare un tema:

  wp theme activate nome-tema
  

• Per installare un plugin:

  wp plugin install nome-plugin
  

• Per attivare un plugin:

  wp plugin activate nome-plugin
  

3. Gestione dei contenuti

WP-CLI ti consente di gestire i contenuti del tuo sito WordPress in modo efficiente. Puoi creare nuovi articoli, pagine, categorie e molto altro ancora utilizzando i seguenti comandi:

• Per creare un nuovo articolo:

  wp post create --post_type=post --post_title='Titolo-articolo' --post_content='Contenuto-articolo' --post_status=publish
  

• Per creare una nuova pagina:

  wp post create --post_type=page --post_title='Titolo-pagina' --post_content='Contenuto-pagina' --post_status=publish
  

• Per creare una nuova categoria:

  wp term create category 'Nome-categoria'
  

• Per assegnare una categoria a un articolo:

  wp post term set ID-articolo category 'Nome-categoria'
  

4. Backup e ripristino del database

Con WP-CLI, puoi eseguire facilmente il backup del tuo database WordPress e ripristinarlo se necessario. Ecco come farlo:

• Per eseguire il backup del database:

  wp db export nome-file.sql
  

• Per ripristinare il database da un file di backup:

  wp db import nome-file.sql
  

Questi sono solo alcuni degli esempi di comandi che puoi utilizzare con WP-CLI. Esplora la documentazione ufficiale di WPCLI per scoprire ulteriori comandi e funzionalità avanzate che possono semplificare ulteriormente la gestione del tuo sito WordPress.

Domande frequenti su WP-CLI

1. Cos'è WP-CLI e perché dovrei usarlo?

WP-CLI è uno strumento di linea di comando per la gestione di WordPress. È estremamente utile per gli sviluppatori e gli amministratori di siti WordPress poiché consente di automatizzare operazioni comuni, risparmiando tempo e sforzo. Con WP-CLI puoi eseguire task come l'installazione di temi e plugin, la gestione dei contenuti e il backup del database, tutto senza dover utilizzare l'interfaccia utente tradizionale del pannello di amministrazione.

2. Come posso installare WP-CLI sul mio sistema?

L'installazione di WP-CLI è semplice. Devi assicurarti di avere PHP installato sul tuo sistema e seguire i passaggi di installazione che abbiamo descritto in precedenza. Una volta completata l'installazione, potrai utilizzare WP-CLI direttamente dalla riga di comando.

3. Quali sono alcuni comandi comuni di WP-CLI che dovrei conoscere?

Ci sono numerosi comandi utili che puoi utilizzare con WP-CLI. Alcuni esempi includono l'installazione di WordPress, l'installazione e l'attivazione di temi e plugin, la gestione dei contenuti e il backup del database. Nel nostro tutorial, abbiamo fornito alcuni esempi di comandi per aiutarti a iniziare, ma ti consigliamo di esplorare la documentazione ufficiale di WP-CLI per scoprire ulteriori comandi e funzionalità.

4. WP-CLI è adatto anche ai principianti o è più adatto agli sviluppatori esperti?

WP-CLI può essere utilizzato sia dai principianti che dagli sviluppatori esperti. Anche se alcune funzionalità più avanzate richiedono una conoscenza più approfondita di WordPress e della riga di comando, ci sono molti comandi di base che possono essere facilmente utilizzati dai principianti per semplificare la gestione del loro sito. Con un po' di pratica, anche i principianti possono trarre vantaggio dall'utilizzo di WP-CLI per automatizzare operazioni comuni e risparmiare tempo.

5. WP-CLI è compatibile con tutti i provider di hosting?

Sì, WP-CLI è compatibile con la maggior parte dei provider di hosting che supportano WordPress. Tuttavia, potrebbero esserci alcune limitazioni o restrizioni imposte dai provider di hosting specifici. Assicurati di verificare con il tuo provider di hosting se supportano WP-CLI e se ci sono eventuali requisiti o configurazioni aggiuntive da seguire per utilizzarlo correttamente.

6. Posso utilizzare WP-CLI anche per siti WordPress multisito?

Assolutamente! WP-CLI supporta la gestione di siti WordPress multisito. Puoi utilizzare comandi specifici per operare su siti individuali all'interno della tua installazione multisito, consentendoti di gestire in modo efficiente l'intera rete di siti WordPress.

Conclusioni

WP-CLI è unostrumento potente che semplifica notevolmente la gestione di WordPress direttamente dalla riga di comando. Nel nostro tutorial, abbiamo esaminato l'installazione di WP-CLI, i comandi principali e fornito esempi pratici per aiutarti a iniziare. Ricorda che WP-CLI può automatizzare molte operazioni comuni, consentendoti di risparmiare tempo prezioso nella gestione del tuo sito WordPress.

Utilizzando WP-CLI, puoi installare temi e plugin, gestire i contenuti, eseguire backup del database e molto altro ancora, tutto attraverso comandi semplici e intuitivi. Con un po' di pratica e familiarità con i comandi di WP-CLI, potrai ottimizzare e semplificare ulteriormente la gestione del tuo sito WordPress.

Spero che questo tutorial ti abbia fornito una base di conoscenza su WP-CLI che ti consenta di sfruttare i vantaggi nell'utilizzo di questo strumento nella tua esperienza con WordPress. Esplora ulteriormente i comandi e le funzionalità di WP-CLI per scoprire come puoi personalizzare e automatizzare la gestione del tuo sito web.

Risorse esterne utili:

• Documentazione ufficiale di WP-CLI: link
• WP-CLI su GitHub: link