Quando si tratta di sviluppare temi WordPress con un agente AI come OpenCode, l'ambiente di lavoro fa la differenza tra un flusso fluido e una sequela di intoppi. Un server LAMP locale — Linux, Apache, MySQL, PHP — ti dà il controllo completo senza dipendere da connessioni remote durante la generazione del codice. È il setup che i developer WordPress professionisti usano da anni, e che si integra naturalmente con strumenti come OpenCode.

Se lavori già con AI e WordPress, sai che il grosso del tempo non sta nel scrivere codice, ma nel configurare l'ambiente, gestire le dipendenze e tenere il ambiente di staging allineato con la produzione. Per questo motivo, prima di entrare nei dettagli su OpenCode e i server MCP, partiamo dalla base: come montare un ambiente LAMP solido su Ubuntu o tramite Docker.

Per chi arriva da un approccio più visuale e vuole capire come l'AI si inserisce nel workflow WordPress, abbiamo analizzato nel dettaglio l'approccio con Novamira.ai per il web design WordPress, che condivide molti principi di integrazione con agenti AI che applicheremo qui.

Perché un ambiente LAMP locale per WordPress theme development

Un ambiente LAMP locale ti dà un'istanza WordPress completa — database MySQL, PHP engine, web server Apache — tutto sul tuo机器. Non servono upload FTP, non c'è latenza di rete, non dipendi da un hosting provider. OpenCode può leggere e scrivere file direttamente sul filesystem, interrogare il database, attivare e disattivare plugin via WP-CLI, il tutto senza uscire dal tuo terminale.

I vantaggi concreti:

• Velocità: nessuna round-trip verso un server remoto. OpenCode legge style.css o theme.json in millisecondi.
• Sicurezza: esperimenti e refactoring restano in locale finché non decidi tu cosa promuovere in staging.
• Riproducibilità: Docker Compose o Lando ti permettono di ricostruire l'ambiente identico su qualsiasi机器.
• WP-CLI nativo: puoi lanciare comandi WordPress da terminale senza passare per l'interfaccia admin.

Ubuntu: installazione manuale LAMP

Su Ubuntu 22.04 o 24.04, un setup LAMP completo per WordPress si installa in pochi passaggi. Il vantaggio rispetto a soluzioni pre-confezionate è che hai il pieno controllo delle versioni di PHP e MySQL.

# Installazione pacchetti Apache, MySQL e PHP
sudo apt update && sudo apt install -y apache2 mysql-server php8.2 \
  php8.2-mysql php8.2-cli php8.2-curl php8.2-gd php8.2-mbstring \
  php8.2-xml php8.2-zip php8.2-bcmath php8.2-intl

# Abilitare mod Apache necessari
sudo a2enmod rewrite headers ssl

# Avviare Apache e MySQL
sudo systemctl enable --now apache2 mysql

# Proteggere installazione MySQL (password root)
sudo mysql_secure_installation

Dopo l'installazione, crea il database WordPress. Il comando MySQL seguente imposta tutto in una volta:

-- Creazione database e utente per WordPress locale
CREATE DATABASE wordpress_dev CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'wpuser'@'localhost' IDENTIFIED BY 'wppassword';
GRANT ALL PRIVILEGES ON wordpress_dev.* TO 'wpuser'@'localhost';
FLUSH PRIVILEGES;

A questo punto scarica WordPress e puntando il browser su http://localhost partirà l'installazione guidata classica. Per un workflow più rapido con OpenCode, usa WP-CLI:

# Download e configurazione WordPress via WP-CLI
wp core download --locale=it_IT
wp config create --dbname=wordpress_dev --dbuser=wpuser --dbpass=wppassword
wp core install --url="http://localhost" --title="Sviluppo WP" --admin_user=admin --admin_password=admin --admin_email=dev@local.it

La combinazione Ubuntu LAMP + WP-CLI ti dà un ambiente dove OpenCode può operare con i server MCP descritti più avanti. Per chi preferisce un setup pre-configurato con staging automatico, consulta la nostra guida agli strumenti essenziali per il web design WordPress che include configurazioni LAMP alternative.

Docker: ambiente LAMP containerizzato

Se preferisci la containerizzazione, Docker elimina la necessità di installare pacchetti nativi e garantisce portabilità. Il file docker-compose.yml seguente definisce un ambiente LAMP completo per WordPress theme development:

# docker-compose.yml per WordPress theme dev con LAMP
version: '3.9'
services:
  wordpress:
    image: wordpress:6.6-php8.2-apache
    container_name: wp_theme_dev
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_NAME: wp_theme
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: wppassword
    volumes:
      - ./wp-content:/var/www/html/wp-content
      - ./uploads.ini:/usr/local/etc/php/conf.d/uploads.ini
    depends_on:
      db:
        condition: service_healthy

  db:
    image: mysql:8.0
    container_name: wp_theme_db
    environment:
      MYSQL_DATABASE: wp_theme
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: wppassword
      MYSQL_ROOT_PASSWORD: rootpassword
    volumes:
      - db_data:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      timeout: 10s
      retries: 5

volumes:
  db_data:

Il mount di ./wp-content sul container è strategico: i file del tema che OpenCode genera o modifica sono accessibili sia dal container che dal host, senza bisogno di rsync o FTP. Lancia l'ambiente con:

# Avvio ambiente Docker LAMP per WordPress
docker compose up -d

# Verifica che WordPress risponda
curl -s -o /dev/null -w "%{http_code}" http://localhost:8080

Questa configurazione è identica per tutti i membri del team: chiunque abbia Docker installato può replicare l'ambiente con un singolo comando.

Configurazione e ottimizzazione di AGENTS.md per WordPress

Il file AGENTS.md nel workspace di OpenClaw è il cuore della configurazione dell'agente AI. Per lo sviluppo WordPress, una configurazione mirata rende OpenCode significativamente più efficace: invece di generare codice generico, rispetta le convenzioni del progetto, conosce la struttura del tema, sa quali plugin sono attivi.

Struttura base di AGENTS.md ottimizzato per WordPress

Una configurazione AGENTS.md efficace per WordPress theme development contiene alcune sezioni chiave. La prima è il context del progetto:

# AGENTS.md — WordPress Theme Development

