AccediPrenota un briefing

Capitolo 2.20

Skill

Come scrivere, testare e pubblicare una skill dello Skills Engine, dove appare una volta attiva e in che modo differiscono le skill del manifest in un plugin. Include un esempio pratico di riepilogo per l'assegnazione degli ormeggi per Harrow Port Authority.

Questa pagina è stata tradotta dall'IA a partire dall'originale in inglese. In caso di dubbi, fa fede la pagina in inglese. Legga questa pagina in inglese

17 minuti di lettura

Tomás Reilly, l'ingegnere di piattaforma presso la Harrow Port Authority, il mese scorso mi ha chiesto perché i suoi pianificatori di ormeggio ricevessero una risposta diversa ogni volta che chiedevano all'assistente "chi c'è su quale ormeggio domani, e cosa è stato spostato?". La risposta era che nessuno aveva indicato all'assistente come dovesse essere una buona risposta. Una skill dello Skills Engine ha risolto il problema in un pomeriggio: i pianificatori ora ottengono ogni volta lo stesso riepilogo in tre parti, con la tabella degli ormeggi per prima, le modifiche rispetto all'ultimo piano sotto e i conflitti per ultimi. Questo capitolo illustra quella skill dall'inizio alla fine, e passa poi all'altro tipo di skill, quella che risiede nel manifest di un plugin.

Due tipi di skill

Nexus usa il termine "skill" per due cose diverse, che vengono costruite in modo diverso.

Skill dello Skills Engine Skill del manifest
Cos'è Un pacchetto SKILL.md nella libreria delle skill Una riga tipizzata nell'array skills[] di un plugin
Chi la scrive Chiunque ne abbia i permessi, nel creatore o nel proprio editor Uno sviluppatore, all'interno di un plugin
Cosa contiene Istruzioni, gli strumenti che può invocare, file e script opzionali Uno schema di input e output, un livello (tier) e i campi richiesti da quel livello
Come raggiunge la piattaforma Convalidata, caricata e pubblicata nello Skills Engine Compilata dal manifest e sincronizzata con il registro delle skill
Chi la esegue L'assistente, gli agenti, i workflow, i pulsanti IA (intelligenza artificiale), Claude Code Il dispatch di UNO (il motore di workflow)
Uso tipico "Riepiloga il piano di ormeggio sempre allo stesso modo" "Esegui il nostro propagatore orbitale su questo passaggio"

Il resto del capitolo le mantiene distinte. Se un paragrafo usa il termine "skill" da solo, si riferisce a una skill dello Skills Engine.

Parte 1: skill dello Skills Engine

Cos'è una skill

Una skill è una cartella. Il suo SKILL.md indica a cosa serve la skill e come svolgere il lavoro; accanto ad esso si trovano gli eventuali file necessari per il lavoro e gli script che esegue. Il motore carica una skill su tre livelli: il nome e la descrizione sempre, le istruzioni quando un'attività richiede la skill e i file solo quando un passaggio ne ha bisogno. Ecco perché un'installazione può contenere duecento skill e non sostenere quasi alcun costo finché non ne viene usata una.

skills/<slug>/
├── SKILL.md      # required: YAML frontmatter, then the instructions
├── skill.yaml    # optional: engine metadata (triggers, aliases, tags, capabilities)
└── scripts/      # optional: bundled with the skill as components

Il nome della directory deve coincidere con lo slug della skill. Una mancata corrispondenza genera un avviso di convalida che vale la pena correggere, poiché lo slug è il modo in cui la libreria abbina un caricamento a una skill esistente.

Frontmatter di SKILL.md

Il frontmatter è codice YAML compreso tra due righe --- all'inizio del file. Il formato richiede tre campi. La convalida si blocca solo per pochi motivi: un nome o una descrizione mancanti, oppure uno slug o un tipo di job già in uso. Tutto il resto viene segnalato come avviso.

Campo Tipo Obbligatorio Contenuto
name string sì L'identificatore univoco, in formato kebab-case
description string sì Cosa fa la skill, massimo 500 caratteri. La libreria e il matcher la leggono, quindi la scriva pensando a un lettore che deve decidere se questa è la skill giusta
allowed-tools string o list sì Gli strumenti che la skill può invocare. Può solo restringere l'allow-list di chi la esegue
triggers list no Comandi slash che invocano direttamente la skill
capabilities list no Capacità strutturate, ciascuna con un name, un description e opzionalmente input_schema, output_schema e examples
version string no Una versione semantica; 1.0.0 se omessa
visibility string no private, team o public
status string no draft, testing o published

