Il risultato, misurato dagli autori del progetto su un tipico progetto TypeScript/Rust di medie dimensioni, è un taglio tra il 60% e il 92% dei token consumati per i comandi più frequenti. In una sessione di sviluppo reale parliamo di decine di migliaia di token risparmiati al giorno, e di context window che resta utilizzabile molto più a lungo.

Che cosa fa RTK, in pratica

RTK non è un wrapper generico: è una collezione di filtri specifici per ognuno dei comandi più usati in un workflow di sviluppo. Per ogni comando applica una o più di queste strategie:

• Smart filtering — rimuove commenti, whitespace, boilerplate, header ripetitivi (per esempio le righe Enumerating objects di Git).
• Grouping — aggrega elementi simili (file per directory, errori per tipo, log duplicati con contatore).
• Truncation — mantiene il contesto rilevante e taglia la ridondanza, conservando però l'output completo su file.
• Deduplication — comprime le righe di log ripetute con un contatore (×142).

Tecnicamente RTK è un singolo binario Rust statico, zero dipendenze di runtime, overhead inferiore ai 10 millisecondi per chiamata. Supporta oltre 100 comandi divisi per categoria:

• File system: rtk ls, rtk read, rtk grep, rtk find, rtk smart.
• Git: rtk git status, rtk git diff, rtk git log, rtk git commit, rtk git push.
• GitHub CLI: rtk gh pr list, rtk gh pr view, rtk gh issue list.
• Test runner: rtk jest, rtk vitest, rtk pytest, rtk cargo test, rtk go test, rtk rspec.
• Linter e build: rtk lint, rtk tsc, rtk next build, rtk cargo build, rtk ruff check.
• Container e cloud: rtk docker ps, rtk kubectl logs, rtk aws ec2 describe-instances.
• Utility: rtk gain (statistiche risparmio), rtk discover, rtk proxy, rtk err.

Quanto si risparmia davvero

I numeri riportati nel README ufficiale derivano da un progetto reale di medie dimensioni (TypeScript + Rust). Ecco i comandi più usati con il relativo taglio di token:

Il risparmio aggregato è circa l'80% del context speso in interazioni con la shell. Su un mese di lavoro intensivo parliamo di milioni di token, e — con i prezzi correnti delle API — di dollari risparmiati in modo trasparente, senza cambiare una riga di codice.

Installazione: 30 secondi

RTK si installa come un singolo binario in ~/.local/bin. Tre opzioni equivalenti, scegli quella più adatta al tuo sistema.

La via più rapida su macOS è Homebrew:

# installa RTK via Homebrew
brew install rtk

Su Linux o WSL funziona meglio lo script ufficiale, che scarica direttamente dal ramo master:

# installa RTK da release ufficiale
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

Se preferisci compilare dai sorgenti, basta Cargo:

# build locale dal repository
cargo install --git https://github.com/rtk-ai/rtk

Al termine verifica che il binario sia raggiungibile e funzioni:

# verifica installazione
rtk --version
rtk gain

Se rtk non è in PATH, aggiungi questa riga al tuo ~/.bashrc o ~/.zshrc:

# rendi rtk disponibile in ogni shell
export PATH="$HOME/.local/bin:$PATH"

Un avvertimento importante: esiste un altro crate pubblicato su crates.io con lo stesso nome (Rust Type Kit). Se rtk gain non produce statistiche di risparmio token, hai preso il pacchetto sbagliato. In quel caso disinstallalo e usa cargo install --git come mostrato sopra.

Integrazione con Claude Code e gli altri agent

Qui sta la parte più elegante: RTK non richiede di riscrivere le istruzioni di sistema o di cambiare il prompt del tuo agent. Espone un comando init che installa un hook trasparente sulle chiamate Bash. Quando Claude Code esegue git status, l'hook lo riscrive in rtk git status prima di passarlo alla shell.

Per Claude Code, Copilot, Gemini CLI, Codex e gli altri agent principali basta un comando:

# inizializza hook globale per i principali agent
rtk init -g
rtk init -g --gemini
rtk init -g --codex
rtk init -g --agent cursor
rtk init -g --agent windsurf

Per agent con plugin dedicato come Cline, Kilo Code, Antigravity e Hermes ci sono flag specifici:

# init per agent con regole project-scoped
rtk init --agent cline
rtk init --agent kilocode
rtk init --agent antigravity
rtk init --agent hermes

Supporta complessivamente 14 tra AI agent e IDE — la matrice completa è nel README del progetto. Per OpenClaw esiste un plugin dedicato installabile con openclaw plugins install ./openclaw dalla root del repository.

Limite importante: l'hook intercetta solo le chiamate al tool Bash. I tool nativi di Claude Code come Read, Grep e Glob non passano dall'hook, quindi non vengono riscritti automaticamente. Per ottenere l'output compatto in quei casi devi invocare direttamente rtk read, rtk grep o rtk find.

Il flusso, visto da vicino

Quando l'hook è attivo, ogni comando shell segue questo percorso:

1. L'agent genera una chiamata Bash (es. git status).
2. L'hook PreToolUse riscrive il comando in rtk git status.
3. La shell esegue il comando, che produce output raw (~2.000 token).
4. RTK filtra l'output in tempo reale, mantenendo solo l'essenziale (~200 token).
5. L'agent riceve l'output compatto e prosegue.

L'overhead per il filtro è inferiore ai 10 ms — impercettibile per l'utente, trasparente per l'agent. In caso di errore, RTK salva automaticamente l'output completo non filtrato in ~/.local/share/rtk/tee/<timestamp>_<cmd>.log, così l'LLM può leggere i dettagli senza rieseguire il comando.

