cursor/plugins · commit bf0c7cd · 17 novembre 2026, ore 15:24 UTC+01:00

pstack: i principi di Lauren Tan per far lavorare bene gli agenti

Recensione del pstack originale di Lauren Tan, nella cartella pstack/ di cursor/plugins al commit bf0c7cd, versione 0.15.42. Il metodo, i 24 principi di poteto-mode e le condizioni che li rendono efficaci.

Presentazione e commento

Questa presentazione si basa sul pstack originale di Lauren Tan, nella cartella pstack/ di cursor/plugins al commit bf0c7cd, versione 0.15.42: README, poteto-mode, 24 principi e procedure di verifica. Considera anche il suo articolo «The Complete Guide to pstack Pt. 1», letto integralmente. Le conclusioni sono nostre; le cifre di produttività citate dall’autrice non sono prove svolte per questa recensione.

Il parallelismo viene dopo il metodo

Nel README originale Lauren Tan riassume la proposta con «go deep first»: prima capire il problema, dare forma ai dati e verificare il risultato, poi distribuire il lavoro a più agenti. poteto-mode sceglie una procedura e richiama le skill necessarie, dalla diagnosi al rilascio.

La verifica è un’infrastruttura da costruire

Nell’articolo Tan la descrive come «critical infrastructure». La skill dedicata crea per il progetto comandi di avvio e controllo, una mappa delle funzioni e prove osservabili. Chi verifica deve poter ripetere un percorso dell’utente e controllarne gli effetti, non limitarsi a dichiarare che i test passano.

Produrre meno codice, con qualità maggiore

È l’obiettivo che Tan formula nel README con «write less, but higher quality code». I principi spingono a togliere complessità, dare forma ai dati e costruire controlli ripetibili. Il criterio di successo è il comportamento del programma e l’esperienza di chi lo usa, non la quantità di codice o di attività assegnate agli agenti.

I 24 principi di poteto-mode danno all’agente criteri per decidere come lavorare. Lauren Tan li distribuisce fra progettazione, architettura, verifica, delega e apprendimento. Li riassumiamo in dieci nuclei, mantenendo le condizioni che ne limitano l’applicazione.

  • Semplificare prima di aggiungereFare la modifica più piccola che risolve il problema, togliere codice e controlli superflui e ridurre i passaggi che chi legge deve ricostruire. Meno livelli e meno stato da tenere a mente rendono più facile capire dove nasce un errore.
  • Scegliere prima i dati e il modello del dominioDefinire le strutture prima della logica, rappresentare le regole del problema nei dati e usare i tipi per escludere stati impossibili. Quando arriva un requisito nuovo, ripensare il disegno come se quel requisito fosse stato presente dall’inizio, consegnando il cambiamento per passi.
  • Mettere alla prova le premesse e confrontare alternativeSe più correzioni falliscono partendo dalla stessa ipotesi, verificare quell’ipotesi prima di tentare ancora. Per una scelta progettuale nuova, confrontare prototipi concorrenti: una prova osservabile può risolvere ciò che una discussione astratta lascia aperto.
  • Puntare all’esperienza e al risultato finalePreferire poche funzioni curate e utili a molte funzioni approssimative. Nelle migrazioni pianificate, convergere verso l’architettura voluta con confini di verifica espliciti, evitando che gli adattamenti temporanei diventino debito permanente.
  • Dare confini precisi al codiceValidare i dati quando entrano nel sistema e conservare all’interno logica semplice e verificabile. Quando si sostituisce un’interfaccia interna, migrare chi la usa e rimuovere quella vecchia nello stesso intervento, se nessun utilizzatore esterno ne dipende.
  • Progettare per concorrenza e ripetizionePrima di coordinare più attori che scrivono gli stessi dati, chiedersi se possano lavorare su dati separati. Rendere le operazioni idempotenti, cioè capaci di raggiungere lo stesso risultato anche dopo una ripetizione o un’interruzione: sono condizioni concrete perché gli agenti possano lavorare in parallelo senza lasciare duplicati e stati incoerenti.
  • Dimostrare il comportamento, una modifica alla voltaControllare il risultato reale, correggere la causa dell’errore, dividere il lavoro in unità verificabili e scrivere test sul comportamento visibile a chi usa il programma. Quando si presenta una misura, spiegare che cosa la determina ed escludere errori, lavoro saltato e rumore: un numero deve sostenere una decisione.
  • Trasformare il lavoro e le lezioni in strumentiCostruire il piccolo comando o script che esegue e controlla un’attività non banale. Quando una correzione si ripete, incorporarla in tipi, test, controlli automatici o metadati. Il risultato resta utilizzabile dal prossimo agente e verificabile da chi lo supervisiona.
  • Proteggere il contesto del coordinatoreLimitare l’ambito delle fasi e affidare ai delegati le letture e le elaborazioni voluminose, conservando nella conversazione principale risultati e decisioni. L’obiettivo è lasciare al coordinatore il contesto necessario per giudicare il lavoro.
  • Procedere sul lavoro reversibile senza aspettare ogni voltaL’agente prende le decisioni esecutive ragionevoli e presenta un risultato correggibile; la direzione del prodotto e le autorizzazioni restano alla persona. Questo principio riduce le attese senza trasformare l’autonomia in un permesso generale di agire.

L’efficacia nasce dal modo in cui questi principi si sostengono. Strutture dati chiare riducono gli errori che il codice può esprimere; modifiche piccole rendono più facile localizzare quelli rimasti. I comandi di verifica consentono all’agente di osservare un fallimento, correggerlo e riprovare senza chiedere alla persona di eseguire ogni controllo. I test e i vincoli strutturali conservano ciò che si è imparato. Separare lo stato condiviso e proteggere il contesto permette poi di delegare senza perdere la capacità di giudicare il risultato.

Il guadagno più concreto è ridurre correzioni e attese. Il metodo interviene sui punti in cui il lavoro agentico tende a diventare costoso: ipotesi ripetute senza verifica, modifiche troppo estese, controlli improvvisati e risultati che il coordinatore non sa valutare. È una combinazione efficace quando il progetto offre prove attendibili e l’agente le usa davvero. Il costo iniziale è costruire queste condizioni; installare le skill da solo non le crea.

