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.