Esempi pratici, prima e dopo

Una ls -la tipica produce 45 righe e circa 800 token. Con rtk ls la stessa directory diventa 12 righe compatte:

# output RTK di una directory di progetto
+-- src/ (8 files)
|   +-- main.rs
|   +-- lib.rs
+-- Cargo.toml
+-- README.md

Un git push standard restituisce 15 righe e ~200 token (Enumerating, Counting, Delta compression…). Con rtk git push:

# output compresso di un push Git
ok main

Una suite di test cargo test in fallimento può produrre 200+ righe. Con rtk test cargo test ottieni solo i test rossi:

# riepilogo failure-only
FAILED: 2/15 tests
test utils::test_parse ... ok
test_edge_case: assertion failed
test utils::test_format ... ok
test_overflow: panic at utils.rs:18

Per il wrapping generico su qualsiasi comando, ci sono rtk err <cmd> (filtra solo gli errori) e rtk test <cmd> (filtra solo i fallimenti). Se invece vuoi mantenere l'output raw ma tracciare il risparmio, usa rtk proxy.

Misurare il risparmio con rtk gain

Una volta che l'hook è attivo, ogni chiamata viene conteggiata. Il comando rtk gain mostra le statistiche aggregate:

# statistiche aggregate di risparmio
rtk gain

# grafico ASCII degli ultimi 30 giorni
rtk gain --graph

# cronologia dei comandi recenti
rtk gain --history

# breakdown giornaliero
rtk gain --daily

# export JSON per dashboard
rtk gain --all --format json

rtk discover fa il passo opposto: trova opportunità di risparmio che stai perdendo, ad esempio comandi per cui non esiste ancora un filtro e che vengono passati raw all'agent.

# scopri risparmi mancanti in tutti i progetti
rtk discover --all --since 7

Configurazione mirata

Il file di configurazione globale vive in ~/.config/rtk/config.toml (su macOS: ~/Library/Application Support/rtk/config.toml). Le opzioni più utili riguardano l'esclusione di comandi specifici dal rewriting e la gestione del salvataggio dell'output completo:

# config.toml di esempio
[hooks]
exclude_commands = ["curl", "playwright"]

[tee]
enabled = true
mode = "failures"

La sezione [tee] controlla se e quando salvare l'output non filtrato. Con mode = "failures" (default), il file viene scritto solo quando il comando fallisce — l'LLM può quindi leggere il contesto completo senza rieseguire nulla. Con "always" il file viene sempre salvato; con "never" mai.

Telemetria e privacy

RTK può raccogliere metriche aggregate anonime (una volta al giorno) per aiutare il team a identificare quali filtri servono e quali vanno migliorati. La telemetria è disabilitata di default e richiede consenso esplicito durante rtk init o via rtk telemetry enable. Cosa viene raccolto, in sintesi:

• Identità: hash SHA-256 salato del device (non reversibile).
• Ambiente: versione RTK, OS, architettura, metodo di installazione.
• Volume d'uso: numero di comandi nelle ultime 24h, token risparmiati.
• Qualità: top 5 comandi passthrough, parse failure, comandi con savings < 30%.
• Ecosistema: distribuzione per categoria (git 45%, cargo 20%, js 15%).

Cosa non viene raccolto: codice sorgente, path assoluti, argomenti dei comandi, segreti, environment variable, contenuti del repository. I comandi riportati sono solo nomi di tool (es. "git", "cargo"), mai righe intere. Puoi disattivare la telemetria in qualsiasi momento o richiedere la cancellazione totale:

# gestione completa della telemetria
rtk telemetry status
rtk telemetry disable
rtk telemetry forget

# blocco totale via environment
export RTK_TELEMETRY_DISABLED=1

Windows: cosa cambia

Su Windows nativo (cmd.exe o PowerShell) l'hook automatico di rewriting non funziona, perché richiede una shell Unix. RTK cade quindi in CLAUDE.md injection mode: l'agent riceve le istruzioni RTK ma i comandi non vengono riscritti automaticamente — devi invocare rtk cargo test, rtk git status eccetera in modo esplicito.

La soluzione consigliata dagli stessi autori è WSL: dentro WSL RTK lavora esattamente come su Linux, hook incluso. Per partire:

# installazione RTK dentro WSL
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
rtk init -g

Ricorda di non fare doppio click su rtk.exe: è un tool CLI che stampa l'usage ed esce immediatamente. Sempre da terminale, mai da Esplora Risorse.

Disinstallazione

Se RTK non fa per te, la rimozione è pulita quanto l'installazione. Tre comandi a seconda del metodo usato:

# rimozione hook, regole e settings.json
rtk init -g --uninstall

# rimozione binario
cargo uninstall rtk
brew uninstall rtk

Verdetto: quando ha senso adottarlo

RTK non è un giocattolo: è uno strumento di produttività pensato per chi usa AI agent in modo intensivo e vuole massimizzare il budget di context. I casi d'uso in cui dà il massimo:

• Sessioni lunghe di pair programming con Claude Code, Codex o Cursor, dove il context si satura in fretta.
• Progetti multi-linguaggio (Rust + TypeScript + Python + Go) con molti test runner diversi.
• Workflow DevOps pesanti su Kubernetes, Docker, AWS CLI, Pulumi — RTK copre tutti i comandi più comuni.
• Team che vogliono abbassare il costo per sessione senza toccare i prompt o i modelli usati.

Se invece usi l'agent solo per task brevi e non tiri su Docker né fai test suite grosse, il guadagno sarà marginale. Ma il costo di adozione è praticamente zero: un comando per installarlo, uno per attivarlo, e da quel momento non devi più pensarci.