Mantenga le istruzioni sotto i 5.000 token circa. Sia specifico e fornisca esempi. Ogni skill dovrebbe svolgere bene un solo compito; se si ritrova a scrivere "e inoltre", probabilmente ha due skill.

skill.yaml

skill.yaml contiene ciò che serve al motore per l'individuazione e per la libreria, in modo che SKILL.md rimanga leggibile. I campi letti dal motore includono name, display_name, description, version, status, visibility, triggers, aliases, category, tags, allowed_tools e capabilities. Una capacità può contenere query_patterns, ovvero le formulazioni che il matcher dovrebbe inviarle. Ci sono anche suggerimenti per il calcolo del budget del motore stesso: complexity, estimated_tokens e required_services.

scripts/

Tutto ciò che si trova sotto scripts/ viene incluso esattamente com'è insieme alla skill come componente. Uno script viene eseguito, mai letto nel contesto del modello, e gira in una sandbox. Ne usi uno quando un passaggio prevede calcoli aritmetici o analisi sintattiche (parsing) che un modello non dovrebbe eseguire a mente.

Visibilità e stato

La visibilità stabilisce chi può trovare la skill: private è lei, team è il suo team e public rappresenta tutti i membri dell'organizzazione servita dalla libreria. Nella console la stessa scelta appare come "Solo io", un team come "Ufficio doganale" o l'intera organizzazione; una skill può anche essere condivisa in un pacchetto di dominio tramite la revisione specifica di quel pacchetto.

Lo stato indica in quale fase del suo ciclo di vita si trova la skill.

Stato Significato
draft Lavori in corso; non individuabile
testing In fase di convalida, con accesso limitato
published Disponibile per l'uso generale
deprecated Sostituita; in via di ritiro

Una volta pubblicata, una versione non cambia mai. Nella console, "live", "canary" e "shadow" sono etichette applicate alle versioni, e il ritorno a una versione precedente sposta un'etichetta. Le esecuzioni in corso terminano sulla versione con cui sono state avviate.

Nuova skill · 2 Istruzioni e strumenti
Nuova skill · 2 Istruzioni e strumenti
Il secondo passaggio del creatore mostra la bozza di SKILL.md, i file accanto ad essa con il momento di caricamento di ciascuno, e gli strumenti che la skill può invocare. A una skill di controllo non viene offerto alcuno strumento di scrittura, e una skill può solo restringere l'allow-list di chi la esegue.

Da una cartella a una skill live

Cinque script npm nel repository dello Skills Engine portano una skill dal suo editor alla libreria e dimostrano che è arrivata.

Comando Cosa fa
npm run skill:validate skills/<slug> Analizza (lint) il pacchetto. La pubblicazione richiede zero errori
npm run skill:upload skills/<slug> Convalida e pubblica in un unico passaggio; idempotente
npm run skill:upload skills/<slug> --dry-run Convalida e stampa il piano senza scrivere nulla
npm run skill:publish -- --dry-run skills/<slug> La pubblicazione di livello inferiore dietro il caricamento, stessa pipeline
npm run skill:reconcile Confronta le skill nel suo repository con ciò che è contenuto nella libreria e nel registro delle skill
npm run skill:live:verify Controlla una skill pubblicata dall'inizio alla fine sull'installazione in esecuzione

La pubblicazione scrive due voci, ed entrambe sono importanti. Una è la skill stessa, con il corpo del suo SKILL.md, le capacità, i componenti e il record di qualità; la libreria, l'individuazione e il matching leggono questa voce. L'altra è la voce di registro rispetto alla quale il motore di workflow risolve un dispatch. Una skill che ha raggiunto solo il registro viene eseguita, ma è invisibile nella libreria finché non viene caricata.

La pubblicazione è idempotente. Una skill invariata non produce alcuna operazione (no-op), e una skill esistente viene abbinata tramite il suo slug e aggiornata sul posto, mai ricreata. Se carica gli stessi byte di una versione già pubblicata, otterrà indietro quella stessa versione con CONTENT_HASH_ALREADY_PUBLISHED, non un duplicato.