## Progetto
- Tipo: Tema WordPress custom (child theme / block theme / classic)
- CMS: WordPress 6.4+ con PHP 8.2
- Theme slug: __THEME_SLUG__
- Text domain: __TEXT_DOMAIN__
- Plugin previsti: Rank Math SEO, Contact Form 7, WooCommerce (se ecommerce)

## Struttura tema attesa

mytheme/
├── style.css              # Header + CSS principale
├── functions.php          # Setup, hook, enqueue
├── theme.json              # Full Site Editing (se block theme)
├── index.php               # Fallback template
├── header.php              # Head + header markup
├── footer.php              # Footer + script closing
├── front-page.php          # Homepage
├── singular.php            # Single post / page
├── archive.php             # Archivio post
├── search.php              # Risultati ricerca
├── 404.php                 # Pagina errore
├── screenshot.png          # 880x660px
├── assets/
│   ├── css/style.css
│   ├── js/main.js
│   └── images/
└── parts/
    ├── navbar.php
    ├── loop.php
    └── footer-content.php

Questa struttura rispecchia lo standard WordPress e permette a OpenCode disap dove collocare ogni file generato.

Regole e vincoli per il codice WordPress

AGENTS.md deve includere anche i vincoli tecnici che OpenCode deve rispettare. Questo evita che generi codice incompatibile con il resto dell'installazione:

## Vincoli tecnici WordPress

### PHP
- Sempre <?php opening tag, mai <? short open tag
- Sempre if ( ! defined( 'ABSPATH' ) ) exit; all'inizio di ogni file
- Prefix tutte le funzioni con lo slug del tema: mytheme_enqueue_assets()
- Non usare funzioni deprecate (cerca WP_DEPRECATED in documentazione)

### CSS
- BEM naming convention: .mytheme-block__element--modifier
- Mobile-first responsive: @media (min-width: 768px) breakpoint tablet
- Nessun !important se non strettamente necessario e commentato
- Variabili CSS per colori e spacing: --mytheme-color-primary

### Hook WordPress
- Priorità standard 10, specificare se diversa
- Usare __return_false / __return_true per filtri booleani
- I hook personalizzati del tema: do_action( 'mytheme_before_header' )

### Sicurezza output
- Tutti gli output HTML: esc_html(), esc_attr(), esc_url()
- Tutti gli output JS: wp_json_encode() + esc_html()
- Tutti gli input utente: sanitize_text_field(), intval(), absint()
- Non usare mai eval() né extract() con input non validato

### theme.json (block theme)
- Versione schema: "2" per WordPress 6.1+
- Colori custom: usare sempre slug minuscolo con trattino
- Tipografia: unità px o rem, mai em per scale fix

Prompt e comandi personalizzati

Una sezione spesso trascurata è quella dei comandi rapidi che accelerano il workflow con OpenCode. Definirli in AGENTS.md significa non doverli riscrivere ogni volta:

## Comandi rapidi WordPress (usare con OpenCode)

### Scaffolding
/create-theme name=mytheme type=classic|block|child parent=twentytwentyfour
/generate-template-part name=newsletter-bar location=footer
/add-block-pattern category=hero name=hero-home title="Hero Homepage"

### Debug locale
/wp-cli db export  # esporta database locale
/wp-cli theme list # lista temi installati con status
/wp-cli post list --post_type=page --fields=ID,post_title,post_status

### Hook utility
/show-hooks         # mostra tutti i filtri e azioni registrati
/list-sidebars      # elenca sidebars registrati con ID e descrizione
/check-theme-deps   # verifica dipendenze plugin del tema

Aggiornare AGENTS.md con la configurazione WordPress specifica del progetto è un investimento iniziale che si ripaga in ogni sessione successiva. OpenCode avrà il contesto necessario per generare codice coerente con la struttura esistente, rispettando le convenzioni definite, senza doverle ripetere nei prompt.

Server MCP essenziali per lo sviluppo WordPress con OpenCode

Il protocollo MCP (Model Context Protocol) è il layer che permette a OpenCode di interagire con l'ecosistema WordPress: leggere file del tema, interrogare il database, cercare nella directory WordPress.org, usare WP-CLI. Ogni server MCP copre un'area operativa specifica.

Server MCP Filesystem

Il server MCP Filesystem è probabilmente il più importante per lo sviluppo WordPress. Ti dà accesso completo al filesystem del progetto, permettendo a OpenCode di leggere template esistenti, modificare functions.php, creare nuovi file del tema, e navigare la struttura delle directory.

# Avvio del server MCP filesystem
# Configurazione tipica in openclaw config o .mcp.json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/home/user/wordpress-dev/wp-content/themes",
               "/home/user/wordpress-dev/wp-content/plugins"]
    }
  }
}

Con questo server attivo, OpenCode può navigare la struttura del tema, leggere file esistenti prima di proporne modifiche, e scrivere nuovi file direttamente nella directory del progetto. Il vantaggio rispetto a prompt generici è che il contesto è sempre il codice reale del progetto, non un'astrazione.

Server MCP WordPress.org

Il server MCP WordPress.org permette di cercare nella directory dei plugin e dei temi ufficiali, leggere recensioni, verificare compatibilità e scaricare informazioni su pacchetti specifici. È utile quando si valutano plugin da includere nel tema o quando si vuole verificare che una funzionalità non esista già in un plugin maturo.

# Ricerca plugin WordPress.org via MCP
mcp__wordpress__search_plugins query="seo meta description" per_page=10

# Ottenere dettagli plugin specifico
mcp__wordpress__get_plugin plugin_slug="wordpress-seo"

La ricerca nella directory ufficiale è particolarmente utile per verificare se un plugin copre già una funzionalità che altrimenti implementeresti da zero. Sviluppare funzionalità native quando esiste un plugin maturo è spesso uno spreco di tempo e manutenzione.

Server MCP WordPress Studio / WP-CLI

Il server MCP WordPress Studio espone WP-CLI e l'istanza WordPress completa all'agente AI. Con questo server, OpenCode può eseguire comandi WP-CLI, attivare e disattivare plugin, generare contenuto di test, resettare il database, e gestire aspetti runtime dell'installazione WordPress.

# Comandi WP-CLI accessibili via MCP
mcp__wpcli__run command="theme list --format=table"
mcp__wpcli__run command="plugin list --status=active --format=json"
mcp__wpcli__run command="post create --post_type=page --post_title="Test Page" --post_status=draft"

