Insights AI

Portare su larga scala gli agenti autonomi di programmazione: come i cicli di verifica e i vincoli rigorosi di integrazione continua consentono una consegna rapida del software

Podcast · Ascolta (20 min)

Cursor工程師讓AI一個月自動合併1000個PR,關鍵不是更聰明

Indice
  1. Il collo di bottiglia della fiducia: perché scalare gli agenti di programmazione è un problema di gestione ingegneristica
  2. 1. Sintetizzare il problema centrale
  3. 2. Stabilire l'analogia gestionale
  4. Verifica programmatica e mappatura delle funzionalità: chiudere il ciclo degli agenti
  5. 1. Spiegare il meccanismo di verifica passo dopo passo
  6. 2. Descrivere in dettaglio l'architettura della mappa delle funzionalità
  7. 3. Descrivere in dettaglio la valutazione e la manutenzione delle competenze degli agenti
  8. Vincoli architetturali rigidi: dalle istruzioni non vincolanti all'applicazione obbligatoria tramite CI
  9. 1. Contrapporre le regole non vincolanti ai vincoli deterministici rigidi
  10. 2. Analizzare il caso di studio dell'architettura «Dune»
  11. Automazione degli agenti nel cloud e implicazioni per i prodotti nell'intero settore
  12. 1. Riproduzione autonoma dei bug e flussi di lavoro nel cloud
  13. 2. Democratizzazione dello sviluppo tra i ruoli non ingegneristici
  14. Limiti architetturali e questioni ingegneristiche aperte
  15. 1. Documentare i principali limiti e i casi limite
  16. Numeri chiave
  17. Cosa cambierebbe questo quadro
  18. Fonti citate

Le moderne organizzazioni di ingegneria del software stanno attuando un cambiamento di paradigma fondamentale, passando dalla programmazione in coppia con intelligenza artificiale [AI] sottoposta a microgestione a flotte di agenti autonomi capaci di integrare da centinaia a migliaia di richieste di integrazione [PR] al mese. Come spiegato da Lauren Tan, ingegnera presso SpaceXAI, scalare la generazione di codice tramite AI è principalmente un problema di gestione ingegneristica, anziché un semplice esercizio di formulazione delle istruzioni. Quando i team di ingegneria si affidano alla supervisione manuale, alle ispezioni del codice riga per riga e a indicazioni non vincolanti nelle istruzioni, lo sviluppatore umano diventa un collo di bottiglia sincrono che limita la scalabilità degli agenti. Il passaggio a un'esecuzione ad alta autonomia richiede di sostituire la supervisione umana con cicli di verifica programmatica, una mappatura strutturata delle funzionalità e vincoli deterministici di integrazione continua [CI]. Codificando le invarianti architetturali direttamente negli strumenti di analisi statica e nei sistemi di verifica in fase di esecuzione, i team di ingegneria possono delegare l'esecuzione ad agenti paralleli nel cloud, impedendo sistematicamente il degrado della base di codice.

Il collo di bottiglia della fiducia: perché scalare gli agenti di programmazione è un problema di gestione ingegneristica

1. Sintetizzare il problema centrale#

Il principale punto di attrito nella distribuzione del software assistita dall'AI è l'assenza di fiducia degli sviluppatori nei risultati degli agenti. Gli agenti software inventano frequentemente astrazioni, diagnosticano erroneamente le cause originarie e propongono con sicurezza correzioni non valide. Come osservato da Lauren Tan durante un'intervista sul canale YouTube Vision Sabbat, gli agenti spesso «affermano con sicurezza di aver trovato la prova decisiva per la centesima volta», mentre il problema sottostante rimane completamente irrisolto.

Quando i team di ingegneria tentano di scalare l'utilizzo degli agenti attraverso la tradizionale programmazione in coppia con intervento umano nel ciclo operativo, il flusso di lavoro raggiunge rapidamente un limite invalicabile. Se un ingegnere deve ispezionare ogni riga di codice generata, testare manualmente le compilazioni locali e verificare le differenze, lo sviluppatore umano diventa un unico punto di serializzazione. Questo collo di bottiglia sincrono limita la scalabilità oltre uno o due agenti locali, impedendo una vera parallelizzazione dei flussi di lavoro ingegneristici.

2. Stabilire l'analogia gestionale#