skill:reconcile confronta le skill del suo repository con la libreria, il registro e l'inventario del motore di workflow, e segnala tutto ciò che esiste in un posto ma non in un altro. skill:live:verify si spinge oltre sull'installazione in esecuzione: verifica che entrambe le voci esistano e puntino l'una all'altra con lo stesso hash del contenuto, che un dispatch di prova (dry-run) del tipo di job della skill venga accettato, che la skill appaia nell'elenco e nei dettagli della libreria, che possa essere invocata e che l'audit trail colleghi la pubblicazione, il dispatch e l'esecuzione tramite lo slug e l'id della richiesta.

Da una workstation, il caricamento raggiunge il servizio di conoscenza dell'installazione, nexus-graphrag, tramite un port-forward, e richiede la chiave di servizio dello Skills Engine nell'ambiente. Carichi la chiave senza stamparla a schermo:

kubectl -n nexus port-forward svc/nexus-graphrag 8090:8090
read -rs GRAPHRAG_SKILLS_ENGINE_SERVICE_KEY
export GRAPHRAG_SKILLS_ENGINE_SERVICE_KEY
GRAPHRAG_URL=http://localhost:8090 npm run skill:upload skills/berth-allocation-summary

All'interno del cluster, in un job della pipeline, l'indirizzo predefinito si risolve da solo e GRAPHRAG_URL non è necessario. Ottenga la chiave tramite la procedura di gestione dei segreti della sua organizzazione. Non deve mai finire nel repository, nella cronologia della shell o nell'output di un comando.

Test, approvazione e messa in produzione (going live)

Una skill raggiunge la libreria come bozza e il creatore la trattiene lì finché non vengono superati tre passaggi.

Controllo Cosa fa
Casi di test Ogni caso deve essere superato prima che la skill possa essere inviata per l'approvazione. Un caso può essere rimosso solo fornendo una motivazione, che gli approvatori vedranno.
Un'esecuzione di prova (dry run) in modalità shadow La skill viene eseguita su lavoro passato, dove nessuno vede le risposte, e i suoi risultati vengono confrontati con ciò che una persona aveva deciso all'epoca.
Una revisione alla cieca da parte di un modello di un'altra famiglia Cerca un controllo mancato, una fonte inventata e un'istruzione nascosta che la skill ha seguito quando non avrebbe dovuto.

Poi l'approvazione. Una skill che aggiunge uno strumento di scrittura viene trattenuta finché due persone non la approvano con le proprie passkey, e la persona che l'ha proposta non può essere una di loro (PUBLISH_NEEDS_APPROVAL). Successivamente va live in modalità shadow, poi in canary per una singola unità dietro gate con nome, infine per tutti. Se un gate canary non viene soddisfatto, il canary si arresta da solo e tutti rimangono sulla versione precedente; per inviarla a tutti in anticipo sono necessari una motivazione e un secondo approvatore (CANARY_GATE_NOT_MET).

Nella versione Community il creatore, la libreria, le versioni e i test sono tutti presenti, e il proprietario pubblica da solo una volta superati i test. Il rilascio canary, l'approvazione di due persone, la sincronizzazione dei plugin e l'unione dei duplicati sono inclusi nella versione Enterprise.

Nuova skill · 4 Pubblica
Nuova skill · 4 Pubblica
La schermata di pubblicazione mostra perché una skill è trattenuta, chi deve dare il consenso e come va live: approvata, in shadow, in canary dietro gate con nome, poi per tutti. Il proponente non può approvare la propria modifica e l'ultima versione rimane pronta per un eventuale ripristino.

Dove compaiono le skill

La stessa skill pubblicata raggiunge le persone in cinque punti.

  1. L'assistente abbina una richiesta a una skill in base alla descrizione, ai trigger e ai pattern di ricerca, e segue le istruzioni della skill.
  2. Gli agenti e i workflow invocano le skill come passaggi. Un passaggio del workflow indica il nome della skill; l'esecuzione registra quale versione è stata usata.
  3. I pulsanti IA sulle schermate eseguono ciascuno una skill. Un amministratore può aprire "Informazioni su questo pulsante" per vedere quale skill esegue un pulsante, cosa legge e chi l'ha modificata per ultimo, e può disattivare il pulsante senza toccare la skill.
  4. Il suo IDE (ambiente di sviluppo integrato) e Claude Code raggiungono la libreria tramite il Workbench e tredici strumenti MCP (Model Context Protocol): tra cui list_skills, get_skill, match_prompt, discover_skills, invoke_skill, record_execution, create_skill, import_skill, get_generation_job e sync_skills_local. Ogni chiamata viene eseguita con l'identità della persona che l'ha avviata, all'interno della sua allow-list.
  5. La libreria delle skill stessa, dove le persone sfogliano, eseguono e suggeriscono modifiche alle skill, e gli amministratori vedono il proprietario, gli utenti, le esecuzioni e la spesa di ciascuna skill.