# Reset database locale (utile tra un test e l'altro)
mcp__wpcli__run command="db reset --yes"

Questo è il server che collega OpenCode al lato runtime di WordPress: non solo il codice statico, ma il comportamento effettivo del CMS con plugin attivi, post esistenti, opzioni configurate.

Server MCP Database

Per operazioni dirette sul database MySQL, il server MCP Database ti dà accesso SQL completo. È meno frequente da usare direttamente, ma diventa essenziale quando servono query di massa, export dati, o verifiche sulla struttura delle tabelle del sito.

-- Verificare struttura tabella postmeta prima di una query personalizzata
DESCRIBE wp_postmeta;

-- Conteggio post per stato (utile dopo un import massiccio)
SELECT post_status, COUNT(*) FROM wp_posts GROUP BY post_status;

-- Verificare opzioni del tema (customizer data)
SELECT option_name, option_value FROM wp_options WHERE option_name LIKE '%mytheme%';

Il rischio di operare direttamente sul database è alto: una query UPDATE o DELETE senza WHERE può distruggere dati. Usa questo server solo quando sai esattamente cosa stai facendo, e sempre su ambiente locale o di staging, mai su produzione.

Workflow pratico: creare un tema WordPress completo da zero con OpenCode

Messe in fila tutte le configurazioni, il workflow reale con OpenCode e WordPress è iterativo. Non si tratta di generare un tema intero in un singolo prompt, ma di costruirlo progressivamente: struttura, template, funzionalità, test, raffinamento.

Step 1 — Brief iniziale e scaffolding

Il prompt iniziale imposta il progetto. Invece di descrivere genericamente "voglio un tema per blog", siamo specifici: funzionalità richieste, plugin da supportare, style guide se esistono, breakpoint responsivi.

# Prompt iniziale per OpenCode
/create-wordpress-theme
  name=mythemeblog
  domain=mythemeblog
  description="Tema blog personale con focus leggibilità"
  features=post-grid,related-posts,dark-mode,cookie-banner,amp
  plugins=rank-math-seo,contact-form-7,wp-optimize
  breakpoints=mobile:375,tablet:768,desktop:1200
  style=groove-retro-light

OpenCode analizza il brief e produce la struttura base: style.css con header completo, functions.php con setup iniziale, theme.json se richiesto per block theme, e i template PHP essenziali.

Step 2 — Configurazione functions.php

Dopo lo scaffolding, il file functions.php va arricchito con le funzionalità specifiche del progetto. OpenCode può generare blocchi mirati per ogni necessità:

<?php
/**
 * MyThemeBlog functions and definitions
 * @link https://developer.wordpress.org/themes/basics/theme-functions/
 */

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

