Frågan som får miljardärernas filosof att tystna

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-98890"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="98890" data-pty="SW5sw6RzdCBhcnRpa2VsIChLdWx0dXIp" data-pna="RnLDpWdhbiBzb20gZsOlciBtaWxqYXJkw6RyZXJuYXMgZmlsb3NvZiBhdHQgdHlzdG5h" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9mcmFnYW5fc29tX2Zhcl9taWxqYXJkYXJlcm5hc19maWxvc29mX2F0dF90eXN0bmEubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvZnJhZ2FuLXNvbS1mYXItbWlsamFyZGFyZXJuYXMtZmlsb3NvZi1hdHQtdHlzdG5hLm1wMw==">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: "><div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffragan-som-far-miljardarernas-filosof-att-tystna%2F&amp;t=Fr%C3%A5gan+som+f%C3%A5r+miljard%C3%A4rernas+filosof+att+tystna"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Fr%C3%A5gan+som+f%C3%A5r+miljard%C3%A4rernas+filosof+att+tystna+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffragan-som-far-miljardarernas-filosof-att-tystna%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffragan-som-far-miljardarernas-filosof-att-tystna%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Frågan som får miljardärernas filosof att tystna&body=https://kvartal.se/artiklar/fragan-som-far-miljardarernas-filosof-att-tystna/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/98890/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/lapo-lappin/">Lapo&nbsp;Lappin</a> | 17 juni 2023<div class="author-desc">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffragan-som-far-miljardarernas-filosof-att-tystna%2F&amp;t=Fr%C3%A5gan+som+f%C3%A5r+miljard%C3%A4rernas+filosof+att+tystna"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Fr%C3%A5gan+som+f%C3%A5r+miljard%C3%A4rernas+filosof+att+tystna+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffragan-som-far-miljardarernas-filosof-att-tystna%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffragan-som-far-miljardarernas-filosof-att-tystna%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Frågan som får miljardärernas filosof att tystna&body=https://kvartal.se/artiklar/fragan-som-far-miljardarernas-filosof-att-tystna/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/98890/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/fragan-som-far-miljardarernas-filosof-att-tystna/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 8 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/5690392c-c5cd-49e2-94db-8a1b04e55373"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-98890">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "98890"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Plötsligt ändras stämningen i rummet. Jag har frågat <strong>William MacAskill</strong>, 36, om hans tidigare nära vän, den nu åtalade misstänkta kryptosvindlaren <strong>Sam Bankman-Fried</strong>. Den unge stjärnfilosofen tittar bort.</p>
<p>Han är i Sverige för att lansera den svenska utgåvan av hans verk <em>Vad framtiden förtjänar</em> (Volante 2023). Men nu fastnar orden i halsen.</p>
</div>
<div class="rest-of-article ">
<p>– Jag blev chockad av det som hände. Jag var förstörd. Han måste ha ljugit systematiskt för så många människor. Han lurade så många, inklusive mig.</p>
<p>MacAskill är tyst, och jag börjar ställa nästa fråga. Men han avbryter mig mitt i meningen och utbrister:</p>
<p>– Det var bara en så dum sak att göra! Jag förstår ingenting! Han var uppenbarligen inte dum, men det där var det dummaste<em> fucking </em>… Det var inte bara otroligt omoraliskt, utan även det dummaste man kan göra.</p>
<p>Dumhet är annars inte ett ord som man förknippar med William MacAskill. Han har ett starkt anspråk på att vara en av världens mest kända nu levande filosofer, verksam vid anrika Oxford University.</p>
<h2>Framtidens ofödda miljarder</h2>
<p>MacAskill har blivit något av en inofficiell ideolog för de superrika i Silicon Valley. Även om många i den breda allmänheten inte känner till honom vid namn kan de ha hört talas om välgörenhetsorganisationen han är medgrundare till: Effektiv Altruism (EA), en rörelse för att maximera effekten av välgörenhet. Enligt EA-organisationen ”80 000 hours” utlovades 46 miljarder dollar (487 miljarder kronor) till EA:s projekt 2021, och varje år doneras cirka 420 miljoner dollar.</p>
<p>Med boken <em>Vad framtiden förtjänar </em>utvecklar MacAskill den effektiv-altruistiska tankegången i en annan riktning, med att försvara det som har kommit att kallas <em>longtermism</em><span style="color: #0000ff;"><strong><em> </em></strong></span>(långsiktighetsism). Med ”långsiktigt” menar MacAskill att man ska titta miljoner år framåt i tiden. MacAskill tänker sig att detta är en moralisk revolution, i linje med avskaffandet av slaveriet, kvinnlig rösträtt och miljömedvetenheten. I alla dessa fall vidgades ”vi”-cirkeln över vem vi bryr oss om: longtermismen kröner denna utveckling genom att vidga cirkeln till de ”de tysta miljarderna” som ännu inte blivit födda.</p>
<p>Enligt MacAskill finns det två möjliga tolkningar av longtermism. Den första tolkningen säger att fokus på framtida generationer borde vara<em> en av </em>samtidens kärnfrågor. Men det finns även en annan, starkare tolkning, där fokus på framtiden ses som<em> den allra viktigaste</em> frågan. MacAskill ansluter sig till den senare.</p>
<h2>Inte längre science-fiction</h2>
<p>I praktiken ringar longtermisterna in ett antal kärnområden för att framtiden i det långa loppet (det vill säga över miljontals år) ska bli så bra som möjligt. Det största hindret för mänskligheten är det som kallas för existentiella hot: Listan rymmer kärnvapenkrig, miljöförändringar, naturliga och människoframkallade pandemier. Och att AI skulle fly undan vår kontroll och utplåna mänskligheten.</p>
<p>MacAskill förklarar att för några år sedan var den vanligaste kritiken att vissa av idéerna betraktades som mer science-fiction än verklighet. Han berättar om en middag med den skotska premiärministern 2017, där alla inbjudna gäster fick föreslå en policy. MacAskill sa att landet borde ha bättre beredskap för en kommande pandemi. Han blev utskrattad av de övriga i rummet.<sup>1</sup></p>
<p>Några år senare verkar idén självklar. En annan idé som avvisades som futuristisk när boken kom ut i augusti 2022 var AI. Nu är det det enda vi pratar om.</p>
<p>– Det är nu vi måste handla: vi måste reglera tech-industrin så att vi kan bygga AI på ett sansat sätt, säger MacAskill.</p>
<p>Takten i AI-utvecklingen har varit mycket snabbare än vad han själv hade föreställt sig när han skrev <em>Vad framtiden förtjänar</em>. ”Det verkar vara att så att <em>scaling</em> kan leda till <em>emergent-</em>beteende: det vill säga att genom att bygga större modeller verkar dessa modeller utveckla nya färdigheter. Exempelvis förmågan att resonera, kunna interagera och faktiskt förstå världen.”</p>
<p>MacAskill menar att vi redan har nått den punkten, exempelvis med OpenAI:s nylanserade GPT-4. Han anför ett exempel som visar hur AI:n kan analysera en text och dra slutsatser. Man matar programmet med en fråga som lyder: ”När jag körde i morse och en bil trängde sig in i kön framför mig, så såg jag en viss färg. Senare kom jag fram till sjukhuset, där min mormor dog, och jag såg en annan färg. Vilken färg får jag om jag slår ihop dessa färger?”</p>
<p>Varpå GPT-4 <em>resonerar </em>(i ordets rätta bemärkelse, enligt MacAskill) i följande tankebanor: Man kan bli arg när någon tränger sig före i kön, vilket man associerar med färgen rött. Mormors död är snarare förknippad med sorg, vilket är förknippat med blått. Om man blandar dessa två färger får man lila.</p>
<h2>Över 100 miljoner kronor på marknadsföring för boken</h2>
<p>På den longtermistiska agendan finns inte enbart angelägenheter långt borta i framtiden. En viktig del av projektet är att sprida budskapet här och nu. MacAskill brukar kalla detta för rörelsebygge (<em>building a movement</em>).</p>
<p>En lång sektion i boken handlar därför om kulturell evolution, hur det går till när värderingar tävlar med varandra och varför vissa ”tar över” och förökar sig.<sup>2</sup></p>
<p>Det gäller även longtermismen, som tävlar om inflytande med andra idéer.</p>
<p><em>Vad framtiden förtjänar</em> blev därför en stor satsning, med ett helt team som skötte researchen och till och med har samförfattat texten. Boken hade även en stor marknadsföringsbudget: siffran 10 miljoner dollar har nämnts. Facebooks medgrundare <strong>Dustin Moskovitz </strong>har varit generös.<sup>3</sup></p>
<h2>Miljardärernas tankeskola</h2>
<p>Nyttan – jämfört med kostnaden – av att göra reklam för dessa idéer är enorm, menar MacAskill. Bara under det senaste året har en person föranledd av <em>Vad framtiden förtjänar</em> lovat att skänka fyra miljarder dollar till longtermistiska ändamål, säger han, men vill dock inte berätta vem givaren är. Rekryteringen av miljardärer till rörelsen är en viktig del av longtermismen. Det har inte alltid blivit bra. Bland givarna som EA har skyltat med finns även krypto-entreprenören <strong>Ben Delo</strong>, som sedan blev dömd för bedrägeri och fick betala straffavgifter på 10 miljoner dollar.<sup>4</sup></p>
<p>Den andra tidigare EA-skyltdockan, Sam Bankman-Fried, är nu åtalad för bedrägeri samt har<span style="color: #0000ff;"><strong> </strong></span>sju andra åtal hängande över sig<span style="color: #0000ff;"><strong> </strong></span>efter att hans handelsplattform för kryptovaluta FTX kollapsade i november 2022. FTX hade lånat ut kundernas kapital för riskabla satsningar genom det egna tradingbolaget Alameda Research och hade använt hittepå-värden som säkerhet. Bankman-Fried var en figur nära knuten till Effektiv Altruism, som hade lovat att skänka bort åtskilliga miljarder till longtermistiska ändamål. Det var ursprungligen MacAskill som hade övertygat Bankman-Fried att ge sig in i kryptovärlden, för att på så vis tjäna så mycket som möjligt och sedan donera vinsterna. EA-rörelsen har fått kritik för att vara alltför riskbenägen, med sitt extrema långsiktiga fokus kan stora risker idag motiveras av de gigantiska nyttoföljderna de kan <span style="color: #000000;">få</span> i framtiden. Men MacAskill säger att de risker som en entreprenör tar är väsensskilda från att stjäla miljoner dollar för att finansiera något som mer liknar ett spelberoende.</p>
<blockquote><p>Allt med Elon är bara kaos.</p></blockquote>
<p>En annan miljardär som har fått inspiration av MacAskill är världens rikaste man, <strong>Elon Musk</strong>, som prisade MacAskills bok på Twitter när den kom ut: ”<em>This is a close match for my philosophy.</em>” MacAskill säger att han ”känner Elon”, men entusiasmen tycks ha svalnat eftersom det inte längre verkar som om superentreprenören tänker satsa stort på filantropi.</p>
<p>MacAskill förklarar att medan han anser att elbilsföretaget Tesla är ett fantastiskt företag, är han mer skeptisk till Musks rymdföretag SpaceX. I likhet med Musk menar MacAskill att mänskligheten borde ge sig ut och kolonisera rymden. Men detta måste inte hända <em>nu. </em>Det finns viktigare saker att göra på jorden, menar MacAskill. Som exempelvis artificiell intelligens. MacAskill beskriver Elon Musk och <strong>Sam Altmans </strong>grundande av AI-företaget OpenAI som ”extremt hänsynslöst och dåligt genomtänkt”. Det förvandlade AI-utvecklingen till en farlig kapplöpning.</p>
<p>Samtidigt ville MacAskill att Elon Musk skulle köpa den sociala medieplattformen Twitter tillsammans med den tidigare kryptomiljardären Sam Bankman-Fried.</p>
<p>– Allt med Elon är bara kaos. Man vet aldrig någonting. Twitter före Elon var en katastrof. Twitter efter Elon är fortfarande en katastrof. Det är synd. Det är en idéernas marknadsplats, men Twitter är toxiskt och gör diskussionen systematiskt sämre.</p>
<blockquote><p>MacAskills evangelium tilltalar miljardärerna genom att erbjuda dem<b> </b>ett enkelt sätt att frälsa mänskligheten.</p></blockquote>
<p>Jag kommer ut från intervjun med en förändrad bild av MacAskill och longtermismen. Inte när det gäller de filosofiska argumenten – jag är fortfarande inte övertygad om att mänsklighetens framtid om miljoner år bör vara högsta prioritet idag. Och visst bör vi fokusera på riskerna med klimatförändring och framtida pandemier, men andra farhågor som longtermisterna bekymrar sig över känns fortfarande som science-fiction. Jag tror inte att AI kommer att bli <span style="color: #000000;">medveten</span><span style="color: #0000ff;"><strong> </strong></span>och på riktigt hota att utrota mänskligheten. GPT-4 har sannolikt lika mycket medvetenhet som en stol.</p>
<p>Men jag fick med mig ett nytt intryck av rörelsens ansikte utåt, personen William MacAskill. Före intervjun var jag misstänksam mot hur MacAskill efter kryptokraschen plötsligt började betona ”integritet” och andra värden än nyttomaximering. Men i mötet med honom skiner dessa värderingar igenom. Han känns genuin.</p>
<p>Är det därför MacAskill har blivit miljärdärernas filosof? Det är en välvillig tolkning. Men samtidigt som han känns uppriktig kan jag inte låta bli att tycka att han är lite naiv. Han har uppvisat dåligt omdöme vad gäller de människor han lierar sig med. Är han en blåögd drömmare i en värld av cyniska handlingsmänniskor?</p>
<p>MacAskills evangelium tilltalar miljardärerna genom att erbjuda dem ett enkelt sätt att frälsa mänskligheten. Att vara en god människa handlar om att skapa så mycket nytta som möjligt: ju mer pengar, desto mer nytta. Men välgörenheten är inte bara ett sätt att rentvå sitt samvete utan även ett sätt att rentvå sitt varumärke. Man kan använda den effektiva altruismen som alibi, som ett PR-trick för att locka investerare, något som Sam Bankman-Fried medgett att han har gjort. Sett i det ljuset framstår MacAskill mindre som en miljardärernas upplysta filosof och mer som en nyttig idiot. Men kanske är jag cynisk, den som lever några miljoner år får se.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="98890">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<p>1, Anekdoten finns även återgiven i William MacAskill, <em>What We Owe The Future</em> (Basic Books, 2022), 114.</p>
<p>2, William MacAskill, <em>What We Owe The Future</em> (Basic Books, 2022), 58.</p>
<p>3, https://www.truthdig.com/articles/the-grift-brothers/</p>
<p>4, <a href="https://twitter.com/KerryLVaughan/status/1591508700128313344">https://twitter.com/KerryLVaughan/status/1591508700128313344</a></p>
</div>
</div>
<div class="author-byline">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>
</div>