Qualunque cosa esegua una skill, la skill non può ampliare ciò che l'esecutore è autorizzato a fare: invoca solo gli strumenti presenti nell'allow-list dell'esecutore e legge solo ciò che quella persona può aprire (SKILL_CANNOT_WIDEN_TOOLS). Un'esecuzione priva di un instradamento del modello viene rifiutata anziché tirata a indovinare (SKILLS_ENGINE_BINDING_MISSING); il dispatcher sceglie l'instradamento dalla configurazione dei modelli propria dell'organizzazione.

Informazioni su questo pulsante
Informazioni su questo pulsante
Informazioni su questo pulsante mostra la skill eseguita da un pulsante IA, le tre fonti che legge, chi l'ha scritta e revisionata e cosa è cambiato nell'ultima versione. La disattivazione del pulsante lo rimuove ovunque simultaneamente; la skill e tutte le risposte passate rimangono.

Esempio pratico: un riepilogo di assegnazione degli ormeggi per Harrow

I pianificatori di Harrow avevano già due strumenti di sola lettura nella loro allow-list, provenienti dal plugin di pianificazione degli ormeggi di Harrow: berth-plan.read restituisce il piano per una data, e vessel-call.read restituisce uno scalo nave con la relativa finestra di arrivo e la lunghezza. Alla skill non serve altro. Non effettua mai scritture, quindi non richiede mai due approvatori.

---
name: berth-allocation-summary
description: Summarise tomorrow's berth plan at Harrow for the planning desk. Use when someone asks who is on which berth, what moved since the last plan, or where two calls clash.
allowed-tools: berth-plan.read, vessel-call.read
triggers:
  - /berth-summary
capabilities:
  - name: summarise_berth_plan
    description: The berth table, the changes since the last plan and any clashes, for one date
version: 1.0.0
visibility: team
status: draft
---

# Berth allocation summary

## When to use
A planner asks about the berth plan for a date, or asks what changed.

## Steps
1. Read the plan for the date with berth-plan.read. If no date is given, use tomorrow.
2. For each call on the plan, read it with vessel-call.read.
3. Write the berth table first: berth, vessel, arrival window, length overall.
4. Then list what moved since the previous plan, one line per change, with the reason the plan records.
5. Then list clashes: two calls whose windows overlap on one berth, or a vessel longer than the berth.
6. Cite the plan's version for every line. Never guess a time the plan doesn't give.

## Output
Three headed sections, in this order: Berths, Changes, Clashes. Write "No clashes" when there are none.

Il file skill.yaml accanto ad essa fornisce alla libreria un nome visualizzato, una categoria e le formulazioni che il matcher deve indirizzare qui:

# skill.yaml, beside SKILL.md
name: berth-allocation-summary
display_name: "Berth allocation summary"
version: "1.0.0"
status: draft
visibility: team
category: operations
tags:
  - berths
  - planning
triggers:
  - "/berth-summary"
allowed_tools:
  - berth-plan.read
  - vessel-call.read
capabilities:
  - name: "summarise_berth_plan"
    description: "Berth table, changes since the last plan and clashes, for one date"
    query_patterns:
      - "who is on which berth tomorrow"
      - "what moved on the berth plan"
      - "any berth clashes on *"

Poi i comandi, dalla radice del repository:

npm run skill:validate skills/berth-allocation-summary
npm run skill:upload skills/berth-allocation-summary --dry-run
npm run skill:upload skills/berth-allocation-summary

Tomás ha aggiunto sei casi di test nel creatore: una giornata ordinaria, una giornata con un arrivo in ritardo che ha spostato due scali, una giornata con un vero e proprio conflitto, una data ancora priva di piano, una nave troppo lunga per il suo ormeggio e una richiesta che tentava di far proporre alla skill un nuovo ormeggio (non dovrebbe; non ha alcuno strumento di scrittura). L'esecuzione di prova ha riprodotto venti piani passati in modalità shadow. Una volta superati i casi, un revisore dell'ufficio pianificazione l'ha approvata ed è andata live per il team di pianificazione. L'assistente ora risponde alla domanda sempre con la stessa struttura, e il pulsante IA dei pianificatori sulla pagina del piano di ormeggio esegue la stessa skill.

