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.
Versione analizzata
| Repository | github.com/cursor/plugins ↗ |
|---|---|
| Analisi eseguita il | 17 novembre 2026, ore 15:24 UTC+01:00 |
| Commit | bf0c7cd80abdbf7fe47b634978a7d1b4071f71a7feat(pstack): new default models, one-file why and how, statechart fixes, sharpen and reflect text (#1236) |
| Data del commit | 14 novembre 2026, ore 19:36 UTC-08:00 |
| Ramo | main |
| 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.
Scopo e casi d'uso
Il punto di partenza è un progetto sul quale l’agente possa osservare e provare il comportamento, con permessi delimitati.
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.
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.
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.
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.
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).
Linguaggi
File più grandi
| File | Righe |
|---|---|
skills/poteto-mode/scripts/watch-pr/policy.ts | 842 |
skills/poteto-mode/scripts/watch-pr/github.ts | 726 |
skills/statechart/scripts/ir.ts | 547 |
skills/statechart/scripts/run.ts | 506 |
skills/poteto-mode/scripts/watch-pr/types.ts | 414 |
skills/statechart/scripts/passes/regions.ts | 295 |
skills/statechart/scripts/frontends/config.ts | 276 |
skills/statechart/scripts/passes/label.ts | 269 |
skills/statechart/scripts/backends/mermaid.ts | 249 |
skills/poteto-mode/scripts/watch-pr/cli.ts | 223 |
Scelte progettuali
Usare poteto-mode per scegliere una procedura e richiamare skill specifiche.
| Contesto | Difetti, prestazioni, nuove funzioni e rilascio richiedono verifiche diverse. |
|---|---|
| Alternative | Scegliere manualmente una skill per volta. |
| Motivazione | Conservare un metodo riconoscibile fra tipi di lavoro diversi. |
| Conseguenze | Ingresso semplice, con prescrizioni e contesto aggiuntivo quando si usa il metodo completo. |
| Evidenze | pstack/skills/poteto-mode/SKILL.md e playbooks/ |
Generare la distribuzione ufficiale Claude Code dalla fonte originale.
| Contesto | Nomi di strumenti, percorsi e modelli differiscono da Cursor. |
|---|---|
| Alternative | Mantenere copie separate oppure rinunciare al secondo ambiente. |
| Motivazione | Una fonte condivisa e una tabella esplicita di traduzione. |
| Conseguenze | La CI rileva copie fuori sincronia; alcune capacità vengono sostituite o saltate. |
| Evidenze | scripts/generate-pstack-harness-trees.mjs; pstack/docs/harness/claude-code.md |
Tecnologie
Le dipendenze operative vanno distinte dalle 25 versioni npm del lockfile analizzato.
| Ambito | Tecnologia | Uso nel progetto |
|---|---|---|
| Metodo | Markdown e Agent Skills | 61 cartelle con SKILL.md, di cui 24 principi; il caricamento dipende dall’agente usato. |
| Strumenti di coordinamento | Bun, TypeScript, Commander | Controllo di piani e stato delle PR; bootstrap con bun install --frozen-lockfile. |
| Verifica formale | TLA+, TLC 1.7.4, Java e mise | Esplorazione di stati e controesempi, con TLC fissato da versione e checksum SHA-256. |
| Test degli strumenti | node:test, bun:test e fast-check | Casi 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.
| Skill | Origine | Licenza | Titolare / fonte | Cartelle | Script |
|---|---|---|---|---|---|
architectSketch 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. | Propria | MIT (dal progetto) | — | repo | — |
arenaSpawn 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. | Propria | MIT (dal progetto) | — | repo | — |
automate-meUse 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 | Propria | MIT (dal progetto) | — | repo | — |
benchmark-checklistVet 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. | Propria | MIT (dal progetto) | — | repo | — |
blast-radiusFind 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. | Propria | MIT (dal progetto) | — | repo | — |
broRestate the last message in plain human language, with no jargon. | Propria | MIT (dal progetto) | — | repo | — |
correctFind 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 | Propria | MIT (dal progetto) | — | repo | — |
create-formal-verification-skillGenerate 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 | Propria | MIT (dal progetto) | — | repo | — |
create-verification-skillGenerate 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. | Propria | MIT (dal progetto) | — | repo | — |
figure-it-outDesign 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'. | Propria | MIT (dal progetto) | — | repo | — |
howUse 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 | Propria | MIT (dal progetto) | — | repo | — |
in-your-own-wordsRestate 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. | Propria | MIT (dal progetto) | — | repo | — |
interrogateUse 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. | Propria | MIT (dal progetto) | — | repo | — |
ketchupCatch 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. | Propria | MIT (dal progetto) | — | repo | — |
ketchup-videoCatch 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. | Propria | MIT (dal progetto) | — | repo | — |
maintain-formal-verification-skillBring 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 | Propria | MIT (dal progetto) | — | repo | — |
maintain-verification-skillPeriodic 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\". | Propria | MIT (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. | Propria | MIT (dal progetto) | — | repo | — |
no-commentsSpawn Comment Sicko, fix accepted findings, and offer encodings for claimed constraints. | Propria | MIT (dal progetto) | — | repo | — |
poteto-helpGuides users through pstack setup, /poteto-mode, and picking the skill, playbook, or principle for a task. Type /poteto-help with a question. | Propria | MIT (dal progetto) | — | repo | — |
poteto-modepoteto'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. | Propria | MIT (dal progetto) | — | repo | 15 (4317 righe) cancella file, rete, esegue processi, variabili d'ambiente |
principle-attack-the-premiseApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-boundary-disciplineApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-build-the-leverApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-encode-lessons-in-structureApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-exhaust-the-design-spaceApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-experience-firstApply when product, UX, or feature-scope tradeoffs come up. Choose user delight over implementation convenience; ship fewer polished features over more rough ones. | Propria | MIT (dal progetto) | — | repo | — |
principle-explain-the-numberApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-fix-root-causesApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-foundational-thinkingApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-guard-the-context-windowApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-laziness-protocolApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-make-operations-idempotentApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-migrate-callers-then-delete-legacy-apisApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-minimize-reader-loadApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-model-the-domainApply when writing stateful logic, or when code branches a lot or repeats a shape assumption across files. | Propria | MIT (dal progetto) | — | repo | — |
principle-never-block-on-the-humanApply when tempted to ask 'should I do X?' on reversible work. | Propria | MIT (dal progetto) | — | repo | — |
principle-outcome-oriented-executionApply during planned rewrites and migrations with explicit phase boundaries. Converge on the target architecture; don't preserve smooth intermediate states with throwaway compatibility code. | Propria | MIT (dal progetto) | — | repo | — |
principle-prove-it-worksApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-redesign-from-first-principlesApply when integrating a new requirement into an existing design. | Propria | MIT (dal progetto) | — | repo | — |
principle-separate-before-serializing-shared-stateApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-sequence-verifiable-unitsApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-subtract-before-you-addApply when sequencing an addition, refactor, or rewrite. Remove dead code, redundant validators, and stub references first, then build on the simpler base. | Propria | MIT (dal progetto) | — | repo | — |
principle-test-behavior-not-implementationApply 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. | Propria | MIT (dal progetto) | — | repo | — |
principle-type-system-disciplineApply 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. | Propria | MIT (dal progetto) | — | repo | — |
recallReconstruct 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 | Propria | MIT (dal progetto) | — | repo | — |
reflectSpawn 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. | Propria | MIT (dal progetto) | — | repo | — |
reproduce-and-fix-issuesReproduce 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. | Propria | MIT (dal progetto) | — | repo | — |
setup-bennyConfigure Benny and prepare its triage and repro automations. Use when installing Benny or changing its Slack, tracker, repository, routing, control, model, or budget settings. | Propria | MIT (dal progetto) | — | repo | — |
setup-pstackConfigure 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. | Propria | MIT (dal progetto) | — | repo | — |
sharpenMake a task deeper, not bigger, then rewrite the prompt. Use for /sharpen. | Propria | MIT (dal progetto) | — | repo | — |
show-me-your-workKeep 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 | Propria | MIT (dal progetto) | — | repo | 1 (42 righe) |
statechartCheck 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. | Propria | MIT (dal progetto) | — | repo | 20 (9696 righe) cancella file, esegue processi, variabili d'ambiente |
swarmFan out N parallel workers, drain them, and return one report. Use for /swarm, 'swarm this', or parallel coverage, races, gauntlets, and exploration. | Propria | MIT (dal progetto) | — | repo | — |
tddUse 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. | Propria | MIT (dal progetto) | — | repo | — |
teachExplain 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'. | Propria | MIT (dal progetto) | — | repo | — |
technical-writingLayered 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. | Propria | MIT (dal progetto) | — | repo | — |
triage-issue-reportsTriage 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. | Propria | MIT (dal progetto) | — | repo | — |
typescript-best-practicesTypeScript best practices. Use when reading or editing any .ts or .tsx file. | Propria | MIT (dal progetto) | — | repo | — |
unslopCut AI tells from any writing. | Propria | MIT (dal progetto) | — | repo | — |
whyUse 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. | Propria | MIT (dal progetto) | — | repo | — |
Altri componenti per agenti
| Tipo | Elemento | Dettaglio |
|---|---|---|
| Plugin | plugin.json |
Stato di salute
Sei dimensioni valutate sul codice e sulla documentazione letti. I punteggi non sono risultati di un’esecuzione del progetto.
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.
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.
Componenti principali e come vengono usati
| Componente | Licenza | Dove e perché | Valutazione |
|---|---|---|---|
| commander 14.0.0 | MIT | Argomenti 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.3 | Da verificare separatamente | Dichiarato 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 25 | Non comprese nell’inventario npm | Strumenti 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)
| Pacchetto | Versione | Ecosistema | Licenza | Categoria | Esito | OSV |
|---|---|---|---|---|---|---|
@types/node sviluppo | 26.1.2 | NPM | MIT | Permissiva | Compatibile | |
@typescript/typescript-aix-ppc64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-darwin-arm64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-darwin-x64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-freebsd-arm64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-freebsd-x64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-linux-arm sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-linux-arm64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-linux-loong64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-linux-mips64el sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-linux-ppc64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-linux-riscv64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-linux-s390x sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-linux-x64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-netbsd-arm64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-netbsd-x64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-openbsd-arm64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-openbsd-x64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-sunos-x64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-win32-arm64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
@typescript/typescript-win32-x64 sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
bun-types sviluppo | 1.3.14 | NPM | MIT | Permissiva | Compatibile | |
commander | 14.0.0 | NPM | MIT | Permissiva | Compatibile | |
typescript sviluppo | 7.0.2 | NPM | Apache-2.0 | Permissiva | Compatibile | |
undici-types sviluppo | 8.3.0 | NPM | MIT | Permissiva | Compatibile |
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
Per categoria di rischio
Compatibilità con la licenza del progetto (MIT)
| Licenza | Pacchetti | Esito | Obblighi principali |
|---|---|---|---|
| Apache-2.0 | 21 | Compatibile | Copia della licenza, file NOTICE, indicare le modifiche |
| MIT | 4 | Compatibile | 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)
LICENSE | MIT | MIT License |
Categorie di licenza:
Risultati
Rilievi confermati dalla lettura, con distinzione fra rischio, limite della prova e difetto osservato.
Valutazione
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.
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.
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.
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.
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
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à.
Nessuna incompatibilità di licenza rilevata
Tutte le 25 dipendenze con licenza nota sono compatibili con MIT.
Rischi per chi adotta
| # | Rischio | Probabilità × Impatto | Mitigazione |
|---|---|---|---|
| 1 | Supporre che l’adattatore ufficiale Claude Code fornisca tutte le capacità cloud di Cursor. | alta × media | Provare le skill necessarie nell’agente scelto e documentare ogni sostituzione. |
| 2 | Concedere merge e messaggi esterni prima di verificare i limiti dell’autonomia. | media × alta | Credenziali ristrette, branch protetti e un progetto di prova senza servizi reali. |
| 3 | Usare i grafi di statechart come prova del programma senza replay sul codice. | media × alta | Verificare la corrispondenza modello-codice e ripetere gli scenari di errore sul programma reale. |
| 4 | Spendere più tempo e token nelle verifiche di quanto il compito giustifichi. | media × media | Selezionare 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 terzi | Stelle GitHub | Perché l’autore lo ha pubblicato | Link |
|---|---|---|---|
| michael-denyer/pstack-claude | 4.434 | L’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/pstack | 4.390 | L’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-pstack | 583 | L’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-pstack | 290 | L’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.
| # | Azione | Ambito | Sforzo |
|---|---|---|---|
| 1 | Scegliere un difetto o una funzione reale e adottare prima create-verification-skill; esigere un percorso riproducibile con prove conservate. | Primo uso | Medio |
| 2 | Fissare la versione del plugin originale e le scelte dei modelli; leggere l’adattatore ufficiale prima di usare Claude Code. | Riproducibilità | Basso |
| 3 | Ripetere in sandbox le suite degli strumenti, inclusi i casi TLC che richiedono Java, prima di affidare loro prove importanti. | Qualità | Medio |
| 4 | Separare i permessi di lettura, modifica del repository, chat e merge; usare le protezioni della piattaforma per ciò che deve essere garantito. | Autorizzazioni | Medio |
| 5 | Confrontare sullo stesso compito tempo, costo, difetti sfuggiti e qualità della prova con il metodo già usato, senza usare la quantità di PR come obiettivo. | Valutazione | Medio |
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.