Per analizzare questa dinamica operativa, Lauren Tan ha tracciato un parallelo diretto tra la gestione degli agenti di programmazione basati sull'AI e quella degli ingegneri del software umani. Nella gestione ingegneristica tradizionale, un responsabile che non si fida dei propri collaboratori diretti ricorre inevitabilmente alla microgestione: sorveglia gli sviluppatori da vicino, controlla continuamente le richieste di integrazione e ispeziona ogni riga di codice per prevenire interruzioni in produzione.

       HIGH |                                     [ Fleet Autonomy ]
            |                                     Auto-merging PRs &
            |                                     Cloud Parallelization
   TRUST    |                                  /
            |                             /
            |                        /
            |   [ Micromanagement ]
        LOW |   Manual Prompting & 1-in-Loop
            +---------------------------------------------------
                LOW                                     HIGH
                               VELOCITY

Scalare l'autonomia degli agenti richiede di risalire quella che Tan definisce la «curva della fiducia». Nella fase iniziale di adozione degli agenti, gli sviluppatori operano in modo sincrono all'interno del ciclo di esecuzione, impartendo manualmente istruzioni ai singoli agenti e ispezionando ogni differenza. Risalire la curva della fiducia richiede sistemi ingegneristici che forniscano una verifica oggettiva e automatizzata dei risultati degli agenti. Stabilire un elevato livello di fiducia sposta il paradigma organizzativo dalla microgestione sincrona alla delega asincrona, consentendo a flotte autonome di agenti nel cloud di compilare, testare e integrare codice in modo indipendente.

Verifica programmatica e mappatura delle funzionalità: chiudere il ciclo degli agenti

1. Spiegare il meccanismo di verifica passo dopo passo#

Nelle architetture ingegneristiche basate su agenti, la verifica programmatica consiste nel fornire agli agenti strumenti di esecuzione espliciti per interagire direttamente con gli ambienti di esecuzione delle applicazioni di destinazione. Anziché chiedere a un modello linguistico di grandi dimensioni [LLM] di indovinare se il suo codice funziona correttamente, un ciclo di verifica programmatica consente all'agente di eseguire compilazioni, ispezionare gli ambienti di esecuzione, acquisire tracce delle prestazioni dell'unità centrale di elaborazione [CPU], analizzare istantanee della memoria dinamica e pilotare simulatori di dispositivi mobili o browser. Per le applicazioni web e desktop, gli agenti utilizzano competenze costruite su protocolli come Chrome DevTools Protocol [CDP] per controllare programmaticamente l'interfaccia utente [UI].

Lauren Tan ha illustrato questo meccanismo con un'analogia culinaria: affidarsi a un agente senza verifica programmatica equivale a un responsabile di ristorante che legge ricette cartacee per indovinare se un piatto è buono, mentre la verifica programmatica mette a disposizione del capocuoco postazioni di cucina per assaggiare, misurare e aggiustare continuamente il cibo durante la preparazione. Fornire agli agenti strumenti di esecuzione chiude automaticamente il ciclo di riscontro. Sebbene la verifica non garantisca l'eleganza architetturale, convalida in modo deterministico la correttezza del comportamento prima della revisione umana del codice.

2. Descrivere in dettaglio l'architettura della mappa delle funzionalità

Un componente fondamentale della verifica programmatica introdotto nell'estensione a codice aperto PStack (Potato Stack) di Tan — uno strumento di competenze per sviluppatori il cui nome richiama GStack di Gary Tan — è la «mappa delle funzionalità». La mappa delle funzionalità risolve la difficoltà di orientamento nella base di codice che gli agenti incontrano quando tentano di correggere difetti o implementare funzionalità in sistemi complessi.

+-----------------------------------------------------------------------+
|                             FEATURE MAP                               |
+-----------------------------------------------------------------------+
|  User Context / Vague Report: "Left sidebar is laggy on click"         |
+-----------------------------------------------------------------------+
                                  |
                                  v
+-----------------------------------------------------------------------+
|  DOM Attributes & Selectors : [data-testid="sidebar-toggle"]          |
|  Keyboard Shortcuts         : Cmd+B / Ctrl+B                          |
|  Code Base Location         : src/components/sidebar/Sidebar.tsx      |
|  CDP Execution Action       : cdp.click('#sidebar-toggle')            |
+-----------------------------------------------------------------------+