L’ambiente di riferimento è Cursor. Il progetto nasce dalle pratiche di lavoro di Lauren Tan in quell’ambiente. Alla versione recensita comprende già un adattatore ufficiale per Claude Code: la copia viene generata dalla stessa fonte e la CI ne controlla l’allineamento. Le funzioni esclusive di Cursor vengono sostituite oppure saltate; la presenza dell’adattatore non rende identiche le infrastrutture.

L’ingresso più utile è una prova sul proprio progetto. Si parte da una funzione o da un difetto reale, si prepara la verifica e si confrontano risultato, tempo e costo con il metodo già usato. Solo dopo ha senso attivare i pannelli di revisione, le deleghe e le procedure di rilascio. Una mappa delle funzioni mantenuta bene è lavoro condiviso che resta al progetto.

Il costo comprende la manutenzione delle prove. Comandi di controllo, dati iniziali, selettori e documentazione devono seguire l’applicazione. Più revisori richiedono più chiamate ai modelli. La CI dell’originale controlla definizioni, copia generata e test degli script; non misura il miglioramento del software prodotto dagli agenti. Per valutarlo serve una prova sul proprio lavoro.

La nostra lettura. Il valore del lavoro di Lauren Tan sta nell’aver collegato buone pratiche di ingegneria, strumenti di verifica e coordinamento degli agenti in un metodo utilizzabile. Lo adotteremmo partendo da una verifica utile e ripetibile sul programma reale, poi estendendo il parallelismo dove quella prova consente di supervisionarlo. Restano al progetto le decisioni su permessi, aggiornamenti e rilascio.

4
contributori umani
61
Skill di pstack
24
Principi di poteto-mode
23
Procedure di lavoro

Versione analizzata

