R2F0ZS5pbyBBTUEgY29uIEZyZXNoQ3V0IC0gVW5hIHBpYXR0YWZvcm1hIGRpIGNvbnRlbnV0aSBkaSBnaW9jbyBpbmNlbnRyYXRhIHN1bGxhIGNvbXVuaXTDoA==

<p><img src="https://gimg2.gateimg.com/image/article/16802467891.jpg" alt=""><br><strong>Ora: 16 maggio 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con James Kuk, co-fondatore e CEO di FreshCut nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="http://diamond.freshcut.gg/" rel="nofollow noopener noreferrer" target="_blank">http://diamond.freshcut.gg/</a></strong><br><strong>Twitter: <a href="https://twitter.com/freshcut" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/freshcut</a></strong><br><strong>Segui FreshCut su <a href="https://twitter.com/freshcut" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16802470082.png" alt=""><br><strong>James Kuk - Co-Fondatore e CEO di FreshCut</strong></p>
<h2 id="h2-QampA20da20Gateio854432"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-D120Puoi20parlarci20della20visione20alla20base20di20FreshCut20e20perch20la20stai20lanciando432314"><a name="D1: Puoi parlarci della visione alla base di FreshCut e perché la stai lanciando?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>D1: Puoi parlarci della visione alla base di FreshCut e perché la stai lanciando?</h3><p><strong>James</strong>: Assolutamente. La nostra visione è quella di essere LA casa per i contenuti di gioco a breve termine e di condividere valore con i creatori e i membri della comunità, un luogo in cui le piattaforme sociali legacy web2 come TikTok e Instagram falliscono miseramente.</p>
<p>La categoria contenuti di gioco globale è cresciuta oltre il 40% YoY negli ultimi 4 anni e il segmento clip di breve durata è incredibilmente frammentato e carente - il gioco ha oltre 1 miliardo di fan in tutto il mondo che giocano e guardano giochi e tutti meritano un’esperienza migliore e un valore migliore.</p>
<p>FreshCut è una community di giochi <a href="/web3" target="_blank" class="blog_inner_link">web3</a> e un ecosistema di contenuti costruito per creatori e fan. La nostra piattaforma combina video di gioco a breve termine e un token comunitario, FreshCut Diamonds ($FCD), per ridefinire il coinvolgimento tra creatori e fan e mostrare esperienze di gioco di alto livello. FreshCut premierà i creatori e i fan tramite meccaniche create-and-earn e watch-and-earn e darà loro anche voce sulla piattaforma.</p>
<h3 id="h3-Q220Puoi20dirci20un20po20di20pi20sulla20FreshCut20Eco20alla20nostra20comunit568809"><a name="Q2: Puoi dirci un po’ di più sulla FreshCut Eco alla nostra comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Puoi dirci un po’ di più sulla FreshCut Eco alla nostra comunità?</h3><p><strong>James</strong>: Il nostro ecosistema include l’app mobile FreshCut (iOS e Android) per una visione ottimale dei contenuti di gioco a breve forma, il token $FCD, la nostra esperienza di visualizzazione web per desktop e la nostra comunità di creatori, fan, partner di esports e game studio. Siamo partner di alcuni dei più grandi creatori di giochi, tra cui Brycent, Chief Pat, Mystic7 e molti altri.</p>
<p>Attualmente, i fan possono guadagnare $FCD partecipando ai nostri eventi nella community di Discord. Più avanti questa estate, sarà possibile guadagnare $FCD nell’applicazione per guardare contenuti e completare missioni.</p>
<p>Questa sarà una delle prime app di contenuti per videogiochi ad essere lanciata con un token integrato. Potresti aver sentito parlare di app come <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">STEPN</a> dove puoi “camminare e guadagnare” - stiamo introducendo “guardare e guadagnare” al mondo! Guadagna $FCD guardando i momenti salienti di League of Legends o le divertenti cadute di Fortnite - su FreshCut.</p>
<p>In futuro, creeremo ulteriore utilità per $FCD collaborando con altri progetti nell’ecosistema web3, sviluppando il nostro programma di adesione in cui i detentori di $FCD ottengono ricompense e privilegi preziosi, ampliando i nostri eventi comunitari sia IRL che online, e aggiungendo flussi di ricavi sostenibili come pubblicità e NFT.</p>
<p>L’Ecosistema includerà anche giochi e aziende di giochi con cui cercheremo di stringere partenariati, motivo per cui abbiamo investitori strategici come Animoca, C2X (Com2Us) e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>- cercheremo di far crescere i loro giochi e i nostri creatori e comunità insieme.</p>
<p>L’ecosistema FreshCut è supportato da VCs leader del settore, strategici e operatori, tra cui Galaxy Interactive, Animoca Brands, Republic Crypto e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Poligono</a>.</p>
<h3 id="h3-Q320Per20favore20parlatemi20del20team20di20FreshCut20e20di20come20la20vostra20esperienza20vi20ha20portato20qui943533"><a name="Q3: Per favore, parlatemi del team di FreshCut e di come la vostra esperienza vi ha portato qui?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Per favore, parlatemi del team di FreshCut e di come la vostra esperienza vi ha portato qui?</h3><p><strong>James</strong> I miei co-fondatori ed io veniamo da Twitch, dove abbiamo fatto crescere e scalato la piattaforma fino a 100 milioni di fan dedicati e membri della comunità. Abbiamo lavorato con alcuni dei più grandi creatori, editori di giochi e organizzazioni di eSports al mondo, come Blizzard, Riot, Valve, Ubisoft, PUBG e altri.</p>
<p>I ( <a href="https://twitter.com/JamesSKuk" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/JamesSKuk</a> in precedenza ha gestito lo sviluppo globale del business e le partnership strategiche presso Twitch occupandosi delle partnership commerciali con tutte le nostre aziende di gioco, partner di esports e piattaforme. Prima ero il responsabile del team di pubblicazione degli Xbox Studios che lavorava con IP globali come Halo, Gears of War e Minecraft.</p>
<p>Il mio co-fondatore e chief content officer Ernie ( <a href="https://twitter.com/ErnestLe" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ErnestLe</a> ) è stato uno dei primi creatori di contenuti su Twitch e YouTube - ha contribuito a creare il programma Twitch Creator - integrando la loro comunità di creatori con oltre 30.000 partner.</p>
<p>Il mio altro co-fondatore e chief product officer Ben ( <a href="https://twitter.com/ben_stueck" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ben_stueck</a>) ho lavorato sugli strumenti per creator che milioni di creatori di Twitch hanno utilizzato.</p>
<p>Ci siamo resi conto che non c’era una casa per i contenuti di gioco a breve termine su Internet e volevamo risolvere questo problema. Abbiamo anche notato che i modelli di business tradizionali di web2 non ricompensano i creatori, i fan e la comunità. Ecco perché abbiamo costruito FreshCut. Oggi siamo un team di oltre 25 persone con esperienza da Twitch, Xbox, Microsoft, Reddit e altre aziende leader.</p>
<h3 id="h3-Q420Ora20parliamo20dellvantaggio20competitivo20di20FreshCut20In20cosa20vi20differenziate20dagli20altri20progetti20simili985874"><a name="Q4: Ora, parliamo dell’vantaggio competitivo di FreshCut. In cosa vi differenziate dagli altri progetti simili?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ora, parliamo dell’vantaggio competitivo di FreshCut. In cosa vi differenziate dagli altri progetti simili?</h3><p><strong>James</strong>: Siamo costruiti in modo diverso.<br>Ecco un riassunto:<br>1/ Cura e servizio dedicati alla creazione di contenuti di gioco per gli appassionati di gaming<br>2/ Distribuzione del valore innovativa e EQUA per creatori e comunità tramite $FCD<br>3/ Integrazione del token nativo per ricompense e incentivi adeguati e, soprattutto, divertimento!<br>4/ Partnership con creatori e giochi e Fondo per i creatori</p>
<p>1/ Pensiamo che FreshCut sia complementare alle piattaforme di streaming e più competitivo con TikTok/IG che non offrono una buona esperienza di visione per il contenuto di gioco. È difficile trovare i tuoi giochi preferiti, creatori, ecc. - NESSUNA di queste piattaforme si concentra sui giochi come FreshCut.</p>
<p>2/ Le piattaforme di contenuti legacy Web2 prendono la maggior parte dei profitti dai creatori, che vanno dal 30 al 50%. Con FreshCut, daremo ai creatori il 90% delle mance sulla piattaforma, con il 10% che va di nuovo al tesoro della comunità. Siamo concentrati nel garantire economie più favorevoli per la comunità.</p>
<p>3/ Stiamo costruendo un ecosistema prospero intorno a $FCD - integrandolo nella nostra app, nei nostri eventi comunitari e altro ancora per premiare i creatori e i fan che contribuiscono alla costruzione della piattaforma.</p>
<p>4/Stiamo collaborando con i più grandi nomi nel mondo dei creator di web3 gaming come Brycent, Chief Pat e Mystic7, oltre ad alcuni noti streamer di web2 come JERICHO. Più avanti quest’estate - lanceremo una grande iniziativa Creator Fund per supportare e integrare nuovi ed esistenti creator su FreshCut.</p>
<h3 id="h3-Q520Ci20piacerebbe20anche20sentire20un20po20di20pi20riguardo20al20tuo20prossimo20piano20di20sviluppo20Quali20funzionalit20chiave20stai20sviluppando779315"><a name="Q5: Ci piacerebbe anche sentire un po’ di più riguardo al tuo prossimo piano di sviluppo. Quali funzionalità chiave stai sviluppando?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ci piacerebbe anche sentire un po’ di più riguardo al tuo prossimo piano di sviluppo. Quali funzionalità chiave stai sviluppando?</h3><p><strong>James</strong>: In primo luogo, quest’estate integreremo il nostro portafoglio nativo nella nostra app mobile in modo che gli utenti e i creatori possano guadagnare $FCD all’interno di iOS/Android tramite i meccanismi di crea-e-guadagna e guarda/interagisci-e-guadagna. I fan potranno guadagnare $FCD completando missioni giornaliere/settimanali, guardando video dei loro creatori preferiti e partecipando alla comunità. Puoi essere ricompensato per fare ciò che ti piace già! Simile a un ottimo modello oggi — <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">STEPN</a>, un esercizio per guadagnare un gioco NFT.</p>
<p>Quest’estate presentiamo anche il nostro programma di adesione FreshCut, dove i fan possono utilizzare $FCD per acquistare adesioni che offrono loro diversi livelli di accesso, vantaggi e privilegi. Siamo ispirati da alcuni grandi modelli di adesione come il Bored Ape Yacht Club. Crediamo nel premiare i nostri primi sostenitori.</p>
<p>Stiamo anche pensando alla pubblicità e all’abilitazione dei creatori per progettare, creare e vendere oggetti da collezione digitali (NFT) come ulteriori fonti di reddito in futuro.</p>
<p>Da un punto di vista di crescita, tutto inizia con i creatori. Siamo concentrati sull’incorporazione di creatori nel 2022 e di portare con loro le loro comunità di fan. Abbiamo un piano completo per incorporare creatori dopo TGE e per il resto dell’anno.</p>
<div class="blog-details-info"><br><div>Autore: Rio Fu., Community di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che Gate.io venga menzionato. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>