Parte 2: skill del manifest

Una skill del manifest è l'unità di calcolo pubblicata da un plugin. Viene dichiarata nell'array skills[] del manifest, convalidata dall'SDK (software development kit) quando si esegue create-nexus-plugin validate, compilata nel corpo del registro da compileRegistry e sincronizzata con il registro delle skill. Non si scrive mai codice SQL del registro a mano, pertanto la riga inviata dalla piattaforma e il descrittore dichiarato non possono disallinearsi.

Ogni skill del manifest richiede id, displayName, description, tier, classification, inputSchema e outputSchema. Dichiari anche timeoutMs: è un numero intero compreso tra 1.000 e 21.600.000 (da un secondo a sei ore), e un valore fuori da questo intervallo viene rifiutato con TIMEOUT_OUT_OF_BOUNDS. dataResidency è any, eu o us, e any è il valore predefinito.

Il id è in formato lower_snake, e la chiave di dispatch del registro è il tipo di job dotato di namespace <plugin name>.<skill id>, in modo che due plugin possano avere entrambi una skill summarise senza entrare in conflitto. Ecco l'unica skill del modello, abbreviata:

{
  "id": "sentiment_score",
  "displayName": "Sentiment score",
  "description": "Deterministic lexicon-based sentiment score for a piece of text.",
  "tier": "host_callback",
  "classification": "tenant",
  "dataResidency": "any",
  "inputSchema": { "type": "object", "properties": { "text": { "type": "string", "minLength": 1 } }, "required": ["text"] },
  "outputSchema": { "type": "object", "properties": { "score": { "type": "number" } }, "required": ["score"] },
  "hostCallback": {
    "service": "my-plugin",
    "port": 8080,
    "path": "/internal/skills/sentiment_score",
    "maxRequestBytes": 262144,
    "maxResponseBytes": 16384,
    "tenantHeader": "X-Organization-ID"
  },
  "timeoutMs": 10000
}

I cinque livelli

Il livello non è un'etichetta. Ogni livello ha i propri campi, e un campo che appartiene a un altro livello viene rifiutato con FIELD_NOT_FOR_TIER anziché essere ignorato silenziosamente.

Livello Richiede Raggiunge un modello Chi lo esegue
host_callback hostCallback: il suo Service, la relativa porta, un percorso ed entrambi i limiti di byte No La piattaforma invia tramite POST l'input al suo Service, all'interno del suo namespace
plugin_queue queueName, scritto <plugin name>.<name> No Il suo worker, prelevando dalla sua coda
tool_using systemPrompt e tools[]; livello di fiducia core o verified Sì La piattaforma, tramite l'AI Provider Router; ogni chiamata a uno strumento passa attraverso un esecutore presente nell'allow-list
llm_only systemPrompt; livello di fiducia core o verified Sì La piattaforma, una chiamata tramite l'AI Provider Router
map map.perItemJobType, indicando un'altra skill dello stesso manifest che non sia una mappa Solo tramite la sua destinazione La piattaforma esegue la destinazione una volta per elemento e raccoglie i risultati

Nessuno dei due livelli di modello indica un provider o un modello. Il router li sceglie entrambi dal pool proprio dell'organizzazione che effettua il dispatch. Uno strumento in una skill tool_using indica uno di sei esecutori: standing_service_call (il suo Service), graphrag, graphrag_query, graphrag_search, h3 o web_search. Qualsiasi altro viene rifiutato con EXECUTOR_NOT_PERMITTED. I tre esecutori del grafo di conoscenza accettano solo i nomi di strumento graphrag_query e graphrag_search, poiché l'esecutore esegue l'operazione da cui lo strumento prende il nome.

Nel registro esistono due livelli che un plugin non può dichiarare: le catene (chains) e le skill che vengono eseguite autonomamente sono scritte esclusivamente dalla piattaforma. Una sincronizzazione che ne indica uno viene rifiutata per intero.