Quando gli utenti inviano segnalazioni di difetti ambigue e di scarsa qualità, come una schermata di Slack annotata soltanto con «???», un agente privo di contesto strutturale fatica a individuare i componenti interessati. Una mappa delle funzionalità colma esplicitamente questa lacuna collegando direttamente gli elementi dell'UI ai percorsi dei file della base di codice, agli attributi del modello a oggetti del documento [DOM], agli identificatori di test, alle scorciatoie da tastiera e ai selettori di esecuzione CDP.

Attraverso competenze come create_verification_skill e maintain_verification_skill all'interno di PStack, gli agenti analizzano sistematicamente le basi di codice per costruire registri strutturati delle funzionalità. L'acquisizione di una segnalazione ambigua consente all'agente di consultare la mappa delle funzionalità, raggiungere direttamente gli elementi dell'UI interessati, eseguire flussi di interazione tramite CDP, acquisire metriche delle prestazioni e verificare la risoluzione del difetto.

3. Descrivere in dettaglio la valutazione e la manutenzione delle competenze degli agenti#

Per mantenere nel tempo gli strumenti e le competenze degli agenti, i team di sviluppo devono adottare sistemi di valutazione automatizzata, che operano come test unitari per le competenze degli agenti AI. La procedura di valutazione segue uno schema di esecuzione in quattro fasi:

  1. Generazione della griglia di valutazione: Un agente coordinatore stabilisce una griglia di valutazione esplicita che definisce i comportamenti attesi degli strumenti e i criteri quantitativi di attribuzione dei punteggi.
  2. Esecuzione in ambienti isolati: I sottoagenti eseguono attività in directory temporanee isolate, alle quali vengono assegnati nomi casuali e offuscati. L'offuscamento delle directory è strettamente necessario perché gli LLM possono rilevare di trovarsi all'interno di un sistema di valutazione e modificare il proprio comportamento esecutivo, introducendo gravi distorsioni nella valutazione.
  3. Valutazione su una matrice di più modelli: Per eliminare le distorsioni di punteggio dovute a un singolo modello, agenti valutatori eseguiti su una matrice di diversi modelli di base valutano le prestazioni dei sottoagenti rispetto alla griglia del coordinatore.
  4. Cicli di ottimizzazione per miglioramento progressivo: Cicli di ottimizzazione automatizzati, come l'esecuzione di /loop in Cursor, perfezionano continuamente le istruzioni delle competenze e i parametri degli strumenti fino al raggiungimento dei punteggi di valutazione obiettivo, ad esempio 10 su 10, nell'intera matrice di modelli.

Tan ha sottolineato che la manutenzione delle competenze degli agenti richiede un'osservazione umana continua e sensibilità ingegneristica. Gli sviluppatori devono agire da supervisori attivi, ispezionando i registri delle chiamate agli strumenti e i blocchi di ragionamento degli agenti durante lo sviluppo delle competenze, per individuare modalità di errore sottili e formalizzare istruzioni correttive in competenze persistenti.

Vincoli architetturali rigidi: dalle istruzioni non vincolanti all'applicazione obbligatoria tramite CI#

1. Contrapporre le regole non vincolanti ai vincoli deterministici rigidi#

Affidarsi esclusivamente a vincoli non vincolanti nelle istruzioni, come guide di stile in markdown, regole per le istruzioni o file di istruzioni AGENTS.md, porta inevitabilmente al degrado della base di codice. Quando agenti privi di vincoli seguono il percorso di minor resistenza per completare attività circoscritte, generano un'«architettura organica» caratterizzata da astrazioni non valide, logica duplicata e accumulo di debito tecnico.

Per mantenere l'integrità strutturale nel lungo termine, le architetture software devono implementare il paradigma progettuale centrale di Lauren Tan: poiché gli agenti adottano naturalmente scorciatoie strutturali, l'architettura della base di codice deve essere progettata affinché il percorso più breve sia strutturalmente il percorso migliore e corretto. I team di ingegneria devono imporre questo paradigma attraverso un sistema di vincoli a livelli, spostando l'affidamento dalle indicazioni non vincolanti ai controlli rigidi di CI.