Approccio pragmatico consigliato: installa RTK, lancia rtk gain dopo una giornata di lavoro reale, e guarda i numeri. Se i token risparmiati superano il costo del setup (qualche minuto), hai la risposta. Il progetto è open source Apache 2.0, sviluppato da Patrick Szymkowiak, Florian Bruniaux e Adrien Eppling, con una community attiva su Discord.

Link utili

• Repository ufficiale su GitHub
• Sito ufficiale e guida completa
• Documento di architettura interna
• Guida di installazione dettagliata
• Policy di sicurezza del progetto
• Community Discord ufficiale

Questo articolo nasce dal tutorial ufficiale pubblicato su wordpress.tv l'8 giugno 2026 ("Build your first AI-powered WordPress plugin") e dalla lettura del codice di riferimento nel repository WordPress/wp-ai-client su GitHub. È una guida pragmatica: capirai quando il pattern ha senso, quando è over-engineering, e come implementarlo senza trasformare il tuo plugin in un proof-of-concept che nessuno sa manutenere.

Cos'è il pattern abilities + MCP + WP AI Client

Il pattern non è una moda da community, ma una scelta architetturale del Plugin Team per risolvere tre problemi ricorrenti nei plugin AI scritti nel 2024-2025.

I tre problemi che il pattern risolve

1. Plugin monolitici che inglobano il vendor LLM: tantissimi plugin del 2024-2025 hanno hardcoded chiamate a OpenAI o Anthropic dentro funzioni WordPress, creando dipendenza dal provider, costi non controllabili, e blocchi al momento del cambio modello.
2. Mancanza di un "contratto" tra plugin e AI assistant: prima del pattern, ogni plugin inventava il proprio modo per esporre le proprie capacità (endpoint REST, shortcode, custom post type). Risultato: l'AI assistant non sa mai cosa può fare davvero su quel sito.
3. Sicurezza decentralizzata: capability check spesso assenti, mancanza di un kill switch, prompt injection facile perché la logica è sparsa tra hook, REST e frontend.

Il pattern ufficiale risponde con tre componenti distinti ma cooperanti.

Le tre componenti in sintesi

• Abilities API (inclusa nel core da WP 6.9, matura in WP 7.0): un modo standard per dichiarare cosa sa fare il tuo plugin. Ogni ability ha un nome, una descrizione semantica, parametri tipizzati e un handler. È il "contratto".
• Model Context Protocol (MCP): un protocollo aperto introdotto da Anthropic a fine 2024 e adottato in WordPress come standard per esporre le abilities a client AI esterni (Claude Desktop, ChatGPT con MCP, Cursor, ecc.). Il plugin pubblica un server MCP; l'AI client lo scopre e lo consuma.
• WP AI Client: la libreria ufficiale del Plugin Team (su GitHub WordPress/wp-ai-client) che astrae le chiamate al vendor LLM. Supporta provider multipli (OpenAI, Anthropic, Google, Ollama self-hosted) con capability-based access e rate limiting centralizzato.

Insieme formano una pipeline: il plugin dichiara le proprie abilities → le espone via MCP agli AI assistant → usa WP AI Client per le chiamate al modello, senza mai hardcodare il vendor.

Quando adottare il pattern (e quando evitarlo)

Non tutti i plugin AI devono adottare questo stack. Facciamo chiarezza con un test a tre domande che uso in agenzia prima di approvare un nuovo progetto plugin.

Test delle tre domande

Adotta il pattern se rispondi sì ad almeno due di queste:

1. Il plugin interagisce con un AI assistant esterno (Claude Desktop, ChatGPT MCP, agent custom)?
2. Prevedi di supportare più provider LMO (OpenAI, Anthropic, Ollama, self-hosted) o di poter cambiare provider in futuro senza riscrivere il plugin?
3. Il plugin deve rispettare policy di sicurezza enterprise (capability check, audit log, kill switch)?

Se rispondi no a due su tre, stai over-engineering. Un plugin AI semplice - ad esempio uno che genera excerpt automaticamente - può usare direttamente WP AI Client saltando abilities e MCP, oppure restare su wp_remote_post() per una singola API key fissa.

Profili tipici di adozione

• Agenzia che sviluppa per clienti enterprise: pattern obbligatorio. Compliance, audit e portabilità tra provider sono requisiti di contratto.
• Freelance con 5-10 clienti piccoli: pattern consigliato. Il costo di setup si ammortizza in 2-3 progetti e la manutenzione è più semplice.
• Hobbista con un solo progetto: pattern eccessivo. Meglio una funzione custom in functions.php.
• Plugin commerciale in vendita su .org: pattern raccomandato dal Plugin Team. La review del 2026 premia i plugin che adottano standard aperti.

Anatomia di un'ability WordPress

Un'ability è un'unità dichiarativa: nome, descrizione, parametri, handler. Vediamo l'implementazione minima tratta dal tutorial wordpress.tv.

Registrare un'ability

add_action( 'abilities_api_init', 'mia_registra_ability_post_summary' );
function mia_registra_ability_post_summary() {
    wp_register_ability( 'content/summarize-post', array(
        'label'       => __( 'Riassumi post WordPress', 'mio-plugin' ),
        'description' => __( 'Genera un riassunto di 60 parole di un post pubblicato.', 'mio-plugin' ),
        'category'    => 'content',
        'input_schema' => array(
            'type' => 'object',
            'properties' => array(
                'post_id' => array( 'type' => 'integer', 'minimum' => 1 ),
                'max_words' => array( 'type' => 'integer', 'default' => 60 ),
            ),
            'required' => array( 'post_id' ),
        ),
        'output_schema' => array(
            'type' => 'object',
            'properties' => array(
                'summary' => array( 'type' => 'string' ),
                'tokens_used' => array( 'type' => 'integer' ),
            ),
        ),
        'permission_callback' => function ( $input ) {
            return current_user_can( 'edit_post', $input['post_id'] );
        },
        'execute_callback' => 'mia_execute_summarize_post',
    ) );
}