/** === Enqueue Scripts e Styles === */
function mythemeblog_enqueue_assets() {
    // CSS principale del tema
    wp_enqueue_style( 'mythemeblog-style', get_stylesheet_uri(), [], wp_get_theme()->get( 'Version' ) );
    // JavaScript con defer per performance
    wp_enqueue_script( 'mythemeblog-main', get_template_directory_uri() . '/assets/js/main.js', [], '1.0.0', true );
    // Google Fonts (async)
    wp_enqueue_style( 'mythemeblog-fonts', 'https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap [], null );
}
add_action( 'wp_enqueue_scripts', 'mythemeblog_enqueue_assets' );

/** === Theme Support === */
function mythemeblog_setup() {
    add_theme_support( 'title-tag' );
    add_theme_support( 'automatic-feed-links' );
    add_theme_support( 'custom-logo', [
        'height' => 100,
        'width' => 300,
        'flex-height' => true,
        'flex-width'  => true,
    ] );
    add_theme_support( 'post-thumbnails', ['post', 'page'] );
    add_theme_support( 'html5', ['search-form', 'comment-form', 'comment-list', 'gallery', 'caption'] );
    add_theme_support( 'editor-styles' );
    add_theme_support( 'responsive-embeds' );
}
add_action( 'after_setup_theme', 'mythemeblog_setup' );

/** === Register Nav Menus === */
function mythemeblog_menus() {
    register_nav_menus( [
        'primary' => 'Primary Menu',
        'footer'  => 'Footer Menu',
        'mobile'  => 'Mobile Menu',
    ] );
}
add_action( 'init', 'mythemeblog_menus' );

/** === Content Width === */
function mythemeblog_content_width() {
    $GLOBALS['content_width'] = apply_filters( 'mythemeblog_content_width', 1200 );
}
add_action( 'after_setup_theme', 'mythemeblog_content_width', 0 );

Questo snippet è un punto di partenza solido. OpenCode lo genera tenendo conto di theme.json se presente, rispettando le variabili CSS definite nella style guide, e includendo i hook essenziali per WordPress.

Step 3 — Template partials e Loop

Il loop WordPress è il cuore di qualsiasi tema. OpenCode può generare template partials modulari che rispettano la Single Responsibility Principle:

<?php
/**
 * Loop dei post — partial da includere in archive.php o index.php
 * @package MyThemeBlog
 */

if ( have_posts() ) : ?>

    <div class="mythemeblog-grid">
        <?php
        while ( have_posts() ) :
            the_post();
            $category = get_the_category();
            $first_cat = $category ? $category[0]->name : '';
        ?>
            <article id="post-<?php the_ID(); ?>" <?php post_class( 'mythemeblog-card' ); ?>>
                <?php if ( has_post_thumbnail() ) : ?>
                    <div class="mythemeblog-card__thumbnail">
                        <a href="<?php the_permalink(); ?>" aria-hidden="true" tabindex="-1">
                            <?php the_post_thumbnail( 'medium_large', ['loading' => 'lazy'] ); ?>
                        </a>
                    </div>
                <?php endif; ?>

                <div class="mythemeblog-card__content">
                    <?php if ( $first_cat ) : ?>
                        <span class="mythemeblog-card__category">
                            <?php echo esc_html( $first_cat ); ?>
                        </span>
                    <?php endif; ?>

                    <h2 class="mythemeblog-card__title">
                        <a href="<?php the_permalink(); ?>" rel="bookmark">
                            <?php the_title( '<span>', '</span>' ); ?>
                        </a>
                    </h2>

                    <div class="mythemeblog-card__excerpt">
                        <?php echo esc_html( wp_trim_words( get_the_excerpt(), 20, '...' ) ); ?>
                    </div>

                    <time class="mythemeblog-card__date" datetime="<?php echo esc_attr( get_the_date( 'c' ) ); ?>">
                        <?php echo esc_html( get_the_date() ); ?>
                    </time>
                </div>
            </article>
        <?php endwhile; ?>
    </div>

    <?php
    the_posts_pagination( [
        'mid_size'  => 2,
        'prev_text' => __( '← Precedente', 'mythemeblog' ),
        'next_text' => __( 'Successivo →', 'mythemeblog' ),
    ] );

else :
    ?>
    <p class="mythemeblog-empty"><?php esc_html_e( 'Nessun articolo trovato.', 'mythemeblog' ); ?></p>
    <?php
endif;

Il markup usa classi BEM (mythemeblog-card__title), escaping sistematico (esc_html, esc_attr, esc_url), e lazy loading per le immagini. Sono dettagli che fanno la differenza in termini di performance e sicurezza.

Step 4 — Customizer: opzioni del tema

Per un blog con esigenze specifiche, le opzioni del Customizer danno ai redattori controllo diretto sul branding senza toccare codice:

<?php
/**
 * Opzioni Customizer per MyThemeBlog
 * @link https://developer.wordpress.org/themes/customize-api/
 */

function mythemeblog_customize_register( $wp_customize ) {

    // Sezione: Colori del brand
    $wp_customize->add_section( 'mythemeblog_colors', [
        'title'    => __( 'Colori Brand', 'mythemeblog' ),
        'priority' => 30,
    ] );

    // Colore primario
    $wp_customize->add_setting( 'mythemeblog_color_primary', [
        'default'           => '#2563eb',
        'sanitize_callback' => 'sanitize_hex_color',
        'transport'         => 'refresh',
    ] );

    $wp_customize->add_control( new WP_Customize_Color_Control( $wp_customize, 'mythemeblog_color_primary', [
        'label'    => __( 'Colore Primario', 'mythemeblog' ),
        'section'  => 'mythemeblog_colors',
        'settings' => 'mythemeblog_color_primary',
    ] ) );

    // Logo homepage
    $wp_customize->add_setting( 'mythemeblog_logo_home_url', [
        'sanitize_callback' => 'esc_url_raw',
    ] );

    $wp_customize->add_control( 'mythemeblog_logo_home_url', [
        'type'        => 'url',
        'section'     => 'mythemeblog_colors',
        'label'       => __( 'URL logo per homepage', 'mythemeblog' ),
        'description' => __( 'Se impostato, mostra questo logo invece del titolo del sito sulla homepage.', 'mythemeblog' ),
    ] );
}
add_action( 'customize_register', 'mythemeblog_customize_register' );

/** === CSS dinamico dal Customizer === */
function mythemeblog_customizer_css() {
    $primary = get_theme_mod( 'mythemeblog_color_primary', '#2563eb' );
    ?>
    <style type="text/css">
        :root {
            --mythemeblog-color-primary: <?php echo esc_attr( $primary ); ?>;
        }
        .mythemeblog-card__category,
        .mythemeblog-btn {
            background-color: <?php echo esc_attr( $primary ); ?>;
        }
    </style>
    <?php
}
add_action( 'wp_head', 'mythemeblog_customizer_css' );

Il customizer espone opzioni concrete — colore primario, URL logo — che i redattori possono modificare senza intervento dello sviluppatore. Il CSS dinamico genera le variabili che i componenti del tema consumano.

Step 5 — Dark mode con CSS custom properties

La dark mode è una funzionalità che molti blog richiedono. Il pattern moderno sfrutta le CSS custom properties con un selettore data-theme:

/* assets/css/dark-mode.css */
/* Dark mode: definisce variabili alternative al tema chiaro */

[data-theme="dark"] {
    --mythemeblog-bg-primary: #0f172a;
    --mythemeblog-bg-secondary: #1e293b;
    --mythemeblog-text-primary: #f1f5f9;
    --mythemeblog-text-secondary: #94a3b8;
    --mythemeblog-border: #334155;
}

[data-theme="dark"] .mythemeblog-card {
    background-color: var( --mythemeblog-bg-secondary );
    border-color: var( --mythemeblog-border );
}

[data-theme="dark"] .mythemeblog-card__title a {
    color: var( --mythemeblog-text-primary );
}

L'interruttore JavaScript per la dark mode è altrettanto semplice:

/* assets/js/main.js */
// Interruttore dark mode — legge preferenza sistema e salva scelta utente
(function() {
    const toggle = document.getElementById('theme-toggle');
    if (!toggle) return;

    const saved = localStorage.getItem('mythemeblog-theme');
    const preferred = window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
    const current = saved || preferred;

    document.documentElement.setAttribute('data-theme', current);

    toggle.addEventListener('click', () => {
        const next = document.documentElement.getAttribute('data-theme') === 'dark' ? 'light' : 'dark';
        document.documentElement.setAttribute('data-theme', next);
        localStorage.setItem('mythemeblog-theme', next);
    });
})();

Questo pattern è resiliente: se JavaScript non carica per qualche motivo, il sito cade nella preferenza di sistema o nel tema chiaro, mai in uno stato rotto. Per approfondire le best practice di accessibilità e performance WordPress, vedi il nostro articolo sugli strumenti essenziali per web design WordPress., il sito cade nella preferenza di sistema o nel tema chiaro, mai in uno stato rotto.

Confronto rapido: Docker vs installazione Ubuntu LAMP

Sia Docker che l'installazione nativa su Ubuntu hanno pro e contro. Per uno sviluppatore WordPress che lavora con OpenCode, la scelta dipende dal contesto.

Per progetti singoli o team che usano Linux come ambiente primario, l'installazione Ubuntu LAMP è la scelta più performante. Se invece vuoi un confronto più ampio su tutti gli strumenti a disposizione dello sviluppatore WordPress, consulta la nostra guida su strumenti essenziali per web design WordPress, che copre anche Lando, Valet e soluzioni containerizzate. Per team con ambienti misti (Windows, Mac, Linux) o chi lavora su più progetti contemporaneamente, Docker Compose offre la portabilità necessaria.

Checklist operativa per sviluppo WordPress con OpenCode

Prima di ogni sessione di sviluppo, verifica questi punti (per un approccio strutturato alla sicurezza WordPress consulta anche la nostra guida agli strumenti essenziali per web design WordPress):

• Ambiente locale attivo: Apache e MySQL in esecuzione, WordPress raggiungibile su localhost
• OpenCode configurato con server MCP: filesystem, WP-CLI, WordPress.org, database attivi
• AGENTS.md aggiornato: struttura tema, vincoli PHP/CSS, comandi rapidi presenti
• Git init completato: il tema è versionato, almeno un commit iniziale esiste
• WP_DEBUG disattivato in locale (o attivato consapevolmente): define('WP_DEBUG', false); in wp-config.php
• Plugin di sviluppo attivi: Query Monitor, WP-CLI, Developer (o equivalenti)
• Staging allineato: se esiste staging, le modifiche dal locale ci arrivano via Git o rsync, non via admin

FAQ — Domande frequenti su OpenCode e sviluppo temi WordPress

OpenCode può generare block theme completi per WordPress 6.x? Sì, OpenCode può generare theme.json completo e template HTML per block theme. Il supporto per block personalizzati (custom blocks con JavaScript/React) richiede ancora scrittura manuala del codice, ma la struttura base del block theme viene prodotta correttamente seguendo lo schema v2.

Come si integra Rank Math SEO con il tema generato da OpenCode? OpenCode può aggiungere hook per Rank Math nel functions.php, come filtri per meta title e description dinamici. Tuttavia la configurazione SEO rimane un'operazione manuale via admin: nessun server MCP attuale modifica le opzioni Rank Math nel database in modo sicuro.

È sicuro usare i server MCP in produzione? Mai. I server MCP danno accesso operativo reale al filesystem e al database. Usa sempre ambiente locale o di staging. Se OpenCode deve operare su produzione, l'unico server accettabile è quello read-only (filesystem in sola lettura), e solo dopo backup completo verificato.

Posso usare OpenCode con Local by Flywheel o Valet invece di LAMP? Sì. Local by Flywheel e Valet sono wrapper che semplificano la gestione dell'ambiente WordPress locale. I server MCP funzionano con qualsiasi ambiente che esponga il filesystem e WP-CLI. Il file wp-config.php deve puntare al database corretto, indipendentemente dallo stack.

Come faccio a far rispettare a OpenCode le linee guida di sicurezza del mio team? Inseriscile esplicitamente nella sezione vincoli di AGENTS.md. Più sono specifiche, più OpenCode le rispetta. Esempi: "nessun file creato senza escaping esc_html", "nessun eval()", "tutti i form devono usare wp_nonce_field()". OpenCode è un modello linguistico: i vincoli scritti funzionano meglio delle aspettative implicite.

Quali server MCP servono per uno workflow WordPress minimo? Il minimo sindacale è filesystem + WP-CLI. Per un riferimento completo sui tool WordPress disponibili, consulta la nostra guida agli strumenti essenziali per creare temi WordPress efficaci. Il primo legge e scrive i file del tema. Il secondo gestisce aspetti runtime come attivazione plugin, reset database e generazione contenuto di test. Se hai bisogno di cercare plugin su WordPress.org, aggiungi il server WordPress.org. Il server database è opzionale e va usato con cautela.

Conclusione

OpenCode trasforma lo sviluppo di temi WordPress da processo manuale e ripetitivo a workflow iterativo e controllato. Ma solo se l'ambiente sottostante è configurato correttamente: un LAMP locale funzionante, un AGENTS.md che codifica le convenzioni del progetto, e i server MCP giusti per ogni area operativa.

La somma di questi elementi — ambiente, configurazione agente, protocollo MCP — ti dà un setup dove OpenCode opera con il contesto pieno del progetto WordPress. Per chi vuole approfondire anche il lato SEO e AI nella gestione WordPress, consigliamo la lettura di articoli WordPress ottimizzati SEO con AI., non in modalità cieca. Il codice che ne risulta è migliore, più coerente, e richiede meno revisione.

Prossimo passo concreto: configura il tuo AGENTS.md WordPress con la struttura del tema, i vincoli di sicurezza e i comandi rapidi che usi più spesso. Poi lancia OpenCode e chiedi di generare il primo template partial del tuo progetto. Dal primo output allarevisione al commit Git, in meno di mezz'ora.

Creare un tema WordPress da zero è una delle competenze più gratificanti che uno sviluppatore web possa acquisire. Non solo ti permette di avere il pieno controllo sul design e sulle funzionalità del tuo sito, ma ti offre anche una comprensione profonda di come funziona WordPress internamente.

In questa guida ti accompagnerò passo dopo passo nel processo di sviluppo di un tema WordPress funzionale, partendo dalle basi fino ad arrivare alla creazione di un tema completo e professionale.

Perché Creare un Tema WordPress Personalizzato

Prima di immergerci nel codice, è importante capire perché potresti voler creare il tuo tema WordPress invece di utilizzarne uno preesistente.

Un tema personalizzato ti offre:

• Controllo totale sull’aspetto e sul comportamento del sito
• Codice pulito senza funzionalità superflue che rallentano il caricamento
• Possibilità di branding per creare un’identità unica
• Apprendimento approfondito del funzionamento di WordPress
• Manutenzione semplificata perché conosci ogni parte del codice

Se stai cercando di entrare nel mondo dello sviluppo WordPress o vuoi creare un sito web professionale, imparare a sviluppare temi è un investimento che vale sicuramente il tempo dedicato.

Prerequisiti per lo Sviluppo di Temi WordPress

Prima di iniziare, assicurati di avere una buona comprensione dei seguenti concetti:

Competenze Tecniche Necessarie

• HTML e CSS: La base di qualsiasi sito web. Devi sapere come strutturare una pagina e stilizzarla.
• PHP: WordPress è costruito su PHP, quindi una conoscenza base è essenziale per comprendere come funziona il sistema di template.
• JavaScript: Utile per aggiungere interattività, anche se non strettamente necessario per un tema base.

Strumenti di Sviluppo

• Un server locale come XAMPP, MAMP o Local by Flywheel
• Un editor di codice come Visual Studio Code, PhpStorm o Sublime Text
• Un browser moderno con strumenti di sviluppo (Chrome DevTools)
• Accesso a un’installazione WordPress locale

Configurare l’Ambiente di Sviluppo Locale

Il primo passo concreto è configurare un ambiente di sviluppo locale dove poter testare il tuo tema senza compromettere un sito live.

Installare Local by Flywheel

Local è una delle opzioni più semplici per creare un ambiente WordPress locale:

1. Scarica e installa Local dal sito ufficiale
2. Crea un nuovo sito WordPress
3. Assegna un nome al progetto
4. Attendi che l’installazione venga completata
5. Accedi alla bacheca WordPress

Una volta completata l’installazione, avrai un sito WordPress funzionante su cui testare il tuo tema in tempo reale.

Struttura delle Cartelle dei Temi

WordPress cerca i temi in una struttura specifica. I temi si trovano in:

wp-content/themes/nome-del-tuo-tema/

Questa cartella sarà la tua area di lavoro principale. Al suo interno creerai tutti i file necessari per il tuo tema.

Creare i File Essenziali del Tema

Ogni tema WordPress richiede alcuni file fondamentali per funzionare. Iniziamo creando la struttura base.

1. Il File style.css

Il file style.css è il cuore del tuo tema. Non contiene solo CSS, ma anche le informazioni necessarie a WordPress per riconoscere e visualizzare il tema nel pannello di amministrazione.

/
Theme Name: Il Mio Primo Tema
Theme URI: https://esempio.com
Author: Il Tuo Nome
Author URI: https://esempio.com
Description: Un tema WordPress personalizzato creato da zero
Version: 1.0.0
License: GNU General Public License v2 or later
License URI: http://www.gnu.org/licenses/gpl-2.0.html
Text Domain: mio-primo-tema
/

Questo commento iniziale è obbligatorio. Senza di esso, WordPress non sarà in grado di riconoscere il tuo tema.

2. Il File functions.php

Il file functions.php è dove definisci le funzionalità del tema, registri script, stili, menu, widget e molto altro.

<?php
// Aggiungiamo il supporto per vari elementi di WordPress
function mio_tema_setup() {
    // Supporto per il titolo del sito
    add_theme_support('title-tag');

    // Supporto per le immagini in evidenza
    add_theme_support('post-thumbnails');

    // Supporto per il logo personalizzato
    add_theme_support('custom-logo');

    // Registriamo un menu di navigazione
    register_nav_menus(array(
        'primary' => __('Menu Principale', 'mio-primo-tema'),
        'footer' => __('Menu Footer', 'mio-primo-tema'),
    ));
}
add_action('after_setup_theme', 'mio_tema_setup');

// Carichiamo gli stili e gli script
function mio_tema_scripts() {
    wp_enqueue_style('mio-tema-style', get_stylesheet_uri());
    wp_enqueue_script('mio-tema-script', get_template_directory_uri() . '/js/main.js', array(), '1.0.0', true);
}
add_action('wp_enqueue_scripts', 'mio_tema_scripts');

3. Il File index.php

Il file index.php è il template di fallback di WordPress. Viene utilizzato quando non esiste un template più specifico per un determinato contenuto.

<?php get_header(); ?>

<main class="site-main">
    <?php if (have_posts()) : while (have_posts()) : the_post(); ?>

        <article id="post-<?php the_ID(); ?>" <?php post_class(); ?>>
            <header class="entry-header">
                <h2 class="entry-title">
                    <a href="<?php the_permalink(); ?>"><?php the_title(); ?></a>
                </h2>
                <div class="entry-meta">
                    <span class="posted-on"><?php echo get_the_date(); ?></span>
                </div>
            </header>

            <div class="entry-content">
                <?php the_content(); ?>
            </div>
        </article>

    <?php endwhile; else : ?>
        <p><?php esc_html_e('Nessun contenuto trovato.', 'mio-primo-tema'); ?></p>
    <?php endif; ?>
</main>

<?php get_footer(); ?>

Comprendere la Gerarchia dei Template

WordPress utilizza un sistema di gerarchia dei template per determinare quale file PHP visualizzare per ogni tipo di contenuto. Comprendere questo sistema è fondamentale per creare un tema completo.

Ordine di Priorità dei Template

Ecco l’ordine in cui WordPress cerca i template:

Esempio Pratico: Creare header.php e footer.php

Per evitare di ripetere il codice in ogni template, WordPress permette di creare file parziali riutilizzabili.

header.php

<!DOCTYPE html>
<html <?php language_attributes(); ?>>
<head>
    <meta charset="<?php bloginfo('charset'); ?>">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <?php wp_head(); ?>
</head>
<body <?php body_class(); ?>>
<?php wp_body_open(); ?>

<header class="site-header">
    <div class="container">
        <?php if (has_custom_logo()) : ?>
            <?php the_custom_logo(); ?>
        <?php else : ?>
            <h1 class="site-title">
                <a href="<?php echo esc_url(home_url('/')); ?>">
                    <?php bloginfo('name'); ?>
                </a>
            </h1>
        <?php endif; ?>

        <nav class="main-navigation">
            <?php wp_nav_menu(array(
                'theme_location' => 'primary',
                'container' => false,
                'menu_class' => 'nav-menu',
            )); ?>
        </nav>
    </div>
</header>

<main class="site-content">

footer.php

</main>

<footer class="site-footer">
    <div class="container">
        <p>&copy; <?php echo date('Y'); ?> <?php bloginfo('name'); ?>. Tutti i diritti riservati.</p>
        <?php wp_nav_menu(array('theme_location' => 'footer')); ?>
    </div>
</footer>

<?php wp_footer(); ?>
</body>
</html>

Il Loop di WordPress: Cuore del Sistema

Il Loop è il meccanismo fondamentale attraverso cui WordPress recupera e visualizza i contenuti. Comprenderlo è essenziale per qualsiasi sviluppatore di temi.

Struttura Base del Loop

<?php
// Verifichiamo se ci sono post da visualizzare
if (have_posts()) :

    // Iteriamo attraverso ogni post
    while (have_posts()) : the_post();

        // Contenuto del singolo post ?>
        <article id="post-<?php the_ID(); ?>">
            <h2><?php the_title(); ?></h2>
            <div class="post-thumbnail">
                <?php if (has_post_thumbnail()) : ?>
                    <?php the_post_thumbnail('medium'); ?>
                <?php endif; ?>
            </div>
            <div class="post-excerpt">
                <?php the_excerpt(); ?>
            </div>
            <a href="<?php the_permalink(); ?>">Leggi tutto</a>
        </article>
        <?php

    endwhile;

    // Paginazione
    the_posts_pagination();

else :
    // Messaggio se non ci sono post
    echo '<p>Nessun contenuto disponibile.</p>';

endif;
?>

Funzioni Utili all’Interno del Loop

All’interno del Loop hai accesso a numerose funzioni:

• the_title() - Visualizza il titolo del post
• the_content() - Visualizza il contenuto completo
• the_excerpt() - Visualizza un riassunto
• the_permalink() - Restituisce l’URL del post
• the_post_thumbnail() - Visualizza l’immagine in evidenza
• the_date() - Visualizza la data di pubblicazione
• the_author() - Visualizza l’autore
• get_the_category() - Recupera le categorie

Template Parts: Riutilizzare il Codice

I template parts sono frammenti di template che puoi includere in diversi punti del tuo tema. Questo approccio promuove il riutilizzo del codice e la manutenzione più semplice.

Creare Template Parts

Puoi creare template parts per elementi ripetitivi come card di articoli, header di sezioni, o qualsiasi altro componente.

template-parts/content.php

<article id="post-<?php the_ID(); ?>" <?php post_class('article-card'); ?>>
    <?php if (has_post_thumbnail()) : ?>
        <div class="card-image">
            <a href="<?php the_permalink(); ?>">
                <?php the_post_thumbnail('large'); ?>
            </a>
        </div>
    <?php endif; ?>

    <div class="card-content">
        <h3 class="card-title">
            <a href="<?php the_permalink(); ?>"><?php the_title(); ?></a>
        </h3>

        <div class="card-meta">
            <span class="card-date"><?php echo get_the_date(); ?></span>
            <span class="card-author">di <?php the_author(); ?></span>
        </div>

        <div class="card-excerpt">
            <?php the_excerpt(); ?>
        </div>

        <a href="<?php the_permalink(); ?>" class="card-link">
            Continua a leggere →
        </a>
    </div>
</article>

Includere Template Parts nel Template

<?php get_template_part('template-parts/content', 'page'); ?>

Il secondo parametro (‘page’) permette di specificare un suffisso. WordPress cercherà prima content-page.php e, se non esiste, ricorrerà a content.php.

Aggiungere Stili e Script Correttamente

Un aspetto cruciale dello sviluppo temi è la gestione corretta di CSS e JavaScript. WordPress fornisce un sistema integrato per caricare risorse in modo sicuro e.performante.

Best Practices per CSS e JavaScript

function mio_tema_enqueue_assets() {
    // CSS principale del tema
    wp_enqueue_style(
        'mio-tema-main',
        get_stylesheet_directory_uri() . '/css/main.css',
        array(),
        '1.0.0'
    );

    // Font Google (dipendenza per main.css)
    wp_enqueue_style(
        'google-fonts',
        'https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap',
        array(),
        null
    );

    // JavaScript con dipendenze
    wp_enqueue_script(
        'mio-tema-navigation',
        get_template_directory_uri() . '/js/navigation.js',
        array(),
        '1.0.0',
        true
    );

    // JavaScript condizionale (es. solo per IE)
    wp_enqueue_script(
        'html5shiv',
        'https://cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv.min.js',
        array(),
        '3.7.3',
        false
    );
    wp_script_add_data('html5shiv', 'conditional', 'lt IE 9');
}
add_action('wp_enqueue_scripts', 'mio_tema_enqueue_assets');

Creare il File CSS Principale

css/main.css

/ Reset di base /
 {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
}

/ Variabili CSS /
:root {
    --color-primary: #2563eb;
    --color-secondary: #1e40af;
    --color-text: #1f2937;
    --color-bg: #ffffff;
    --font-main: 'Inter', sans-serif;
    --spacing-md: 1.5rem;
    --spacing-lg: 3rem;
}

/ Stili globali /
body {
    font-family: var(--font-main);
    color: var(--color-text);
    background-color: var(--color-bg);
    line-height: 1.6;
}

/ Container /
.container {
    max-width: 1200px;
    margin: 0 auto;
    padding: 0 var(--spacing-md);
}

/ Header /
.site-header {
    padding: var(--spacing-md) 0;
    border-bottom: 1px solid #e5e7eb;
}

.site-header .container {
    display: flex;
    justify-content: space-between;
    align-items: center;
}

/ Navigazione /
.nav-menu {
    display: flex;
    list-style: none;
    gap: var(--spacing-md);
}

.nav-menu a {
    text-decoration: none;
    color: var(--color-text);
    transition: color 0.3s ease;
}

.nav-menu a:hover {
    color: var(--color-primary);
}

/ Articoli /
.article-card {
    margin-bottom: var(--spacing-lg);
    padding: var(--spacing-md);
    border-radius: 8px;
    background: #f9fafb;
}

.card-title a {
    text-decoration: none;
    color: var(--color-text);
}

/ Responsive */
@media (max-width: 768px) {
    .site-header .container {
        flex-direction: column;
        gap: var(--spacing-md);
    }

    .nav-menu {
        flex-direction: column;
        align-items: center;
    }
}

Personalizzare il Tema con il Customizer

Il Customizer di WordPress permette agli utenti di modificare aspeketti del tema in tempo reale. Implementare il Customizer rende il tuo tema più flessibile e user-friendly.

Aggiungere Opzioni al Customizer

function mio_tema_customize_register($wp_customize) {
    // Sezione Colori
    $wp_customize->add_section('mio_tema_colors', array(
        'title' => __('Colori del Sito', 'mio-primo-tema'),
        'priority' => 30,
    ));

    // Impostazione colore primario
    $wp_customize->add_setting('primary_color', array(
        'default' => '#2563eb',
        'sanitize_callback' => 'sanitize_hex_color',
    ));

    $wp_customize->add_control(new WP_Customize_Color_Control($wp_customize, 'primary_color', array(
        'label' => __('Colore Primario', 'mio-primo-tema'),
        'section' => 'mio_tema_colors',
        'settings' => 'primary_color',
    )));

    // Sezione Layout
    $wp_customize->add_section('mio_tema_layout', array(
        'title' => __('Layout', 'mio-primo-tema'),
        'priority' => 35,
    ));

    // Impostazione container width
    $wp_customize->add_setting('container_width', array(
        'default' => '1200',
        'sanitize_callback' => 'absint',
    ));

    $wp_customize->add_control('container_width', array(
        'type' => 'number',
        'section' => 'mio_tema_layout',
        'label' => __('Larghezza Container (px)', 'mio-primo-tema'),
        'input_attrs' => array(
            'min' => 800,
            'max' => 1920,
            'step' => 20,
        ),
    ));
}
add_action('customize_register', 'mio_tema_customize_register');

// Applicare le impostazioni nel CSS
function mio_tema_customizer_css() {
    $primary_color = get_theme_mod('primary_color', '#2563eb');
    $container_width = get_theme_mod('container_width', '1200');
    ?>
    <style type="text/css">
        :root {
            --color-primary: <?php echo esc_attr($primary_color); ?>;
            --container-max: <?php echo esc_attr($container_width); ?>px;
        }
    </style>
    <?php
}
add_action('wp_head', 'mio_tema_customizer_css');

Creare Template Specifici

Per un tema completo, dovresti creare template specifici per diversi tipi di contenuto.

Template per Pagine (page.php)

<?php get_header(); ?>

<main class="page-template">
    <?php while (have_posts()) : the_post(); ?>

        <article class="page-content">
            <header class="page-header">
                <h1 class="page-title"><?php the_title(); ?></h1>
            </header>

            <div class="page-body">
                <?php the_content(); ?>
            </div>

            <?php
            // Supporto per la paginazione all'interno del contenuto
            wp_link_pages(array(
                'before' => '<div class="page-links">' . __('Pagine:', 'mio-primo-tema'),
                'after' => '</div>',
            ));
            ?>
        </article>

        <?php
        // Commenti (se abilitati)
        if (comments_open() || get_comments_number()) :
            comments_template();
        endif;
        ?>

    <?php endwhile; ?>
</main>

<?php get_footer(); ?>

Template per Articoli (single.php)

<?php get_header(); ?>

<main class="single-post">
    <?php while (have_posts()) : the_post(); ?>

        <article class="post-single">
            <header class="post-header">
                <?php if (has_post_thumbnail()) : ?>
                    <div class="post-featured-image">
                        <?php the_post_thumbnail('large'); ?>
                    </div>
                <?php endif; ?>

                <h1 class="post-title"><?php the_title(); ?></h1>

                <div class="post-meta">
                    <span class="post-date">
                        <time datetime="<?php echo get_the_date('c'); ?>">
                            <?php echo get_the_date(); ?>
                        </time>
                    </span>
                    <span class="post-author">
                        <?php the_author_posts_link(); ?>
                    </span>
                    <span class="post-categories">
                        <?php the_category(', '); ?>
                    </span>
                </div>
            </header>

            <div class="post-content">
                <?php the_content(); ?>
            </div>

            <footer class="post-footer">
                <?php the_tags('<div class="post-tags"><strong>Tag:</strong> ', ', ', '</div>'); ?>

                <?php get_template_part('template-parts/author', 'bio'); ?>
            </footer>
        </article>

        <nav class="post-navigation">
            <div class="previous-post">
                <?php previous_post_link('%link', '← Articolo precedente'); ?>
            </div>
            <div class="next-post">
                <?php next_post_link('%link', 'Articolo successivo →'); ?>
            </div>
        </nav>

        <?php comments_template(); ?>

    <?php endwhile; ?>
</main>

<?php get_footer(); ?>

Template per Errori 404 (404.php)

<?php get_header(); ?>

<main class="error-404">
    <div class="container">
        <section class="error-404-content">
            <h1 class="error-code">404</h1>
            <h2 class="error-title"><?php esc_html_e('Pagina Non Trovata', 'mio-primo-tema'); ?></h2>
            <p class="error-message">
                <?php esc_html_e('La pagina che stai cercando non esiste o è stata spostata.', 'mio-primo-tema'); ?>
            </p>

            <div class="error-search">
                <h3><?php esc_html_e('Prova a cercare:', 'mio-primo-tema'); ?></h3>
                <?php get_search_form(); ?>
            </div>

            <div class="error-links">
                <a href="<?php echo esc_url(home_url('/')); ?>" class="btn-home">
                    <?php esc_html_e('Torna alla Home', 'mio-primo-tema'); ?>
                </a>
            </div>
        </section>
    </div>
</main>

<?php get_footer(); ?>

Sicurezza e Best Practices

Quando sviluppi un tema WordPress, la sicurezza deve essere sempre una priorità.

Sanitizzazione e Validazione

// Sanitizzazione degli input
$testo = sanitize_text_field($input);
$email = sanitize_email($input);
$url = esc_url($input);
$html = wp_kses_post($input);

// escaping dell'output
echo esc_html($testo);
echo esc_attr($attributo);
echo esc_url($link);
echo wp_kses_post($contenuto_html);

Altre Best Practices

• Non modificare i file core di WordPress
• Usa funzioni WordPress native invece di codice personalizzato quando possibile
• Implementa il supporto per la traduzione usando __() e _e()
• Evita queries personalizzate complesse nel template; usa invece hooks e filtri
• Mantieni il codice modulare usando template parts e funzioni specifiche

Testare e Distribuire il Tema

Prima di rendere disponibile il tuo tema, è essenziale testarlo accuratamente.

Checklist per i Test

• [ ] Il tema si attiva senza errori
• [ ] Tutti i template funzionano correttamente
• [ ] I menu di navigazione sono visualizzati
• [ ] Le immagini in evidenza vengono visualizzate
• [ ] I commenti funzionano
• [ ] La paginazione è corretta
• [ ] Il Customizer funziona
• [ ] Il tema è responsive su diversi dispositivi
• [ ] Non ci sono errori PHP o JavaScript nella console
• [ ] Il tema rispetta gli standard WordPress

Strumenti di Test

• Theme Check: Plugin che verifica la conformità agli standard WordPress
• Query Monitor: Per debuggare query database e performance
• Browser DevTools: Per testare CSS e JavaScript
• Theme Unit Test: Dataset di test per verificare la compatibilità