Quale livello usare

  • host_callback quando il lavoro è una funzione dell'input calcolata dal suo codice: un punteggio, un calcolo, una ricerca nel suo schema. È il più semplice da testare ed è il valore predefinito del modello. Protegga la rotta di callback: un percorso in un manifest non è un segreto, e la rotta deve verificare la chiamata della piattaforma ed estrarre l'organizzazione da essa, mai dal corpo del messaggio. La dichiari auth: internal e vi monti requireService (Fastify) o serviceMiddleware (Express). La protezione rifiuta un token emesso per chiunque altro. Risponda rapidamente e renda innocuo un secondo invio dello stesso job.
  • plugin_queue per lavori più lunghi che una persona attende, in cui il suo worker gestisce il ciclo di vita. Il worker deve portare l'esecuzione a running quando inizia e a uno stato terminale quando finisce; un worker che si limita a inviare il risultato lascia l'esecuzione nello stato queued per sempre.
  • llm_only quando una singola chiamata al modello con un prompt di sistema fisso svolge il lavoro, e il suo plugin è core o verified.
  • tool_using quando il modello ha bisogno di invocare strumenti in un ciclo, sempre e solo a livello core o verified.
  • map quando desidera che la piattaforma distribuisca (fan out) una delle sue altre skill su un elenco.

La mia skill di propagazione orbitale presso Corrán Orbital è una host_callback. Il nostro plugin è community, quindi i livelli basati su modello non sono mai stati un'opzione, e non ne sento la mancanza: un propagatore che desse una risposta diversa il martedì sarebbe peggio che inutile.

Approvazione prima di ogni esecuzione

Una skill del manifest che non deve mai essere eseguita per sola decisione di una macchina lo dichiara:

"approval": { "required": true, "reason": "Re-planning a pass needs the flight dynamics lead." }

required è sempre true; una skill che non necessita di approvazione omette il blocco. reason è ciò che vede l'approvatore, da 1 a 500 caratteri dopo la rimozione degli spazi iniziali e finali (trimming), e qualsiasi altra forma viene rifiutata con APPROVAL_INVALID. Un dispatch della skill viene quindi trattenuto: il dispatch risponde 202 con status: "awaiting_approval" e un waitpointId, e solo l'approvazione di una persona designata lo sblocca, una sola volta. Un dispatch di tipo batch, map o chain di una skill trattenuta viene rifiutato con SKILL_APPROVAL_NOT_HOLDABLE, poiché una distribuzione (fan-out) non può trattenere i propri elementi. Mostri la risposta trattenuta e lasci decidere all'approvatore; non effettui il dispatch per poi chiedere il consenso.

Sincronizzazione con il registro

Ogni sincronizzazione è dichiarativa e verificata per intero. Invii ogni volta il set completo di skill: una skill tralasciata viene disabilitata, mentre la cronologia delle sue esecuzioni rimane. Una sola skill non valida rifiuta l'intera sincronizzazione con SYNC_CONTRACT_VIOLATION, elencando tutte le violazioni insieme e senza scrivere nulla, cosicché un plugin non risulti mai aggiornato a metà. Il Capitolo 2.22, Il runtime dei plugin, tratta la chiamata di sincronizzazione e il modo in cui la piattaforma riconosce quale plugin sta effettuando la chiamata.

Le skill nell'IDE e in Claude Code
Le skill nell'IDE e in Claude Code
Le skill nell'IDE e in Claude Code mostra gli stessi passaggi di convalida, caricamento e pubblicazione dal terminale di uno sviluppatore, con la bozza trattenuta per l'approvazione poiché l'autrice non può approvare la propria modifica.

Scegliere tra i due tipi

Se il compito è "esprimi questo concetto sempre allo stesso modo", si tratta di una skill dello Skills Engine. Se il compito è "esegui il mio codice e dammi la sua risposta", si tratta di una skill del manifest. La maggior parte del lavoro reale finisce per essere entrambe le cose: il riepilogo degli ormeggi di Harrow è una skill dello Skills Engine i cui strumenti provengono da un plugin, e gli strumenti del plugin sono a loro volta dichiarati nel suo manifest. La skill dello Skills Engine è la più economica da modificare tra le due, il che è un ottimo motivo per mantenere lì la formulazione e il giudizio, lasciando l'aritmetica nel plugin.

Il costo è comunque reale in entrambi i casi. Una skill dello Skills Engine non è finita quando il file SKILL.md si legge bene; è finita quando i suoi casi di test vengono superati, la sua esecuzione di prova concorda con quanto deciso dalle persone, e qualcuno diverso da lei l'ha approvata. Metta in preventivo una settimana per una skill che effettua scritture, per la maggior parte dedicata alla fase canary.