Tre dettagli che fanno la differenza rispetto a un custom endpoint REST: la description è leggibile dall'AI assistant (è il campo che popola la MCP tool list), input_schema e output_schema rendono l'ability validabile senza scrivere validator custom, e permission_callback è valutato prima dell'esecuzione. Niente più capability check duplicati in cinque punti del codice.

L'handler: cosa non fare

function mia_execute_summarize_post( $input ) {
    $post = get_post( $input['post_id'] );
    if ( ! $post ) {
        return new WP_Error( 'post_not_found', __( 'Post non trovato.', 'mio-plugin' ) );
    }
    // delega al client AI, non alla chiamata vendor
    $client = wp_ai_client();
    $response = $client->generate_text( array(
        'model' => 'auto',
        'system' => 'Sei un editor tecnico che riassume in italiano corretto.',
        'prompt' => wp_strip_all_tags( $post->post_content ),
        'max_tokens' => (int) ( $input['max_words'] * 1.5 ),
    ) );
    if ( is_wp_error( $response ) ) {
        return $response;
    }
    return array(
        'summary' => $response['text'],
        'tokens_used' => $response['usage']['total_tokens'] ?? 0,
    );
}

Nota: nessuna API key nel codice, nessuna chiamata diretta a un endpoint vendor. wp_ai_client() è la factory ufficiale introdotta dal Plugin Team, e l'argomento model => 'auto' lascia al client la scelta del modello in base a policy, costo e disponibilità. Questo è il punto: cambiare provider significa cambiare una costante di config, non riscrivere l'handler.

Esposizione MCP: dal plugin al desktop AI

Una volta registrate le abilities, esporle via MCP richiede il secondo mattoncino. Il Plugin Team mantiene un adapter (wp-abilities-mcp-adapter) che pubblica le abilities come MCP tools.

Setup dell'adapter MCP

add_action( 'mcp_adapter_init', 'mia_registra_mcp_server' );
function mia_registra_mcp_server() {
    $adapter = wp_mcp_adapter();
    $adapter->register_server( 'mio-plugin', array(
        'name'         => 'Mio Plugin AI',
        'version'      => '1.0.0',
        'abilities'    => array( 'content/summarize-post' ),
        'capabilities' => array( 'tools' ),
    ) );
}

Da questo momento, un client MCP (Claude Desktop, Cursor, Continue.dev, ChatGPT con supporto MCP) può connettersi al sito via STDIO o streamable HTTP e vedere summarize-post come tool disponibile. L'AI assistant può decidere autonomamente di chiamarlo quando l'utente chiede "riassumi l'ultimo post pubblicato".

Tre guardrail operativi non negoziabili

Quando esponi abilities via MCP, la superficie d'attacco aumenta: un client compromesso potrebbe chiamare strumenti con input malevoli. Tre regole ferree.

1. Whitelist di ability id: non esporre mai tutte le abilities registrate. Decidi tu quali sono "esterne".
2. Rate limit per ability: aggiungi un token bucket. Il Plugin Team consiglia wp_ai_client_rate_limit() con scope per user_id e ability_id.
3. Log audit obbligatorio: ogni chiamata MCP deve loggare user_id, ability_id, input_hash, tokens_used, timestamp. Il log non è opzionale, è la base del GDPR compliance.

WP AI Client: il collante tra plugin e provider

WP AI Client è la libreria che rende il pattern portabile. Vediamo le tre feature che lo distinguono da una semplice wp_remote_post() custom.

Feature 1: provider abstraction con capability matrix

$client = wp_ai_client();
$capabilities = $client->get_capabilities();
// output:
// array(
//   'text_generation' => array( 'openai', 'anthropic', 'ollama' ),
//   'image_generation' => array( 'openai' ),
//   'embeddings' => array( 'openai', 'ollama' ),
// )

Il plugin può scegliere dinamicamente un provider in base a cosa deve fare. Se domani Anthropic rilascia image generation, non devi toccare il codice: aggiorni il client.

Feature 2: capability-based access e kill switch

// disabilitare globalmente l'AI per manutenzione
add_filter( 'wp_ai_client_enabled', '__return_false' );
// oppure per singola ability
add_filter( 'wp_ai_client_ability_enabled', function( $enabled, $ability_id ) {
    if ( $ability_id === 'content/summarize-post' && ! current_user_can( 'manage_options' ) ) {
        return false;
    }
    return $enabled;
}, 10, 2 );

Il kill switch wp_ai_client_enabled è fondamentale per chi gestisce flotte di siti: un command injection nel prompt o un breach del provider si bloccano modificando un constant in wp-config.php.

Feature 3: cost tracking integrato

$response = $client->generate_text( array( ... ) );
update_option( 'mio_plugin_ai_cost_june', ( get_option( 'mio_plugin_ai_cost_june' ) ?: 0 ) + $response['cost_usd'] );

$response['cost_usd'] è calcolato dal client conoscendo il pricing del modello usato. Niente più fogli Excel per riconciliare le fatture OpenAI a fine mese.

Caso reale: agenzia con 12 siti clienti

Un'agenzia milanese con cui lavoro ha adottato il pattern su un plugin interno di content brief. Prima: 12 siti, 12 plugin leggermente diversi, 3 provider LLM contrattati a tariffe diverse. Dopo sei mesi col pattern:

• Tempo medio di sviluppo di una nuova ability: passato da 4 ore a 1,5 ore (l'abilità è dichiarativa, l'AI client è condiviso).
• Costo medio mensile AI: sceso del 32% grazie al routing automatico Ollama per task semplici e GPT-4o solo per task complessi.
• Audit GDPR: tempo di generazione report passato da 2 giorni a 4 ore, perché i log sono strutturati e non sparsi in 12 codebase diverse.
• Provider lock-in: eliminato. Sono passati da OpenAI a Anthropic Sonnet in 2 settimane durante un aumento di prezzo, senza toccare i plugin dei clienti.

Roadmap di adozione in 5 step

Una sequenza realistica per adottare il pattern in produzione, basata sull'esperienza con clienti di taglia diversa.

Step 1: audit del plugin esistente

Identifica le funzioni AI attuali. Per ognuna chiediti: usa una API key hardcoded? Ha capability check? Logga le chiamate? Se la risposta è "no" a due su tre, è un candidato alla migrazione.

Step 2: installa WP AI Client

# richiede WP-CLI 2.10+ e PHP 8.1+
wp plugin install wp-ai-client --activate
wp ai-client provider add openai --api-key="$OPENAI_KEY"
wp ai-client provider add ollama --endpoint="http://localhost:11434"

Il comando wp ai-client provider add è la novità 2026: permette di configurare i provider da CLI senza editare costanti a mano.

Step 3: converti una ability esistente

Parti da una singola ability a basso rischio (es. "genera meta description"). Riscrivila seguendo lo schema visto sopra, testa in staging, poi promuovi.

Step 4: esponi via MCP

Installa wp-abilities-mcp-adapter, registra il server MCP, testa la connessione da Claude Desktop o Cursor. Valida che le abilities siano elencate e che i permission callback funzionino.

Step 5: monitora e itera

Imposta un cron giornaliero che aggrega mio_plugin_ai_cost_<mese>, mio_plugin_ai_calls_<mese>, e invia report via email. Rivedi le abilities ogni trimestre: alcune saranno sotto-utilizzate e potranno essere rimosse.

Errori comuni che vedo nelle review

Dopo aver revisionato una dozzina di plugin AI nel 2026, ecco gli errori ricorrenti da evitare.

Errore 1: ability troppo generica

Creare un'ability do_anything($instruction) che accetta un prompt libero e decide lei cosa fare. Sembra flessibile, ma distrugge la capability matrix dell'AI client e rende impossibile il rate limiting. Un'ability deve fare una cosa sola, bene.

Errore 2: permission_callback ingenuo

# esempio codice
'permission_callback' => '__return_true',

Sembra assurdo, ma l'ho visto in due plugin pubblicati nel 2025. Mai. Sempre capability check basato su current_user_can() e validazione dell'input.

Errore 3: log solo in debug.log

Scrive in wp-content/debug.log è comodo ma non è un audit trail. Serve un log strutturato (custom table o rotazione file) con campi indicizzati: user_id, ability_id, cost, timestamp.

Errore 4: dimenticare la deprecazione

Il Plugin Team 2026 rilascia WP AI Client con API che evolvono rapidamente. Un'ability deprecata va marcata con 'status' => 'deprecated' e mantenuta per almeno 6 mesi. Non rimuovere mai silenziosamente.

FAQ

Il pattern funziona anche con plugin gratuiti pubblicati su .org?

Sì, anzi: il Plugin Team 2026 lo raccomanda esplicitamente nei criteri di review. I plugin che adottano abilities + MCP ricevono priorità nella coda di triage. Il tutorial wordpress.tv dell'8 giugno 2026 è nato proprio per supportare gli sviluppatori indipendenti in questa transizione.

Devo abbandonare wp_remote_post() per le chiamate LLM?

Non necessariamente. Se il tuo plugin fa una singola chiamata a una singola API, wp_remote_post() resta valido. Il pattern diventa necessario quando hai più di un'ability, più di un provider, o requisiti di compliance. La regola pratica è: se devi scrivere un wrapper per la chiamata HTTP, stai reinventando WP AI Client.

MCP è compatibile con il vecchio WP 6.x?

No. MCP richiede almeno WP 6.9 per le abilities, e il plugin adapter è testato solo su WP 7.0+. Se il tuo plugin deve supportare WP 6.5, devi restare su REST API classica. Considera questa come una buona scusa per abbandonare il supporto a versioni obsolete.

Posso mischiare abilities registrate e REST endpoint tradizionali?

Tecnicamente sì, concettualmente no. Ogni endpoint REST non mappato su un'ability è una superficie d'attacco non documentata per l'AI assistant. Meglio migrare tutto al pattern, o tenere il legacy fuori dal server MCP.

Il self-hosted LLM (Ollama) è production-ready con questo pattern?

Sì, con cautele. Ollama è supportato da WP AI Client da aprile 2026, e il pattern di routing "Ollama per task semplici, cloud per task complessi" è quello che uso di default. Vedi la mia guida a WordPress e LLM self-hosted per i dettagli di setup.

Quanto pesa in performance il pattern rispetto a una chiamata diretta?

Misurato su un sito staging: +12ms per chiamata a causa del layer di astrazione. Su un endpoint REST chiamato 100 volte al minuto è trascurabile. Se hai un carico anomalo (es. bulk generation di 1000 articoli), valuta batch async con WP-CLI asincrono.

Conclusione: il pattern è il futuro, ma adottalo con criterio