Repositorygithub.com/cursor/plugins ↗
Analisi eseguita il17 novembre 2026, ore 15:24 UTC+01:00
Commitbf0c7cd80abdbf7fe47b634978a7d1b4071f71a7
feat(pstack): new default models, one-file why and how, statechart fixes, sharpen and reflect text (#1236)
Data del commit14 novembre 2026, ore 19:36 UTC-08:00
Ramomain
Popolarità (al momento dell'analisi)4 autori umani nella storia Git

Verifica allineamento. Per sapere quanto il repository è cambiato dopo questa analisi apri il confronto su GitHub o esegui in un clone aggiornato:

Confronta bf0c7cd80abd con lo stato attuale di main ↗

git fetch origin && git rev-list --count bf0c7cd80abdbf7fe47b634978a7d1b4071f71a7..origin/main

In breve

pstack è il metodo di ingegneria di Lauren Tan per lavorare con gli agenti di programmazione. L’oggetto di questa recensione è esclusivamente pstack/ nel repository ufficiale cursor/plugins, al commit bf0c7cd. poteto-mode sceglie una procedura per il compito e richiama principi e skill, dalla comprensione del problema alle prove del risultato.

Il metodo punta a rendere verificabile ogni incremento prima di moltiplicare gli agenti. Una skill può costruire i comandi per pilotare l’applicazione e una mappa delle sue funzioni: l’agente osserva gli effetti, corregge gli errori e ripete la prova. La qualità dei dati, i confini del codice e la separazione dello stato condiviso preparano questa capacità.

Il progetto nasce per Cursor e nel commit recensito include già un adattatore ufficiale per Claude Code, con una copia generata controllata dalla CI. Le funzioni cloud, Bugbot e automazioni restano legate alle capacità dell’ambiente. Le cifre di produttività dell’autrice non sono misure riprodotte da questa recensione; i quattro adattamenti di terzi sono soltanto link di contesto, senza valutazioni.

Come leggere questo rapporto. Le sezioni vanno dal generale al dettaglio. Le etichette colorate indicano la gravità: Alta richiede un'azione, Media va pianificata, Bassa è un miglioramento, OK è un controllo superato. I dati numerici sono calcolati automaticamente; i giudizi sono dell'analista.

Scopo e casi d'uso

Il punto di partenza è un progetto sul quale l’agente possa osservare e provare il comportamento, con permessi delimitati.

1

Dare all’agente una verifica specifica del progetto

create-verification-skill ricava avvio, diagnosi, comandi di interazione e prove osservabili dal repository. Produce una skill locale e una mappa delle funzioni; richiede di eseguire almeno un percorso completo prima della consegna.

2

Lavorare con più agenti e conservare una responsabilità unica

arena confronta alternative, swarm distribuisce attività e interrogate organizza una critica. Il coordinatore resta responsabile dei risultati; il plugin originale sfrutta le capacità Cursor e ne documenta le sostituzioni in Claude Code.

3

Correggere un difetto o migliorare una prestazione con prove

Le procedure distinguono riproduzione, ipotesi, cambiamento e verifica. benchmark-checklist chiede di spiegare il numero misurato, mentre il percorso di rilascio richiede un verificatore diverso da chi ha scritto il codice.

4

Esplorare stati, transizioni e casi di errore

statechart usa modelli TLA+, TLC e una vista Mermaid. Consente di discutere percorsi di errore, ma un risultato sul modello va riportato al programma reale: non dimostra automaticamente la correttezza dell’applicazione.

Più utile per

  • Chi usa Cursor e può investire in strumenti di verifica del proprio progetto.
  • Chi adotta il plugin ufficiale in Claude Code accettando le sostituzioni e le funzioni non disponibili.
  • Gruppi che vogliono passare dalla fiducia nell’agente a prove ripetibili sul risultato.

Meno adatto a

  • Chi cerca modelli, browser e infrastruttura cloud già forniti da una semplice raccolta di skill.
  • Chi non può provare il programma e vuole usare istruzioni generiche come sostituto della verifica.
  • Chi intende concedere azioni esterne e merge senza permessi e controlli del proprio ambiente.

Architettura

Il prodotto principale è una raccolta di istruzioni. Due piccoli pacchetti di strumenti affiancano le procedure. La mappa seguente descrive responsabilità, non servizi già distribuiti.

INGRESSO E CONFIGURAZIONEpoteto-mode — sceglie fra 23 procedure di lavoropoteto-modesceglie fra 23 procedure di lavorosetup-pstack — ruoli, modelli e budget di ragionamentosetup-pstackruoli, modelli e budget di ragionamentoMETODO CONDIVISO24 principi — forma dei dati, semplicità, prove e delega24 principiforma dei dati, semplicità, prove e delegaSkill operative — architettura, revisione, scrittura e verificaSkill operativearchitettura, revisione, scrittura e veri…Mappa delle funzioni — prodotta per il progetto da controllareMappa delle funzioniprodotta per il progetto da controllareSTRUMENTI E CONFINI ESTERNIwatch-pr e controllo dei piani — Bun, GitHub CLI e processi localiwatch-pr e controllo dei pianiBun, GitHub CLI e processi localistatechart — TypeScript, TLC, Java e MermaidstatechartTypeScript, TLC, Java e MermaidAmbiente dell’agente — modelli, browser, sessioni e credenzialiAmbiente dell’agentemodelli, browser, sessioni e credenziali

Soluzioni ricorrenti

  • Composizione dichiaratapoteto-mode sceglie un percorso fra 23 procedure; le altre skill risolvono compiti specifici. L’ingresso proposto dall’autrice è setup-pstack seguito da poteto-mode.
  • Separazione fra chi scrive e chi verificaLa procedura shipping richiede un giudizio indipendente per ogni PR e lo lega alla modifica verificata. È una regola del metodo, non una protezione di ramo configurata dal plugin.
  • Adattatore ufficiale generatoCursor usa pstack/; Claude Code installa harness/pstack/claude-code. Un generatore aggiunge i riferimenti alla traduzione degli strumenti; la CI controlla che l’albero generato sia allineato.

Dove sta il codice

Righe per area (test inclusi).

skills/statechart9.730
skills/poteto-mode4.311
skills/show-me-your-work42

Linguaggi

TypeScript14 k
JavaScript220
Shell176
Java63

File più grandi

FileRighe
skills/poteto-mode/scripts/watch-pr/policy.ts842
skills/poteto-mode/scripts/watch-pr/github.ts726
skills/statechart/scripts/ir.ts547
skills/statechart/scripts/run.ts506
skills/poteto-mode/scripts/watch-pr/types.ts414
skills/statechart/scripts/passes/regions.ts295
skills/statechart/scripts/frontends/config.ts276
skills/statechart/scripts/passes/label.ts269
skills/statechart/scripts/backends/mermaid.ts249
skills/poteto-mode/scripts/watch-pr/cli.ts223

Scelte progettuali

Usare poteto-mode per scegliere una procedura e richiamare skill specifiche.

Documentata pstack/README.md
ContestoDifetti, prestazioni, nuove funzioni e rilascio richiedono verifiche diverse.
AlternativeScegliere manualmente una skill per volta.
MotivazioneConservare un metodo riconoscibile fra tipi di lavoro diversi.
ConseguenzeIngresso semplice, con prescrizioni e contesto aggiuntivo quando si usa il metodo completo.
Evidenzepstack/skills/poteto-mode/SKILL.md e playbooks/

Generare la distribuzione ufficiale Claude Code dalla fonte originale.

Documentata pstack/README.md, install
ContestoNomi di strumenti, percorsi e modelli differiscono da Cursor.
AlternativeMantenere copie separate oppure rinunciare al secondo ambiente.
MotivazioneUna fonte condivisa e una tabella esplicita di traduzione.
ConseguenzeLa CI rileva copie fuori sincronia; alcune capacità vengono sostituite o saltate.
Evidenzescripts/generate-pstack-harness-trees.mjs; pstack/docs/harness/claude-code.md

Tecnologie

Le dipendenze operative vanno distinte dalle 25 versioni npm del lockfile analizzato.

AmbitoTecnologiaUso nel progetto
MetodoMarkdown e Agent Skills61 cartelle con SKILL.md, di cui 24 principi; il caricamento dipende dall’agente usato.
Strumenti di coordinamentoBun, TypeScript, CommanderControllo di piani e stato delle PR; bootstrap con bun install --frozen-lockfile.
Verifica formaleTLA+, TLC 1.7.4, Java e miseEsplorazione di stati e controesempi, con TLC fissato da versione e checksum SHA-256.
Test degli strumentinode:test, bun:test e fast-checkCasi di errore, fixture, confronti con TLC e generazione di casi; non sono valutazioni dei risultati di un agente.

Skill e altri componenti per agenti

Sono state individuate 61 skill nel pstack originale: 24 sono principi. L’avviso MIT di Lauren Tan è conservato in pstack/LICENSE. I due wrapper sotto agents/ e l’adattatore generato per Claude Code sono verificati anche a mano: non erano rilevati dalla scansione limitata alla cartella.

61
skill
61
proprie
0
di terze parti / derivate
3
con script
SkillOrigineLicenzaTitolare / fonteCartelleScript
architect
Sketch types, signatures, and module structure before code, then stay in the loop while implementation fills in. Use for /architect, 'architect this', 'design this', or non-trivial work where jumping to code would lock in the wrong shape.
PropriaMIT (dal progetto)—repo—
arena
Spawn N parallel candidates at the same task, pick a base, graft the strongest parts of the losers into it. Use for /arena, 'arena this', 'throw it in the arena', or when one attempt at a non-trivial artifact would lock in the wrong shape.
PropriaMIT (dal progetto)—repo—
automate-me
Use for \"automate me\", \"create/update/refresh my -mode skill\", \"turn/capture my preferences or working style into a skill\", or wanting agents to follow how the user works. Drafts or revises a personal -mode skill via create-skill + unslop, optionally pulling fresh evidence from recent transcri
PropriaMIT (dal progetto)—repo—
benchmark-checklist
Vet a perf measurement (limiter, tuning, limits, errors, repeatability, relevance, and whether the work happened) before you report or act on it. Use when you run a benchmark or report a speedup or regression you measured.
PropriaMIT (dal progetto)—repo—
blast-radius
Find what a change could break somewhere else before it ships, beyond the diff, and prove the one fact it's safe because of by running real code instead of writing it up. Use for 'blast radius of X', 'what could this break', or reviewing a small diff you don't trust.
PropriaMIT (dal progetto)—repo—
bro
Restate the last message in plain human language, with no jargon.
PropriaMIT (dal progetto)—repo—
correct
Find the mistakes agents keep repeating in this repo and make each one impossible. Try architecture first, then types, then a lint whose error names the fix, then a test, and write docs last. Prove each check fails on a real past mistake. Repeat this each time the operator corrects you. Use for /cor
PropriaMIT (dal progetto)—repo—
create-formal-verification-skill
Generate a project-local skill that formally verifies the code where a bug costs the most and tests reach the least, in any language, with whichever verification tool fits. Use for /create-formal-verification-skill, \"model-check this race\", \"prove this invariant\", or when concurrency, retries, s
PropriaMIT (dal progetto)—repo—
create-verification-skill
Generate a project-local verification skill that drives your app the way a user does — any language, framework, or platform. Use for /create-verification-skill, \"make a control skill for this repo\", or when a project has no scripted way to prove UI/CLI/service behavior.
PropriaMIT (dal progetto)—repo—
figure-it-out
Design an auditable playbook when no narrower one fits: a large migration, an ambitious multi-part change, or work a human reviews after stepping away. Scales rigor to the task, runs a hypothesis loop, and logs decisions. Use for /figure-it-out or 'figure it out'.
PropriaMIT (dal progetto)—repo—
how
Use for \"how does X work\", code walkthroughs before changing something, and placement / ownership / layering questions (\"where should this live\", \"which package owns this\", \"is this the right layer\"). Explains subsystem architecture, runtime flow, onboarding mental models. Use why for motiva
PropriaMIT (dal progetto)—repo—
in-your-own-words
Restate in your own words what you think the user's goals are and what problem they're trying to solve. Use for /in-your-own-words.
PropriaMIT (dal progetto)—repo—
interrogate
Use for \"interrogate\", \"adversarial review\", \"multi-model review\", \"challenge this\", \"stress test this code\", \"find blind spots\", or \"tear this apart\". Adversaries try to break a change or design, and only findings proven by a run survive.
PropriaMIT (dal progetto)—repo—
ketchup
Catch the user up on what changed in this chat since their last message, in plain words and small visuals. List every item waiting on them with what they need to decide it from the reply alone. Use for /ketchup.
PropriaMIT (dal progetto)—repo—
ketchup-video
Catch the user up like /ketchup, with a short subtitled video of slides for what happened and the waiting calls as text under it. Use for /ketchup-video.
PropriaMIT (dal progetto)—repo—
maintain-formal-verification-skill
Bring a project's formal verification back in line with the code after the code changes: find the commits that touched verified code, update the model, harness, or properties to describe the code as it is now, rerun, and say whether each failure is drift in the verification or a bug in the code. Use
PropriaMIT (dal progetto)—repo—
maintain-verification-skill
Periodic pass that keeps a project's verification skill and feature map honest: parallel source readers per feature, one live session driving every feature, at most one PR of proven corrections. Use for /maintain-verification-skill or \"audit the verify skill\".
PropriaMIT (dal progetto)—repo—
make-bot-ui
>- Use when building a custom UI (page, dashboard, buttons) that should wake a Grok Bot over a webhook, when the user must provide a webhook sender key, or when exposing that UI on Tailscale.
PropriaMIT (dal progetto)—repo—
no-comments
Spawn Comment Sicko, fix accepted findings, and offer encodings for claimed constraints.
PropriaMIT (dal progetto)—repo—
poteto-help
Guides users through pstack setup, /poteto-mode, and picking the skill, playbook, or principle for a task. Type /poteto-help with a question.
PropriaMIT (dal progetto)—repo—
poteto-mode
poteto's agent style for concise, detailed responses, deliberate subagents, unslopped prose, simple code, and verified work. Use for poteto, /poteto-mode, or requests to work in this style.
PropriaMIT (dal progetto)—repo15 (4317 righe)
cancella file, rete, esegue processi, variabili d'ambiente
principle-attack-the-premise
Apply when two or more fixes that share one premise have failed the same gate. Write the premise down and test it directly before you write another fix that assumes it.
PropriaMIT (dal progetto)—repo—
principle-boundary-discipline
Apply when wiring validation, error handling, or framework adapters. Concentrate guards at system boundaries (CLI, config, network, external APIs); trust internal types and keep business logic in pure functions.
PropriaMIT (dal progetto)—repo—
principle-build-the-lever
Apply to any non-trivial work, not just bulk work: edits, migrations, analyses, checks. Build the tool that does it or proves it (codemod, script, generator, or a skill your subagents follow) instead of working by hand. The tool is the artifact a reviewer can rerun.
PropriaMIT (dal progetto)—repo—
principle-encode-lessons-in-structure
Apply when you catch yourself writing the same instruction a second time, or notice a recurring correction. Encode the rule as a lint, metadata flag, runtime check, or script instead of more text.
PropriaMIT (dal progetto)—repo—
principle-exhaust-the-design-space
Apply when facing a novel UI interaction or architectural decision with no precedent in the codebase. Build 2-3 competing prototypes and compare side by side before committing.
PropriaMIT (dal progetto)—repo—
principle-experience-first
Apply when product, UX, or feature-scope tradeoffs come up. Choose user delight over implementation convenience; ship fewer polished features over more rough ones.
PropriaMIT (dal progetto)—repo—
principle-explain-the-number
Apply before you measure, and before you trust, report, or act on a number you measured: a speedup, a regression, a throughput, a latency, or an eval result. Find what limits it, and rule out that it measured something other than the work you think.
PropriaMIT (dal progetto)—repo—
principle-fix-root-causes
Apply when debugging. Trace each symptom back to the first place the system went wrong and fix it there. A guard is a fix only when the state it handles is legitimate.
PropriaMIT (dal progetto)—repo—
principle-foundational-thinking
Apply before writing logic: choosing core types and data structures, sequencing scaffold-vs-feature work, asking what concurrent actors share. Get the data structures right so downstream code becomes obvious.
PropriaMIT (dal progetto)—repo—
principle-guard-the-context-window
Apply when context is filling up: large outputs, long files, repeated reads, fan-out planning. Route bulk to subagents; keep summaries in the main thread, not raw payloads.
PropriaMIT (dal progetto)—repo—
principle-laziness-protocol
Apply when refactoring, evaluating diff size, or tempted to add abstractions, layers, or signal threading. Bias toward deletion and the smallest change that solves the problem.
PropriaMIT (dal progetto)—repo—
principle-make-operations-idempotent
Apply when designing commands, lifecycle steps, or processing loops that run amid crashes, restarts, and retries. Converge to the same end state regardless of partial prior runs.
PropriaMIT (dal progetto)—repo—
principle-migrate-callers-then-delete-legacy-apis
Apply when introducing a new internal API while old callers still exist. Migrate callers and delete the old API in the same wave instead of preserving compatibility layers.
PropriaMIT (dal progetto)—repo—
principle-minimize-reader-load
Apply when reviewing or shaping code that's hard to trace. Count layers between question and answer, and hidden state in the reader's head; collapse one-caller wrappers and shrink mutable scope.
PropriaMIT (dal progetto)—repo—
principle-model-the-domain
Apply when writing stateful logic, or when code branches a lot or repeats a shape assumption across files.
PropriaMIT (dal progetto)—repo—
principle-never-block-on-the-human
Apply when tempted to ask 'should I do X?' on reversible work.
PropriaMIT (dal progetto)—repo—
principle-outcome-oriented-execution
Apply during planned rewrites and migrations with explicit phase boundaries. Converge on the target architecture; don't preserve smooth intermediate states with throwaway compatibility code.
PropriaMIT (dal progetto)—repo—
principle-prove-it-works
Apply after completing a task, before declaring done. Verify against the real artifact (run the feature, read the actual value, inspect the diff), not a proxy, self-report, or 'it compiles.
PropriaMIT (dal progetto)—repo—
principle-redesign-from-first-principles
Apply when integrating a new requirement into an existing design.
PropriaMIT (dal progetto)—repo—
principle-separate-before-serializing-shared-state
Apply when concurrent actors might write to the same file, branch, key, or state object. Eliminate the sharing first; serialize structurally only when one shared writer is a real invariant.
PropriaMIT (dal progetto)—repo—
principle-sequence-verifiable-units
Apply to multi-step work (sweeps, migrations, runs of similar edits) and to how you stack commits and PRs. Break work into small units that each end in a verifiable state, check each before the next, and order delivery so the sequence proves itself to a reviewer.
PropriaMIT (dal progetto)—repo—
principle-subtract-before-you-add
Apply when sequencing an addition, refactor, or rewrite. Remove dead code, redundant validators, and stub references first, then build on the simpler base.
PropriaMIT (dal progetto)—repo—
principle-test-behavior-not-implementation
Apply when you write, change, or keep a test. Assert what the code's users can observe, so that the test fails when that behavior breaks and keeps passing when only the internals change.
PropriaMIT (dal progetto)—repo—
principle-type-system-discipline
Apply when designing types, reviewing a function signature, or writing code in any statically-typed language. Make illegal states unrepresentable, brand semantic primitives, parse external data at boundaries, exhaust variants, derive from authoritative schemas.
PropriaMIT (dal progetto)—repo—
recall
Reconstruct your recent working context from your own chat history, live state, and the shared record (user reports, prior fixes, incidents), then hand back a tight current-state brief. Use for 'recall my work on X', 'catch me up', 'what have I been working on', 'where did I leave off', before start
PropriaMIT (dal progetto)—repo—
reflect
Spawn three parallel review subagents over the active transcript, surface learnings, and route each to a concrete edit on an existing skill. Use when the user says reflect.
PropriaMIT (dal progetto)—repo—
reproduce-and-fix-issues
Reproduce triaged Slack bugs through a configured app-control adapter, verify existing fixes, and open a bounded draft pull request only after before-and-after proof. Use only from the configured Benny repro automation.
PropriaMIT (dal progetto)—repo—
setup-benny
Configure Benny and prepare its triage and repro automations. Use when installing Benny or changing its Slack, tracker, repository, routing, control, model, or budget settings.
PropriaMIT (dal progetto)—repo—
setup-pstack
Configure which models pstack uses per role and at what reasoning budget. Detects your available models and writes an always-applied rule that overrides the skill defaults. Use for /setup-pstack, "configure pstack models", "pstack budget", or changing pstack's model choices.
PropriaMIT (dal progetto)—repo—
sharpen
Make a task deeper, not bigger, then rewrite the prompt. Use for /sharpen.
PropriaMIT (dal progetto)—repo—
show-me-your-work
Keep a reviewable decision trail for long-running or unattended work: a TSV log with one row per decision (what, why, evidence, result). Local by default; commit it when a reviewer needs the trail to trust the result. Use for /show-me-your-work, autonomous or multi-phase runs, or work a human review
PropriaMIT (dal progetto)—repo1 (42 righe)
statechart
Check a TLA+ model of a system that moves between states, such as a product flow, a protocol, or a service, and draw it as a Mermaid statechart. The report gives the shortest path to each state that breaks a rule. Use for /statechart, or to show a bug as a path through states.
PropriaMIT (dal progetto)—repo20 (9696 righe)
cancella file, esegue processi, variabili d'ambiente
swarm
Fan out N parallel workers, drain them, and return one report. Use for /swarm, 'swarm this', or parallel coverage, races, gauntlets, and exploration.
PropriaMIT (dal progetto)—repo—
tdd
Use only when the user explicitly asks for TDD, a failing test, or a regression test, OR when the bug has an obvious cheap local test target. Skip when the test path is unclear, expensive, integration-heavy, or not requested.
PropriaMIT (dal progetto)—repo—
teach
Explain a body of work plainly so a person actually understands it. Runs the `how` and `why` skills and weaves what they find into one clear explanation. Use for 'teach me this', 'help me really understand X', 'explain this change or subsystem to me'.
PropriaMIT (dal progetto)—repo—
technical-writing
Layered technical-writing standard: Diátaxis structure, Google developer style sentences, STE instruction rules, Global English syntax. Use for /technical-writing or when writing or reviewing docs, RFCs, readmes, PR descriptions, or commit messages.
PropriaMIT (dal progetto)—repo—
triage-issue-reports
Triage Slack issue reports with one thread-only verdict, evidence review, cause-aware routing, tracker dedupe, and fail-closed ticket creation. Use only from the configured Benny triage automation.
PropriaMIT (dal progetto)—repo—
typescript-best-practices
TypeScript best practices. Use when reading or editing any .ts or .tsx file.
PropriaMIT (dal progetto)—repo—
unslop
Cut AI tells from any writing.
PropriaMIT (dal progetto)—repo—
why
Use for 'why does X work this way', 'why we picked Y', design rationale, regressions, postmortems, or data-backed thresholds. Returns a cited read on decisions and tradeoffs. Use how for runtime behavior.
PropriaMIT (dal progetto)—repo—

Altri componenti per agenti

TipoElementoDettaglio
Pluginplugin.json

Stato di salute

Sei dimensioni valutate sul codice e sulla documentazione letti. I punteggi non sono risultati di un’esecuzione del progetto.

4,5/5
Valutazione della redazione
Media dei punteggi: 3,8/5

Misura l'impatto positivo che il progetto può avere sul lavoro di chi lo adotta: tiene conto dei punteggi tecnici qui sotto, ma non ne è la media.

ArchitetturaPrincipi, procedure e strumenti separati, con regole di delega e verifica. La copia per Claude Code è generata e controllata, non mantenuta manualmente.
Qualità del codiceGli strumenti hanno componenti distinti, fixture e gestione degli errori; la valutazione è statica e non estende questi pregi al codice generato dagli agenti.
Test e CIPipeline ufficiale su Node 22: validazione dei plugin, controllo della copia Claude Code e test degli script. Il job non esegue tutte le suite Bun né configura TLC per tutti i casi; nessuna esecuzione svolta qui.
Sicurezza e supply-chainPermessi ampi, lettura delle sessioni e strumenti che installano dipendenze. Lockfile Bun e checksum TLC sono presidi utili; non emerge una verifica automatica della distribuzione.
LicenzeMIT con attribuzione originale conservata; licenze permissive per le 25 dipendenze risolte. Due manifest privati senza campo license e dipendenze operative fuori dall’inventario del lockfile.
Manutenzione e communityProgetto ufficiale con guida, contributi e controlli nel monorepository. La cronologia pstack/ è dominata da Lauren Tan; i dati globali di stelle e autori del catalogo non sono attribuiti a questo componente.

Test, documentazione e limiti della verifica

Le suite lette includono unità, fixture di CLI, interruzioni dei processi, corpus TLA+ e proprietà generative. I rilevatori individuano 197 funzioni di test nel quality scan e 210 nel conteggio generale: sono forme sintattiche diverse, non test osservati passare.

Il workflow ufficiale gira su Ubuntu con Node 22. Valida i plugin, controlla la copia generata di pstack per Claude Code ed esegue il glob pstack/skills/*/scripts/test/*.test.ts. Non imposta TLA2TOOLS; i casi che richiedono TLC possono saltare, e il comando non comprende tutte le suite Bun degli altri percorsi.

Il README, la guida e l’adattatore descrivono l’ingresso e i casi non supportati. La copertura automatica dei commenti API è poco significativa per una raccolta soprattutto Markdown. Le prove degli strumenti e i controlli della distribuzione non misurano, da soli, la qualità del codice scritto dagli agenti.

Punti di forza e debolezza

I pregi emergono dalla struttura delle procedure; i limiti riguardano soprattutto la prova di efficacia e i confini operativi.

Punti di forza

  • Verifica costruita per l’applicazioneAvvio, stato iniziale, percorso dell’utente ed effetti osservabili diventano istruzioni e comandi riutilizzabili. La manutenzione della mappa fa parte del lavoro.
  • Metodo selezionabileIl README permette di invocare skill specifiche oltre alla modalità principale. Si può iniziare costruendo una verifica utile e introdurre gli altri percorsi quando il progetto ne ha bisogno.
  • Adattatore ufficiale controllato dalla CIREADME, docs/harness/claude-code.md e il generatore della radice descrivono percorsi, strumenti, modelli e funzioni da saltare. Il workflow verifica che la copia generata non sia fuori sincronia.
  • Principi che arrivano ai controlliIl metodo chiede di trasformare correzioni ripetute in tipi, test, script e controlli automatici. La struttura conserva le lezioni invece di affidarle soltanto alla memoria della conversazione.

Punti di debolezza

  • Le capacità dell’ambiente contanoL’adattatore Claude Code sostituisce gli agenti cloud con worktree locali, rinuncia alle famiglie di modelli non disponibili e salta i passaggi esclusivi di Cursor. La stessa procedura non implica la stessa infrastruttura.
  • Costo iniziale e continuoLa verifica del progetto va costruita e mantenuta. Pannelli di più agenti moltiplicano chiamate e consumo di contesto; non sono pubblicati costi comparabili per gli ambienti supportati.
  • La CI non dimostra l’efficacia del metodoIl workflow esiste e copre definizioni, copia generata e test Node. Non costituisce una valutazione comparativa del codice scritto dagli agenti e non esegue tutti i percorsi che richiedono Bun o TLC.
  • Regole molto prescrittivepoteto-mode interviene su comunicazione, scelta dei modelli, delega, commenti e rilascio. Va confrontato con i contratti e le autorizzazioni del progetto prima dell’uso.

Dipendenze

Il lockfile Bun risolve 25 versioni npm. La scansione non sostituisce il controllo di ciò che gli strumenti possono scaricare o installare durante l’uso.

25
Npm

Componenti principali e come vengono usati

ComponenteLicenzaDove e perchéValutazione
commander 14.0.0MITArgomenti degli strumenti poteto-mode; fissato nel lockfile.Esiste la major 15.1.0; la distanza non prova incompatibilità o un difetto di sicurezza.
fast-check 4.5.3Da verificare separatamenteDichiarato nel manifest privato di statechart, senza lockfile rilevato per quel pacchetto.Fuori dall’insieme delle 25 versioni controllate; nessuna conclusione sulle sue transitive.
TLC 1.7.4 e Java Temurin 25Non comprese nell’inventario npmStrumenti esterni risolti con mise da statechart; TLC ha un checksum nel codice.Verificare installazione, provenienza e condizioni dei componenti esterni nella propria distribuzione.

Tutte le dipendenze (25)

PacchettoVersioneEcosistemaLicenzaCategoriaEsitoOSV
@types/node sviluppo26.1.2NPMMITPermissivaCompatibile
@typescript/typescript-aix-ppc64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-darwin-arm64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-darwin-x64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-freebsd-arm64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-freebsd-x64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-linux-arm sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-linux-arm64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-linux-loong64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-linux-mips64el sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-linux-ppc64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-linux-riscv64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-linux-s390x sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-linux-x64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-netbsd-arm64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-netbsd-x64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-openbsd-arm64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-openbsd-x64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-sunos-x64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-win32-arm64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
@typescript/typescript-win32-x64 sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
bun-types sviluppo1.3.14NPMMITPermissivaCompatibile
commander14.0.0NPMMITPermissivaCompatibile
typescript sviluppo7.0.2NPMApache-2.0PermissivaCompatibile
undici-types sviluppo8.3.0NPMMITPermissivaCompatibile

File delle versioni bloccate analizzati: skills/poteto-mode/scripts/bun.lock

Sicurezza e privacy operative

Il pstack originale distribuisce istruzioni, due wrapper per delegati e strumenti di supporto; non installa un server MCP proprio. Le procedure possono far usare all’agente cronologie, processi, credenziali GitHub, modelli e servizi esterni. La capacità effettiva dipende dal programma che ospita l’agente e dai suoi permessi.

Il bootstrap poteto-mode usa bun install --frozen-lockfile; statechart risolve TLC 1.7.4 con checksum e Java tramite mise. Il modulo di vista di statechart è codice importato nel processo, quindi deve essere fidato. Le chiamate a child_process sono una capacità necessaria di questi strumenti, non da sole una vulnerabilità dimostrata.

Le skill recall, reflect e automate-me possono consultare conversazioni del progetto. La sezione Harness chiede di limitarsi al workspace attivo; applicare questa regola e verificare l’accessibilità dei file è responsabilità dell’ambiente. Non sono state lette conversazioni personali per questa recensione.

make-bot-ui contiene un percorso opzionale che propone l’installazione di Tailscale con curl eseguito da una shell privilegiata e l’uso di un webhook. È una procedura da valutare prima dell’adozione, non un’azione compiuta qui. Nessuna credenziale candidata o telemetria incorporata è emersa dalla scansione.

Licenze e coerenza

Lettura tecnica di licenze e attribuzioni, non consulenza legale. Il giudizio copre i file e i pacchetti individuati, non tutti i servizi o beni di terzi richiamati.

Licenze del progetto

  • MIT per pstack, attribuita a Lauren Tanpstack/LICENSE attribuisce il codice a Lauren Tan e il manifest del plugin dichiara MIT. L’assenza di una licenza GitHub globale del catalogo non annulla la licenza di questa cartella. Estrarre skill richiede di conservare l’avviso pertinente.
  • Due manifest privati senza campo license@cursor-skill/poteto-mode-tools e @cursor-skill/statechart non dichiarano license. Il LICENSE MIT alla radice resta la fonte per il repository; l’assenza del campo non è prova di codice senza permesso né un’inversione di licenza.
  • Dipendenze rilevate permissivePer le 25 versioni risolte non risultano licenze sconosciute o conflitti con MIT nelle fonti interrogate. Questo esito non comprende toolchain esterne e la chiusura transitiva di fast-check fuori lockfile.

Distribuzione delle licenze

Apache-2.0: 21MIT: 425pacchetti
Apache-2.0 — 21 (84,0%)MIT — 4 (16,0%)

Per categoria di rischio

Permissiva25

Compatibilità con la licenza del progetto (MIT)

LicenzaPacchettiEsitoObblighi principali
Apache-2.021Compatibile Copia della licenza, file NOTICE, indicare le modifiche
MIT4Compatibile Nota di copyright e testo della licenza

Licenze dei pacchetti interni

Licenza#Pacchetto
(none)2@cursor-skill/poteto-mode-tools, @cursor-skill/statechart
File di licenza trovati (1)
LICENSEMITMIT License

Categorie di licenza:

Pubblico dominioPermissivaCopyleft deboleCopyleft forteCopyleft di reteSource-available / proprietariaSconosciuta

Risultati

Rilievi confermati dalla lettura, con distinzione fra rischio, limite della prova e difetto osservato.

Valutazione

Media Permessi

L’autonomia scritta nella skill richiede confini esterni

poteto-mode permette azioni su chat, ticket e valutazioni senza domande; distingue poi una lista di azioni irreversibili sulle quali fermarsi. Shipping contempla merge e force-with-lease. Le autorizzazioni del proprio ambiente devono prevalere sulle istruzioni della skill.

Raccomandazione: Limitare credenziali, proteggere i rami e provare il metodo su copie isolate prima di concedere capacità di scrittura esterna.

Media Dipendenze

Il lockfile non copre tutti i percorsi

Il lockfile Bun copre gli strumenti poteto-mode; statechart dichiara fast-check a parte e usa Java/TLC tramite mise. La CI installa ajv e ajv-formats senza versioni fissate. La versione del plugin e le scelte dei modelli vanno registrate per ripetere una prova.

Raccomandazione: Registrare commit e versione degli strumenti; mantenere un insieme risolto delle dipendenze usate nei test e nelle verifiche operative.

Bassa CI

Presidi ufficiali presenti, con copertura delimitata

.github/workflows/validate-plugins.yml controlla definizioni e copia Claude Code ed esegue i test Node degli script. Le action usano tag v4, non hash; ajv e ajv-formats vengono installati senza versione fissata. Il job non configura Java/TLC e il glob dei test non include tutte le suite Bun.

Raccomandazione: Fissare le dipendenze della CI e verificare separatamente i percorsi Bun e TLC rilevanti per l’adozione.

Informativa Evidenze

Il numero di test individuati non è il numero di test superati

I rilevatori riportano 197 funzioni di test nel quality scan e 210 nel conteggio generale. Cercano forme testuali diverse, non eseguono le suite; le 16 occorrenze di skip hanno lo stesso limite.

OK Scansione

Nessuna credenziale individuata dai rilevatori

Nessun segreto candidato e nessun SDK di telemetria individuato nei file analizzati. Non equivale a una verifica dinamica dell’installazione o dei servizi esterni.

Controlli automatici

Informativa licenze

Pacchetti interni senza licenza dichiarata

@cursor-skill/poteto-mode-tools, @cursor-skill/statechart.

Valutazione dell'analista: I due pacchetti sono privati e il repository ha un LICENSE MIT alla radice. Il campo mancante resta un problema di metadati, non prova di incompatibilità.

OK licenze

Nessuna incompatibilità di licenza rilevata

Tutte le 25 dipendenze con licenza nota sono compatibili con MIT.

Rischi per chi adotta

Impatto bassa
Impatto media
Impatto alta
Probabilità alta
1
Probabilità media
4
2 3
Probabilità bassa
#RischioProbabilità × ImpattoMitigazione
1Supporre che l’adattatore ufficiale Claude Code fornisca tutte le capacità cloud di Cursor.alta × mediaProvare le skill necessarie nell’agente scelto e documentare ogni sostituzione.
2Concedere merge e messaggi esterni prima di verificare i limiti dell’autonomia.media × altaCredenziali ristrette, branch protetti e un progetto di prova senza servizi reali.
3Usare i grafi di statechart come prova del programma senza replay sul codice.media × altaVerificare la corrispondenza modello-codice e ripetere gli scenari di errore sul programma reale.
4Spendere più tempo e token nelle verifiche di quanto il compito giustifichi.media × mediaSelezionare poche skill e misurare costo, difetti intercettati e tempo su casi confrontabili.

Link: implementazioni di terzi

Questi progetti non sono recensiti. Riportiamo lo scopo dichiarato nei rispettivi README: sono nati per usare il metodo originale in altri ambienti o tradurne le funzioni legate a Cursor. Stelle rilevate il 17 novembre 2026, in ordine decrescente; non sono una graduatoria di qualità.

Lavoro di terziStelle GitHubPerché l’autore lo ha pubblicatoLink
michael-denyer/pstack-claude4.434L’autore lo presenta come un modo per tradurre i meccanismi di Cursor prima dell’installazione, evitando di affidare ogni traduzione all’agente durante il lavoro, ed estendere il metodo ad altri ambienti.Apri repository
backnotprop/pstack4.390L’autore lo pubblica come mirror autonomo, sincronizzato con l’originale, per installare le skill anche senza Cursor e adattare percorsi e strumenti ad altri agenti.Apri repository
ericlitman/open-pstack583L’autore dichiara di voler restare vicino al metodo di Lauren Tan, portandolo a Codex e ad altri ambienti e facendo collaborare modelli di fornitori diversi tramite i rispettivi strumenti da riga di comando.Apri repository
chhoumann/t3-pstack290L’autore lo pubblica per usare il metodo dentro T3 Code: deleghe, pannelli di più modelli, pianificazioni e controllo delle PR vengono indirizzati agli strumenti di T3.Apri repository

Raccomandazioni

Una prova limitata può misurare l’utilità prima di adottare tutto il metodo.

#AzioneAmbitoSforzo
1Scegliere un difetto o una funzione reale e adottare prima create-verification-skill; esigere un percorso riproducibile con prove conservate.Primo usoMedio
2Fissare la versione del plugin originale e le scelte dei modelli; leggere l’adattatore ufficiale prima di usare Claude Code.RiproducibilitàBasso
3Ripetere in sandbox le suite degli strumenti, inclusi i casi TLC che richiedono Java, prima di affidare loro prove importanti.QualitàMedio
4Separare i permessi di lettura, modifica del repository, chat e merge; usare le protezioni della piattaforma per ciò che deve essere garantito.AutorizzazioniMedio
5Confrontare sullo stesso compito tempo, costo, difetti sfuggiti e qualità della prova con il metodo già usato, senza usare la quantità di PR come obiettivo.ValutazioneMedio

Metodo e limiti

  • Analisi statica del pstack originale nella cartella pstack/ di cursor/plugins, commit bf0c7cd, versione 0.15.42. Il checkout esterno è fissato alla revisione richiesta. Nessun codice del progetto, installer, test o automazione è stato eseguito.
  • Gli script repo-analysis raccolgono i dati della sola cartella pstack/. Sono stati letti anche workflow, generatore e configurazione marketplace della radice, necessari per capire distribuzione e CI. La scansione locale della cartella riporta zero workflow: è un limite del perimetro, corretto leggendo il workflow ufficiale della radice.
  • La cronologia è filtrata per pstack/: 170 commit, quattro autori umani e tre commit di Cursor Agent, escluso dal conteggio umano. Le metriche automatiche prima della delimitazione sono preservate. Stelle, fork, contributori e attività GitHub del catalogo cursor/plugins sono conservati in github-monorepo.json e omessi dalla resa perché non misurano pstack.
  • Letti README, poteto-mode, i 24 principi, skill di verifica, configurazione, procedure di rilascio, strumenti e test selezionati. I 24 file dei principi sono confrontati con la copia già letta: nessuna differenza al commit recensito. Letto l’articolo pubblico di Lauren Tan indicato dal committente; le sue cifre di produttività non sono trattate come benchmark verificati.
  • Per i lavori di terzi si sono letti soltanto descrizione e introduzione dei README, per attribuire lo scopo dichiarato; rilevate le stelle via GitHub API il 17 novembre 2026. Non sono stati recensiti, provati, confrontati per qualità o valutati. La scelta è limitata a quattro link, ordinati per stelle decrescenti.
  • Nessuna installazione o esecuzione provata con Cursor o con l’adattatore ufficiale Claude Code.
  • Nessuna misura autonoma di qualità del codice generato, produttività, costo dei modelli o affidabilità delle deleghe.
  • Nessun risultato di esecuzione delle suite o della pipeline è attribuito a questa sessione: sono verificati i file che le definiscono.
  • Le 25 versioni npm del lockfile non comprendono tutte le dipendenze operative, la toolchain Java/TLC e i pacchetti installati dal job CI.
  • Le implementazioni di terzi sono citate solo per scopo dichiarato e stelle alla data di rilevazione; non ne è valutata l’efficacia.