Livello Livello di applicazione Meccanismo / Strumenti Caratteristiche
1. Architettura della base di codice e incapsulamento Rigido (deterministico) Raggruppamento per funzionalità, confini rigorosi tra directory, regole di importazione personalizzate Impedisce strutturalmente gli antipattern architetturali rendendo il percorso più breve quello corretto
2. Analisi statica e diagnostica del compilatore Rigido (deterministico) Compilatori rigorosi, ad esempio il verificatore dei prestiti di Rust, analizzatori del codice personalizzati, controlli di CI Fa fallire deterministicamente le compilazioni in caso di violazioni delle invarianti, prima della revisione umana
3. Revisione automatizzata del codice Non vincolante / semideterministico Revisori del codice basati sull'AI, ad esempio Bugbot, analisi automatizzata delle PR Individua difetti contestuali durante la convalida delle PR
4. Competenze degli agenti e guide di stile Non vincolante (non deterministico) Regole in markdown, istruzioni per gli agenti, guide di stile Facilmente ignorate o applicate in modo incoerente dai modelli

Sebbene le indicazioni non vincolanti ai livelli 3 e 4 offrano un contesto utile, l'analisi statica rigida e l'incapsulamento architetturale ai livelli 1 e 2 sono obbligatori per garantire che gli agenti autonomi non possano integrare codice non valido.

2. Analizzare il caso di studio dell'architettura «Dune»#

L'implementazione pratica dei vincoli deterministici è dimostrata nella ristrutturazione del codice dell'applicazione desktop Grokbot. Grokbot è stata realizzata utilizzando «Dune», un'infrastruttura interna specializzata descritta come Next.js per applicazioni Electron, progettata esplicitamente per la distribuzione del software guidata da agenti.

Per proteggere le prestazioni dell'applicazione in fase di esecuzione ed eliminare le modalità di errore ricorrenti degli agenti, l'architettura Dune impone regole deterministiche rigorose all'interno delle sequenze operative di CI:

  • Divieto degli agganci di React: L'aggancio useEffect di React è completamente vietato nell'intera base di codice per prevenire difetti di sincronizzazione dello stato e nuovi rendering indesiderati. Le compilazioni di CI falliscono immediatamente se viene rilevato useEffect.
  • Divieto dei commenti nel codice: I commenti nel codice dell'applicazione sono rigorosamente vietati. Tan ha osservato che gli agenti generano frequentemente commenti storici o interpretano erroneamente osservazioni temporanee nelle revisioni delle richieste di integrazione, ad esempio trasformando una singola osservazione di revisione come "Lauren ha detto di non farlo mai" in un commento statico nel codice: ciò inventa vincoli globali permanenti e inquina le finestre di contesto dei modelli. Vietare i commenti nel codice impone un codice autodocumentante e previene il degrado del contesto.
  • Isolamento obbligatorio dei confini tra processi: Le applicazioni Electron richiedono una separazione rigorosa tra il processo principale di Node e il flusso di esecuzione dell'UI del renderer. Per proteggere il tempo di esecuzione disponibile di 16 millisecondi per fotogramma, necessario a mantenere prestazioni fluide a 60 fotogrammi al secondo [FPS], le operazioni ad alta intensità computazionale e le attività di ingresso/uscita [IO] sono vietate sul flusso di esecuzione del renderer. Dune impone questo vincolo isolando la logica nelle directory electron_main ed electron_renderer, utilizzando controlli automatizzati del grafo delle dipendenze nella CI per bloccare le importazioni tra directory.

Automazione degli agenti nel cloud e implicazioni per i prodotti nell'intero settore#

1. Riproduzione autonoma dei bug e flussi di lavoro nel cloud#

La predisposizione di strumenti di verifica locale e vincoli rigorosi di integrazione continua consente alla distribuzione del software di passare dalle istruzioni locali a flotte di agenti autonomi ospitate nel cloud. Questo cambiamento è esemplificato da agenti interni di automazione nel cloud come "Benny" presso Cursor.

  [ User Feedback ] (Slack / Support Channels)
         |
         v
  [ Benny Cloud Agent ] (Spawns Isolated Cursor Cloud Environment)
         |
         v
  [ Execute Verification Skill ] (Launches App, Simulates UI Input)
         |
         +---> Bug Reproduced? ---> Yes ---> Generate Fix & Submit PR
         |
         +---> Already Fixed on Main? ---> Confirm Resolution & Notify Team