Il pattern abilities + MCP + WP AI Client non è una moda passeggera. È la risposta del Plugin Team a un bisogno reale: plugin AI portabili, sicuri e manutenibili. Detto questo, adottalo solo se il tuo caso d'uso lo giustifica. Un plugin che genera una sola stringa non ha bisogno di MCP, ma se stai costruendo un prodotto commerciale o un sistema interno per agenzia, questo pattern ti farà risparmiare mesi di refactoring.

Checklist operativa pre-pubblicazione

• Almeno un'ability registrata con input_schema e output_schema documentati
• Permission callback su ogni ability
• Rate limit configurato per ability e per user
• Log audit attivo con campi user_id, ability_id, cost, timestamp
• Kill switch wp_ai_client_enabled testato e funzionante
• Server MCP in staging con test da Claude Desktop o Cursor
• Cost tracking aggregato su base mensile
• Policy di deprecazione scritta per le abilities

Se la checklist è verde, il tuo plugin è pronto per la review 2026 del Plugin Team. Se è rossa su più di due punti, vale la pena rivedere l'architettura prima di pubblicare.

Riferimenti utili per approfondire

• Tutorial ufficiale "Build your first AI-powered WordPress plugin" su wordpress.tv - il video di riferimento da cui è nato l'articolo
• Repository GitHub WordPress/wp-ai-client - codice della libreria ufficiale del Plugin Team
• Specifica Model Context Protocol di Anthropic - documento tecnico del protocollo MCP
• WordPress 7.0 AI Connectors: guida operativa - come i Connectors dialogano con WP AI Client
• WPVibe e MCP per WordPress - caso commerciale di adozione MCP lato utente finale
• Repository WordPress/wp-abilities - reference implementation della Abilities API
• Documentazione Plugin Team su review 2026 - criteri aggiornati per plugin AI
• Esempio completo di plugin MCP-based - codice di partenza pronto all'uso
• OpenCode per temi WordPress con MCP - integrazione lato IDE di MCP per sviluppatori
• Creare plugin WordPress con AI: metodo completo - workflow completo per chi parte da zero
• AI workflow agenzia WordPress 2026 - come le agenzie adottano il pattern su più progetti
• WP-CLI nel 2026 con AI - automazione CLI del pattern abilities

L'angolo è strategico e di prodotto, non recensione. Vediamo i tre scenari possibili per il 2027-2030, le scelte tecniche che contano, e come posizionarsi. È complementare alla guida su FSE + AI e a WordPress 7.0 AI Connectors.

La domanda giusta: cosa faranno gli utenti nel 2028?

Prima di parlare di page builder e AI, serve capire chi userà cosa. La frattura è tra tre profili utente.

Profilo 1: l'utente business senza competenze tecniche

Marina gestisce un Bed & Breakfast. Vuole un sito. Cosa fa nel 2028?

• Scenario A (AI puro): apre Claude, scrive "creami un sito per un B&B in Toscana con 5 camere, galleria fotografica, modulo prenotazioni, multilingua IT/EN/DE, e integrami con Booking.com". L'AI genera un sito completo in 10 minuti, lo deploya su un hosting, le spiega come gestirlo.
• Scenario B (page builder visuale): compra Elementor Pro, usa un template preimpostato per B&B, personalizza con drag-and-drop, integra un plugin di prenotazioni. Tempo: 4-6 ore.

Chi vince? La risposta non è scontata. Lo Scenario A è più veloce e meno costoso inizialmente, ma richiede un'AI affidabile, un hosting decente, e la capacità di gestire l'evoluzione del sito (aggiornare testi, aggiungere foto, gestire le email). Lo Scenario B è più lento e costoso, ma dà all'utente controllo e prevedibilità.

Profilo 2: l'agenzia di sviluppo

Luca ha un'agenzia di 5 persone, realizza 20-30 siti/anno per clienti corporate. Cosa usa?

• Page builder per prototipi rapidi e siti small-medium
• Custom theme PHP/ACF per progetti enterprise
• AI per generare boilerplate, snippet, copy
• Hosting gestito per clienti (Kinsta, WP Engine, Rocket.net)

L'agenzia non ha un vincitore unico: usa l'AI dove accelera, page builder dove serve controllo visuale, custom code dove serve performance e scalabilità.

Profilo 3: lo sviluppatore senior

Sara sviluppa plugin e temi custom per clienti enterprise. Lavora con PHP, JavaScript moderni, e ACF. Cosa fa con l'AI?

• Usa Cursor o Claude Code per scrivere plugin più velocemente
• Usa AI per refactoring e test generation
• Non usa page builder (la sua produttività è nel codice)
• L'AI è uno strumento, non un sostituto del suo lavoro

Sara non è in competizione con i page builder: opera su un altro layer.

I 3 scenari per i page builder nel 2027-2030

Sulla base delle tendenze attuali e delle scelte di produttori come Beaver Builder, Elementor, Bricks, e Divi, ecco i tre scenari più probabili.

Scenario 1: page builder come "design system visuale" (realista, 50%)

I page builder evolvono da "strumenti per costruire pagine" a design system visuali che l'AI può interrogare e modificare. L'utente finale usa ancora il page builder per la personalizzazione fine, ma l'AI può generare siti completi che rispettano il design system del page builder.

Concretamente: l'AI genera la struttura del sito, sceglie i blocchi del page builder, li configura. L'utente apre il page builder, vede il sito finito, modifica dove vuole con il visual editor.

Esempio reale: Elementor AI 2.0 (rilasciato in beta a maggio 2026) permette di descrivere una sezione in linguaggio naturale e vederla generata direttamente nel builder, con i widget nativi. L'utente può poi modificare ogni widget come al solito.

Pro: integra l'AI senza stravolgere il modello. Contro: richiede all'AI di conoscere il DSL del page builder (cosa non banale).

Scenario 2: page builder come "legacy" (possibile, 25%)

L'AI diventa così brava a generare siti completi da prompt che i page builder tradizionali vengono percepiti come obsoleti. I visual editor rimangono per chi vuole "vedere" cosa sta costruendo, ma la maggior parte degli utenti usa solo l'AI.

Concretamente: 70% dei nuovi siti WordPress nel 2028 viene generato via prompt AI, 30% tramite page builder. I page builder tradizionali si contraggono a una nicchia.

Pro: mercato si semplifica, focus su qualità. Contro: chi ha investito in page builder perde terreno.

Scenario 3: page builder come "editor AI-augmented" (possibile, 25%)

I page builder diventano ambienti collaborativi uomo + AI dove l'utente e l'AI co-editano il sito in tempo reale. L'utente fa modifiche strutturali, l'AI fa suggerimenti contestuali, copy, ottimizzazioni.

Concretamente: un'interfaccia tipo Figma + Cursor, dove muovi un blocco e l'AI propone varianti, ottimizza per conversioni, scrive il copy.

Pro: il meglio dei due mondi. Contro: complessità tecnica alta, curva di apprendimento ripida.

Cosa sta facendo Beaver Builder (e perché è interessante)

La scelta di Beaver Builder è un caso studio. Invece di mettere un "pulsante AI" nel builder (come hanno fatto in tanti), il team sta lavorando a un editor collaborativo in tempo reale dove l'utente e l'AI possono co-editare la pagina.

McCullough spiega che l'AI migliore in un page builder non è quella che "genera una sezione", ma quella che capisce il contesto della sezione esistente e propone miglioramenti chirurgici. L'AI lavora sui blocchi già presenti, non ne crea di nuovi da zero.

// Esempio concettuale di AI contestuale nel page builder
const block = editor.getSelectedBlock();

// L'AI analizza il blocco nel contesto della pagina
const suggestions = await ai.suggest({
    type: 'inline_edit',
    block: block,
    page_context: editor.getPageContext(), // altri blocchi, tema, brand
    user_goal: 'increase_readability',
});

// L'utente vede le 3 varianti inline, applica quella preferita
editor.showInlineAISuggestions( block, suggestions );

È un approccio molto diverso dal "clicca qui per generare una sezione con AI". Meno spettacolare, ma più integrato nel workflow reale.

Le 5 decisioni strategiche per chi sviluppa page builder

Se stai sviluppando (o gestisci) un page builder, ecco le 5 decisioni strategiche che contano per il 2026-2028.

Decisione 1: integrare l'AI come layer sopra o come motore nativo

Scelta attuale di Elementor: AI come layer (pulsanti AI ovunque). Scelta di Beaver Builder: AI come motore contestuale (in lavorazione). La prima è più veloce da implementare, la seconda è più profonda e più difficile da copiare.

Decisione 2: supportare il Full Site Editing o restare sul modello classico

Il FSE di WordPress è un paradigma diverso dal page builder classico: blocchi nativivi, template parts, global styles. I page builder possono:

• (a) Competere con FSE, offrendo un'esperienza più ricca
• (b) Integrarsi con FSE, offrendo blocchi custom che lavorano dentro l'editor nativo
• (c) Ignorare FSE, scommettendo sulla nicchia "visual editor ricco"

Bricks ha scelto (a) e (b): compete con FSE per i siti avanzati, ma offre compatibilità. Elementor ha fatto scelte ibride. Divi è più fedele al modello classico.

Decisione 3: pricing basato su features o su AI credits

Sta emergendo un modello in cui le funzioni AI sono "a consumo" (crediti), mentre le funzioni classiche restano in abbonamento. È un modello più giusto per l'utente (paghi solo quello che usi) ma più complesso da gestire.

Decisione 4: plugin gratuito o premium

La maggior parte dei page builder ha un tier gratuito limitato. La scelta per il 2026 è se ampliare il free tier (per intercettare utenti che userebbero solo AI) o restare premium-only (per monetizzare meglio).

Decisione 5: focus su performance o su funzionalità

Bricks è il campione della performance. Elementor è il campione delle funzionalità. La domanda è: nel 2027, gli utenti premieranno la velocità (Core Web Vitals) o le feature?

Cosa significa per le agenzie

Le agenzie che oggi usano page builder per il 70% del loro lavoro devono riposizionarsi. Tre raccomandazioni concrete.

1. Smetti di vendere "il sito", vendi "il sistema"

Un sito statico fatto con page builder vale sempre meno. Un sistema (sito + automazioni + integrazioni + AI custom) vale di più. Riposiziona la tua offerta su quest'ultimo.

2. Impara l'AI almeno quanto hai imparato il page builder

Se la tua produttività viene dal page builder, sei sostituibile dall'AI. Se la tua produttività viene dalla capacità di combinare AI + page builder + custom code + design thinking, sei molto più difficile da sostituire.

3. Offri "AI setup" come servizio

C'è un mercato enorme di aziende che vogliono usare WPVibe, gli AI Connectors di WP 7.0, o agenti custom, ma non sanno da dove partire. Offrire un servizio di setup + formazione è una nicchia remunerativa e scalabile.

Cosa significa per chi usa page builder

Se sei un utente finale che usa un page builder, ecco i consigli pratici.

Consiglio 1: non stravolgere il tuo workflow

Se oggi usi Elementor e funziona, non passare a Bricks solo perché "è più veloce". Il costo di apprendimento potrebbe non valere. Aspetta che l'integrazione AI maturi.

Consiglio 2: testa le funzioni AI ma non fidarti ciecamente