Benny acquisisce automaticamente i commenti grezzi degli utenti e le segnalazioni di difetti dai canali Slack. Alla ricezione di una segnalazione, Benny avvia un'istanza desktop isolata di Cursor nel cloud, esegue l'ambiente di esecuzione dell'applicazione e impiega competenze di verifica memorizzate per riprodurre programmaticamente il difetto segnalato.

Operando in un ambiente isolato dotato di capacità di verifica complete, Benny può determinare autonomamente se un problema persiste o è già stato risolto nel ramo principale. Questa automazione elimina la necessità che gli ingegneri dedichino lavoro manuale ai tentativi di riprodurre segnalazioni degli utenti di scarsa qualità.

2. Democratizzazione dello sviluppo tra i ruoli non ingegneristici#

I vincoli deterministici di integrazione continua modificano radicalmente le dinamiche operative delle organizzazioni di sviluppo del prodotto. Quando gli invarianti architetturali, i confini della memoria e i limiti prestazionali vengono imposti in modo deterministico dai compilatori e dagli script di integrazione continua, il personale non ingegneristico, inclusi i responsabili di prodotto [PM], i progettisti dell'esperienza utente [UX] e il personale addetto alla strategia di commercializzazione [GTM], può realizzare funzionalità e presentare richieste di integrazione destinate alla produzione in sicurezza.

Poiché l'infrastruttura respinge automaticamente le implementazioni non conformi, i collaboratori non tecnici possono realizzare miglioramenti funzionali attraverso interfacce in linguaggio naturale come Grokbot, senza compromettere la stabilità della base di codice o i limiti prestazionali.

Questo modello operativo presenta specifici compromessi economici e in termini di rendimento dell'investimento [ROI]:

  • Spese iniziali in conto capitale per i token: La costruzione di suite di verifica complete, l'esecuzione di matrici di valutazione multiagente e la ristrutturazione strutturale del codice richiedono una spesa iniziale considerevole per i token. La ristrutturazione dell'applicazione Grokbot secondo l'architettura Dune ha richiesto oltre 600 singole richieste di integrazione.
  • Incrementi dell'efficienza del lavoro: L'elevata spesa iniziale per i token è compensata da drastiche riduzioni del carico di lavoro degli ingegneri. Le catene di esecuzione degli agenti ad alta capacità consentono alle organizzazioni di operare con gruppi snelli, evitando gli oneri organizzativi di grandi reparti di ingegneria. La sostenibilità economica dei cicli continui di valutazione e delle matrici di valutazione degli agenti è ulteriormente migliorata da modelli di frontiera come Grok 4.6, che mantiene il prezzo dei token della versione 4.5 offrendo al contempo prestazioni superiori nei test di riferimento.

Limiti architetturali e questioni ingegneristiche aperte#

1. Documentare i principali limiti e i casi limite#

Nonostante i miglioramenti di velocità ottenuti grazie a flotte di agenti altamente autonomi, gli attuali schemi architetturali introducono limiti e compromessi ingegneristici espliciti:

  • Spesa iniziale per i token: La costruzione di catene di verifica continua e l'esecuzione di interventi di ristrutturazione del codice che comportano diverse centinaia di richieste di integrazione consumano volumi enormi di token. Per i gruppi che operano con risorse limitate per i token, il capitale necessario a costruire gli strumenti di verifica può rappresentare una barriera significativa prima di conseguire un rendimento dell'investimento.
  • Rischi della prototipazione da zero: La prototipazione rapida di applicazioni senza vincoli strutturali ("programmazione intuitiva") genera un grave debito tecnico architetturale. In assenza di confini espliciti di incapsulamento e vincoli statici, gli agenti scelgono scorciatoie di comodo che fanno rapidamente sfuggire al controllo le basi di codice, rendendo infine necessarie imponenti operazioni di ristrutturazione, con diverse centinaia di richieste di integrazione, per porvi rimedio.
  • Oneri di manutenzione e giudizio tecnico: I sistemi di verifica automatizzati non eliminano la necessità del giudizio tecnico di ingegneri esperti. La costruzione delle valutazioni, l'aggiornamento delle mappe delle funzionalità e la definizione dei vincoli di integrazione continua richiedono una profonda competenza di dominio e una supervisione attiva che orienti il lavoro senza eseguirlo direttamente.

Numeri chiave#

  • 1,000 richieste di integrazione: Numero di richieste di integrazione incorporate da Lauren Tan nel mese precedente utilizzando agenti autonomi presso Cursor.
  • Quasi 800 richieste di integrazione: Numero di richieste di integrazione incorporate da Lauren Tan nel mese corrente (al giorno 12 del mese).
  • 20 richieste di integrazione: Numero di richieste di integrazione generate dagli agenti, incorporate automaticamente durante la notte e verificate sul ramo principale in un solo giorno.
  • 600+ richieste di integrazione: Numero di richieste di integrazione eseguite per completare la ristrutturazione integrale dell'architettura della base di codice di Grokbot.
  • 16 millisecondi: Finestra massima di esecuzione per fotogramma richiesta sul filo di esecuzione del componente di visualizzazione di Electron per mantenere prestazioni fluide dell'interfaccia utente a 60 fotogrammi al secondo [FPS].
  • 5 mesi fa: Momento in cui Lauren Tan è entrata in Cursor, sperimentando inizialmente una bassa produttività mentre costruiva la fiducia iniziale negli agenti e le competenze di verifica.
  • Grok 4.6: Versione del modello appena annunciata che mantiene il costo dei token della versione 4.5 del modello, aumentando al contempo le prestazioni nei test di riferimento.

Cosa cambierebbe questo quadro#

  1. Passaggio a vincoli per gli agenti nativi del compilatore: Adozione diffusa di linguaggi rigorosamente compilati con sistemi rigorosi di proprietà della memoria e di tipi (come Rust) al posto di strutture software dinamiche, trasferendo l'imposizione dei vincoli strutturali dagli script personalizzati di integrazione continua direttamente alla diagnostica del compilatore.
  2. Standardizzazione dei protocolli di verifica programmatica: Adozione estesa nel settore di standard unificati e indipendenti dalla piattaforma per la verifica tra agenti e interfacce utente, oltre al Chrome DevTools Protocol, per rendere le interfacce desktop, mobili e web accessibili nativamente agli agenti di intelligenza artificiale.
  3. Integrazione autonoma diffusa tramite integrazione continua: Passaggio dei gruppi di sviluppo di software commerciale più comuni dalle catene di revisione manuale del codice a code di integrazione completamente automatizzate, guidate da punteggi di valutazione sintetici e test di integrazione continua.
  4. Riduzione del costo dei token nelle valutazioni multiagente: Riduzioni strutturali significative dei costi di inferenza dei modelli di base, che consentano ai gruppi di sviluppo non aziendali di eseguire continuamente matrici di valutazione multiagente e cicli di ottimizzazione per miglioramento locale in modo economicamente sostenibile.

Per saperne di più sull'implementazione di strutture avanzate di ingegneria dell'intelligenza artificiale e catene di esecuzione autonome, esplorate la ricerca a codice aperto disponibile sul sito di DeepValues Research oppure provate oggi l'applicazione DeepValues.

Fonti citate#

Lauren Tan - SpaceXAI engineer, interview published on YouTube channel Vision Sabbat

Guarda

Link alle fonti

Guarda e ascolta

Testo di ricerca con licenza CC BY 4.0, citare come: DeepValues Research, Portare su larga scala gli agenti autonomi di programmazione: come i cicli di verifica e i vincoli rigorosi di integrazione continua consentono una consegna rapida del software, https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents-it/

Email settimanale gratuita

Margin of Safety Weekly

Ogni sabato: la temperatura del mercato, cosa hanno comprato e venduto i grandi investitori (13F), le nuove analisi della settimana, video e podcast — gratis, senza bisogno di un account. L’email è in inglese.

Send me the DeepValues Margin of Safety Weekly, one email every Saturday. I can unsubscribe at any time. Information only, not investment advice. Privacy

Vai oltre

Esegui questa analisi su qualsiasi azione in 2 minuti

Deep Value Intelligence, l'analista AI multi-agente dietro questo report, scrive su richiesta lo stesso report per qualsiasi azienda quotata.

Apri Deep Value Intelligence

Segui oltre 300 azioni nell'app DeepValues

Posizioni, valore intrinseco e ultimi report, sul tuo telefono.

Sviluppatori: posizioni e report via API

I fondamentali, i valori intrinseci, le posizioni e i link ai report dietro queste pagine, in JSON.

Documentazione API

Discuti