Quando il tuo page builder aggiunge AI, provala. Ma fai sempre review umana di quello che genera, specialmente per copy e design. L'AI sbaglia ancora, e gli errori sono meno tollerabili su un sito live.

Consiglio 3: mantieni la portabilità del sito

Siti costruiti con page builder proprietari possono essere difficili da migrare. Mantieni backup regolari e una exit strategy. Idealmente, costruisci con page builder che esportano in HTML standard o in blocchi FSE nativi.

Esempio tecnico: integrare l'AI come motore contestuale in un page builder

Vediamo come potrebbe funzionare un'integrazione AI contestuale in un page builder (pseudocodice del flusso di Beaver Builder).

// Sistema di suggerimenti AI contestuali
class ContextAwareAI {
    constructor( pageState, userPreferences ) {
        this.pageState = pageState;
        this.userPreferences = userPreferences;
    }

    async suggestBlockImprovement( block ) {
        // 1. Recupera il contesto della pagina
        const context = {
            page_type: this.pageState.getPageType(),
            surrounding_blocks: this.pageState.getSurroundingBlocks( block.id, 2 ),
            theme_tokens: this.pageState.getThemeDesignTokens(),
            brand_voice: this.userPreferences.getBrandVoice(),
        };

        // 2. Chiedi all'AI con contesto specifico
        const response = await this.callAI( {
            model: 'claude-3-5-sonnet',
            system: `Sei un assistente per page builder. Migliori blocchi esistenti
                    senza stravolgerli. Rispondi in JSON con {"variants": [...]}.`,
            user: `Blocco attuale: ${JSON.stringify( block.data, null, 2 )}
                   Contesto: ${JSON.stringify( context, null, 2 )}
                   Obiettivo utente: ${block.userGoal}`,
        } );

        // 3. Restituisci 3 varianti contestualizzate
        return response.variants.map( v => ({
            ...v,
            blockId: block.id,
            // Mantieni la struttura del blocco, cambia solo contenuto/stile
            preserveStructure: true,
        }) );
    }

    async callAI( payload ) {
        // Usa la WordPress AI API (vedi guida AI Connectors)
        return await wpAiRequest( payload );
    }
}

// Uso nell'editor
const ai = new ContextAwareAI( pageState, userPrefs );
const suggestions = await ai.suggestBlockImprovement( selectedBlock );

// Mostra le varianti inline nel page builder
ui.showInlineVariants( selectedBlock, suggestions );

È un pattern più complesso del "clicca e genera", ma molto più integrato con il workflow dell'utente.

Domande frequenti

I page builder sono morti?

No. Stanno evolvendo. Il page builder come strumento puramente visuale sta cedendo spazio a un modello ibrido dove visuale + AI coesistono. La categoria sopravvive, ma il prodotto singolo deve evolversi.

Meglio imparare un page builder o l'AI oggi?

Entrambi, in ordine di priorità: prima il page builder (perché è ancora il modo più prevedibile di costruire un sito), poi l'AI (per accelerare). Non sono alternativi, sono complementari.

Beaver Builder è indietro rispetto a Elementor sull'AI?

No, è in una posizione diversa. Elementor ha integrato l'AI come feature aggiuntiva (più veloce da implementare, meno profondo). Beaver Builder sta integrando l'AI come cambio di paradigma (più lento, più profondo). I due approcci non sono direttamente confrontabili.

L'AI può sostituire un web designer professionista?

Per task semplici (landing page, siti vetrina, blog personali), sì, oggi. Per task complessi (e-commerce enterprise, portali custom, integrazioni), no, non ancora. La soglia si alza ogni anno, ma la complessità dei progetti reali cresce più velocemente.

Il Full Site Editing di WordPress rende obsoleti i page builder?

No, ma li costringe a specializzarsi. FSE è ottimo per siti piccoli/medi, ma manca di molte feature che i page builder offrono (conditional display, dynamic content, theme builder avanzato). I page builder che si integrano con FSE hanno il futuro assicurato; quelli che lo combattono sono a rischio.

Vale la pena investire in Bricks (performance) o in Elementor (ecosistema)?

Dipende dal tipo di progetti. Per siti dove la performance è critica (publishing, e-commerce ad alto traffico), Bricks è superiore. Per progetti dove servono molte integrazioni e un ecosistema ampio, Elementor vince. La scelta giusta è progetto-specific.

Quando arriverà un page builder veramente AI-native?

Ci sono già prototipi (Bricks AI, Divi AI 2.0, l'approccio Beaver Builder), ma un page builder "AI-native" nel senso pieno del termine (dove l'AI è il motore primario, non un layer sopra) non esiste ancora. Probabile orizzonte: 2027-2028.

Riferimenti utili per approfondire

• WP Tavern #214 con Robby McCullough - il podcast originale.
• Elementor AI 2.0 release notes - esempio di approccio "AI come layer".
• Bricks Builder AI features - esempio di approccio performance-first con AI.
• Divi AI documentation - altro esempio di integrazione AI.
• Beaver Builder roadmap pubblica - visione strategica del team.
• WordPress FSE documentation - come evolve il core.
• Anthropic Computer Use demo - dove sta andando l'AI agentica.
• FSE + AI per temi a blocchi mrtux.it - guida pratica su FSE + AI.
• WordPress 7.0 AI Connectors mrtux.it - il motore AI lato core.
• Strumenti AI per sviluppatori WordPress mrtux.it - la cassetta degli attrezzi AI.

Questa guida verrà aggiornata quando Beaver Builder rilascerà la sua AI contestuale e quando Elementor AI raggiungerà la versione 3.0. Per discussioni o casi d'uso specifici, l'area commenti è aperta.