Mytomanen som driver världsutvecklingen

<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/hakan-lindgren/">Håkan&nbsp;Lindgren</a> | 14 april 2025<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%2Fmytomanen-som-driver-varldsutvecklingen%2F&amp;t=Mytomanen+som+driver+v%C3%A4rldsutvecklingen"    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=Mytomanen+som+driver+v%C3%A4rldsutvecklingen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fmytomanen-som-driver-varldsutvecklingen%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%2Fmytomanen-som-driver-varldsutvecklingen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Mytomanen som driver världsutvecklingen&body=https://kvartal.se/artiklar/mytomanen-som-driver-varldsutvecklingen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/174194/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="kv-art-ext-sep"></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%2Fmytomanen-som-driver-varldsutvecklingen%2F&amp;t=Mytomanen+som+driver+v%C3%A4rldsutvecklingen"    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=Mytomanen+som+driver+v%C3%A4rldsutvecklingen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fmytomanen-som-driver-varldsutvecklingen%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%2Fmytomanen-som-driver-varldsutvecklingen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Mytomanen som driver världsutvecklingen&body=https://kvartal.se/artiklar/mytomanen-som-driver-varldsutvecklingen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/174194/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 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 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/66bc4f71-142c-460e-8d1c-74f9e95d732a"    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-174194">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "174194"></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 ">Efter drygt två år med AI börjar det bli uppenbart vilket slags present vi har fått. AI är inte en fortsättning på den informationsteknologi vi redan känner till; det är en teknologi som förstör information.</p>
</div>
<div class="rest-of-article ">
<p>Så fort Chat GPT kom in i världen blev universiteten tvungna att anpassa sig och förändra sitt arbetssätt. Det är ingen mening att be studenterna ägna en termin åt att skriva en uppsats när Chat GPT kan göra det åt dem på ett ögonblick. Att avslöja den sortens AI-genererade fusk skulle kräva ohållbara resurser – det enda universiteten kan göra i det läget är att ge upp. ”Det står klart att all annan examination än den som sker muntligen eller är förlagd i skrivsal med larmbågar är omöjlig”, <a href="https://www.dn.se/kultur/ulf-danielsson-ai-gor-att-bara-muntliga-prov-och-salstentor-ar-mojliga/">förklarade</a> fysikern <strong>Ulf Danielsson</strong> i DN tidigare i år.</p>
<p>Observera vad som har gått förlorat här. Syftet med uppsatsskrivandet är inte att studenterna ska lära sig reproducera en viss mängd information. Det verkliga syftet är djupare: att läsa och själv skriva långa, krävande texter tränar tänkandet på ett sätt som aldrig kan ersättas med en muntlig tentamen eller ett kort skriftligt prov. Denna mentala träning har varit universitetens huvudsyfte lika länge som universitet har existerat. Om vi avskaffar den – förtjänar det som återstår fortfarande att kallas universitet?</p>
<h2>Inte en ytterligare sökmotor</h2>
<p>Det har blivit vanligt att använda Chat GPT för att ställa frågor och leta information på nätet, som om programmet bara var ännu en sökmotor. Det är en missuppfattning: Chat GPT hittar inte information, det hittar på information. <strong>Eugene Volokh</strong>, professor i juridik på University of California Los Angeles, bestämde sig för att testa hur bra det fungerar i praktiken.</p>
<p>Han <a href="https://www.washingtonpost.com/technology/2023/04/05/chatgpt-lies/">bad</a> Chat GPT att ge honom namn på akademiker som har dömts för sexuella övergrepp. Han fick fem svar, varav tre var falska – och lägg märke till på vilket sätt de var falska. En av de utpekade, professorn <strong>Jonathan Turley</strong>, var en verklig person, men helt oskyldig. Chat GPT hade hittat på anklagelsen, komplett med övertygande citat från en icke-existerande artikel i <em>Washington Post</em>.</p>
<p>Den här historien bör ses som ett stickprov.</p>
<p>Multiplicera den med det antal miljarder sökningar som görs varje dag och slutsatsen blir att vi inte längre lever i ett informationssamhälle, utan i ett desinformationssamhälle.</p>
<blockquote><p>Det är viktigt att komma ihåg att Chat GPT inte vet någonting om världen.</p></blockquote>
<p><em>The Guardians</em> innovationschef <strong>Chris Moran</strong> har <a href="https://www.theguardian.com/commentisfree/2023/apr/06/ai-chatgpt-guardian-technology-risks-fake-article">berättat</a> att tidningen har börjat få mejl från läsare som klagar på att de inte kan hitta de artiklar som Chat GPT citerar från och anger som källor för sina påståenden. Artiklarna har verkliga <em>Guardian</em>-journalisters namn, men det går inte att googla fram dem eftersom de aldrig har existerat. I ett samhällsklimat där förtroendet för etablerad journalistik redan är oroväckande lågt – kommer läsarna att lita på Moran eller Chat GPT? Kanske börjar de misstänka att <em>The Guardian</em> i hemlighet ägnar sig åt att censurera arkiven.</p>
<h2>Vet ingenting</h2>
<p>Det är viktigt att komma ihåg att Chat GPT inte vet någonting om världen. Allt programmet gör är att sätta samman statistiskt sannolika ordföljder. Programmet kan inte ens besvara en relativt enkel fråga som ”Vad heter världens mest citerade artikel om ekonomi?”</p>
<p>Ställ frågan, och Chat GPT kan svara med en presentation av en fiktiv artikel. <strong>David Smerdon</strong>, lektor i ekonomi vid University of Queensland, har <a href="https://threadreaderapp.com/thread/1618816703923912704.html">förklarat</a> varför i en lång tråd på X.</p>
<p>Det mest sannolika svaret på frågan börjar med orden ”Världens mest citerade artikel om ekonomi heter…” Vilka ord borde ingå i titeln? De vanligaste orden i titlarna på de mest citerade artiklarna är ”economic”, ”theory” och ”history”. Alltså uppfinner Chat GPT ett verk med titeln <em>A theory of economic history</em>.</p>
<p>Vem har skrivit denna icke-existerande artikel? Den mest citerade ekonomihistorikern är Nobelpristagaren <strong>Douglass North</strong>. Han får bli upphovsman, men eftersom vetenskapliga artiklar brukar ha flera författare behövs minst ett namn till. North har skrivit många artiklar ihop med <strong>Robert Thomas</strong>, som Chat GPT anger som författare nummer två. Var är artikeln publicerad? Den tidskrift som oftast nämns i samband med North och Thomas heter <em>The Journal of Economic History</em>. Så går det till när Chat GPT uppfinner en icke-existerande artikel, skriven av två verkliga ekonomer och publicerad i en verklig tidskrift.</p>
<p>Historier av det här slaget är inte misstag eller olyckshändelser. Chat GPT gör exakt vad programmet har konstruerats att göra. Om det ibland ger korrekta och användbara svar beror det på att den mest sannolika ordföljden just i det fallet råkar motsvara verkliga förhållanden. När jag gör research vill jag ha lite bättre odds än så.</p>
<h2>Måste kontrollera själv</h2>
<p>Open AI, som ligger bakom Chat GPT, känner naturligtvis till att programmet ger fiktiva svar, men motargumentet från AI-branschen lyder: det är ingen fara, så länge de som använder våra produkter förstår att de själva måste kontrollera alla påståenden. Föreställ dig att miniräknaren, när den var spännande ny teknik på 1970-talet, hade varit lika opålitlig och att den hade sålts in med samma argument: visst, den räknar fel ibland, men så länge du själv kan kontrollräkna kvadratroten ur pi med papper och penna är det inga problem.</p>
<p>Om du ställer matematiska frågor till Chat GPT är det också bäst att kontrollräkna, <a href="https://arstechnica.com/science/2023/05/when-it-comes-to-advanced-math-chatgpt-is-no-star-student/">skriver</a> vetenskapsjournalisten <strong>Kenna Hughes-Castleberry</strong> i <em>Ars Technica</em>. Programmet är suveränt bra på att simulera det auktoritära tonfallet i matematiska texter – ”låt x vara arean av en kvadrat med sidan y…” – men det svar som följer är ibland rappakalja av ett slag som det krävs en universitetsutbildad matematiker för att genomskåda.</p>
<blockquote><p>Internet har blivit nedsmutsat av AI-genererad ordvälling&#8230;</p></blockquote>
<p>Den amerikanske filosofen <strong>Daniel Dennett</strong> gillade att provocera läsarna med sin materialistiska syn på medvetandet. Att lära sig en ny färdighet, har han sagt, är lika med att ladda ner en ny app till sin ”necktop computer”. Mot slutet av livet blev han allt mer skeptisk till AI. Att släppa ut förfalskade människor i offentligheten, <a href="https://www.theatlantic.com/technology/archive/2023/05/problem-counterfeit-people/674075/">skrev</a> han i en av sina sista texter, borde bestraffas lika strängt som att sprida falska pengar. Utan förtroendet för ett gemensamt betalningsmedel finns inget samhälle – och med offentliga uttalanden är det likadant, menade Dennett. Kan jag inte lita på att den röst som talar till mig tillhör en människa har vi introducerat en ny form av korruption, som kommer att fräta sönder vårt mellanmänskliga förtroende.</p>
<p>I februari 2023 meddelade den lilla amerikanska science fiction-tidskriften <em>Clarkesworld Magazine</em> att den inte längre kunde ta emot manus, eftersom tidskriftens mejlkorg översvämmades av AI-genererat skräp. För att åskådliggöra hur ohållbar situationen hade blivit <a href="https://neil-clarke.com/a-concerning-trend/">lade</a> man ut ett diagram över antalet mejladresser som redaktionen måste blockera. Spiken i diagrammet visar vad som hände när Chat GPT kom in i matchen. Observera att stapeln för februari 2023 bara innehåller data för halva månaden.</p>
<p><img fetchpriority="high" decoding="async" class="alignnone wp-image-174197 size-full" src="https://kvartal.se/wp-content/uploads/2025/04/AI-graf.png" alt="kvartal" width="1126" height="660" data-wp-pid="174197" srcset="https://kvartal.se/wp-content/uploads/2025/04/AI-graf.png 1126w, https://kvartal.se/wp-content/uploads/2025/04/AI-graf-300x176.png 300w, https://kvartal.se/wp-content/uploads/2025/04/AI-graf-768x450.png 768w, https://kvartal.se/wp-content/uploads/2025/04/AI-graf-600x352.png 600w" sizes="(max-width: 1126px) 100vw, 1126px" /></p>
<p>För mig var det här diagrammet en första regndroppe som varslar om att en syndaflod är på väg.</p>
<h2>Förfalskade artiklar</h2>
<p>Ett år senare förklarade Wiley, ett av de mest respekterade akademiska förlagshusen, att det lade ner 19 av sina vetenskapliga tidskrifter på grund av problem med förfalskade artiklar. I samband med det sade <strong>Kim Eggleton</strong>, ansvarig för peer reviews på vetenskapsförlaget IOP, till <em>Wall Street Journal</em> att det <a href="https://www.wsj.com/science/academic-studies-research-paper-mills-journals-publishing-f5a3d4bc">växande antalet</a> förfalskningar hotar hela branschen.</p>
<p>Digitalt fejk går betydligt snabbare att producera än verklig forskning och journalistik. Hur många trollfabriker, organisationer och stater kommer att vilja dränka världen i falska nyheter, fiktiva opinionsundersökningar, manipulerade historiska dokument och påhittade vetenskapliga rapporter? Hur många redaktörer för dagstidningar och bokförlag kommer snart att befinna sig i samma situation som <em>Clarkesworld</em>? Samma fråga gäller också bibliotekarierna. De kommer inte att få det lättare när de måste hantera en <a href="https://www.404media.co/ai-generated-slop-is-already-in-your-public-library-3/">flodvåg</a> av AI-genererade texter.</p>
<p><strong>Robyn Speer</strong> har utvecklat open source-projektet <em>Wordfreq</em>, som studerar slang, trender och språkanvändning på nätet. I september förra året bestämde hon sig för att lägga ner projektet. Internet har blivit så nedsmutsat av AI-genererad ordvälling att det var meningslöst att fortsätta. ”Jag tror inte att någon har tillförlitliga data om människors språkanvändning efter 2021”, <a href="https://www.404media.co/project-analyzing-human-language-usage-shuts-down-because-generative-ai-has-polluted-the-data/">sade</a> hon till sajten <em>404media</em>.</p>
<h2>Inte bara text</h2>
<p>Problemet handlar inte bara om text; även bildgenererande AI har börjat översvämma nätet med pseudoinformation. Den som söker efter kända konstnärer som <strong>Monet</strong> eller <strong>van Gogh</strong> kommer att <a href="https://maggieappleton.com/generative-forgery">hitta</a> mängder av verk som de aldrig har målat. Ibland är förfalskningarna klumpiga, ibland är de övertygande. Hur länge kan det pågå innan nätet har blivit oanvändbart som informationskälla? Kommer du att sluta googla när hälften av sökresultaten ser ut som AI-genererat skräp – eller räcker det med en tredjedel? Och vad ska du göra sedan? Kanske rycker du på axlarna och fortsätter som förut.</p>
<p>Jämför med vad som hände när <strong>Edward Snowden</strong> avslöjade att Google, Apple, Facebook och Microsoft hade hjälpt USA:s säkerhetstjänst att massövervaka sina användare: ingenting alls. Folk blev kanske lite mer cyniska, men vi fortsatte att använda storföretagens tjänster. Människan kan mycket väl leva i ett korrupt samhälle där all information är osäker eller opålitlig.</p>
<p>AI-genererade bilder är numera så realistiska att foton och videoklipp inte längre är användbara i nyhetsförmedlingen. En video av <strong>Donald Trump</strong> som blir arresterad av polis bevisar ingenting. Möjligen kan du fortfarande misstänka att det är något skumt på gång om du stoppar videon och ser att en av poliserna har sju fingrar, men ge <a href="https://arstechnica.com/tag/deepfakes/">deepfake-tekniken</a> några år till, så gör den säkert inte lika avslöjande misstag. Observera att det här gäller allt källmaterial – även foton och film som historisk dokumentation. Kanske vill du att den kinesiska armén ska ha befriat Auschwitz och tagit <strong>Hitler</strong> tillfånga; i så fall är det lätt att fejka en lagom repig och trovärdig journalfilm.</p>
<h2>AI i skolorna</h2>
<p>Vi har försatt oss i ett läge där ingen information, varken text, bild eller video, är pålitlig eller användbar utan specialistkunskaper. Hur många generationer kan de nödvändiga specialkunskaperna överleva i en sådan värld?</p>
<p>När tusen amerikanska skolor tillfrågades svarade <a href="https://www.forbes.com/sites/emmawhitford/2023/03/25/how-chatgpt-is-fast-becoming-the-teachers-pet/?sh=b41cbb05177c">hälften</a> av dem att de hade använt Chat GPT i undervisningen. Trycket på att få in AI i skolorna är enormt. Här finns lättförtjänta skattepengar, plus en marknad som har visat att den gång efter gång låter sig förföras av de senaste trenderna. Varför skolan har så bråttom att tillägna sig den senaste tekniken förstår jag inte; det tar förmodligen lika lång tid att lära ett barn att läsa idag som i antikens Grekland.</p>
<p>Under industriåldern brukade samhällskritiken handla om alienation; människan hade skapat fantastiskt kraftfulla maskiner, men snart blev det uppenbart att vi i samma ögonblick hade reducerat oss själva till maskinernas tjänstefolk. Industriarbetarna hade blivit servicetekniker åt sina maskiner och var tvungna att anpassa sig till deras arbetstempo. Trots 100 år av den sortens kritik håller vi nu på att upprepa samma sak med intellektuella och kreativa yrken. I förlagsbranschen är det på modet att låta AI göra en grovöversättning och sedan kalla in mänskliga översättare för att rätta de mest uppenbara språkfelen. Det kan fungera så länge vi har en generation av översättare med årtiondens erfarenhet av språklig lyhördhet – men det är inget människovärdigt arbete, och det innebär en enorm kunskapsförstörelse.</p>
<p>Och hur ska nästa generations översättare skaffa sig de erfarenheter som gör att de förstår att översättning är mer än att byta ett ord mot ett annat?</p>
<p>Lägg samman alla dessa anekdoter, och det som framträder är en teknik som sätter punkt för informationssamhället just i det ögonblick när vi trodde att vi var på väg in i det. Varför har vi fått den sortens teknologi? För att ett litet antal människor är kåta på en gammal 1900-talsfantasi om tänkande maskiner och för att mängder av människor hoppas tjäna snabba pengar på den senaste teknologiska hajpen. I båda fallen struntar de i konsekvenserna.</p>
<h2>Teknologiska barnsjukdomar?</h2>
<p>Det jag har beskrivit i den här artikeln borde kanske betraktas som något slags inledande teknologiska barnsjukdomar. Kommer vi om några år att återvända till fungerande universitet och pålitliga nätsökningar? I bästa fall blir det så, men även om vi tror det borde vi fråga oss hur mycket tålamod med barnsjukdomar och oavsiktliga sidoeffekter det är rimligt att ha.</p>
<p>Hur mycket ska den nya tekniken tillåtas förstöra innan vi konstaterar att det den eventuellt kommer att ge oss inte kan väga upp det som har gått förlorat? Det är som om bilen, när den var ny, hade haft bromsar som bara fungerade ibland – och som om man hade försökt få oss att tro att det var en bra idé att genast släppa ut ett par miljoner av dem på vägarna medan man väntar på att bromsproblemet ska lösa sig av sig självt lite längre fram.</p>
<blockquote><p>De vackra förväntningar på datorerna som fanns kring millennieskiftet har vänts i sin motsats på förunderligt kort tid.</p></blockquote>
<p>Finns det inga fördelar med AI? De bästa exemplen på att tekniken kan göra verklig nytta kommer från naturvetare som använder AI i sin forskning. Programmet Alpha Fold, som har utvecklats av den brittiske forskaren <strong>Demis Hassabis</strong> företag Deep Mind (numera uppköpt av Google), har <a href="https://www.youtube.com/watch?v=P_fHJIYENdI&amp;t=1179s">revolutionerat</a> kunskapen om proteinmolekylernas tredimensionella struktur. Så fort Alpha Fold kom in i matchen ökade antalet kartlagda proteinstrukturer från 150 000 till 200 miljoner – vilket innebär att vi snart känner till samtliga proteiner som bygger upp alla levande varelser på Jorden. För detta genombrott delade Hassabis och hans kollega <strong>John Jumper</strong> Nobelpriset i medicin 2024.</p>
<p>Men forskningen är ett specialfall; här rör det sig om människor som styr tekniken i stället för att låta sig styras av den. De har en realistisk uppfattning om vad programmen kan göra, de ger dem en specifik, begränsad uppgift och de vet hur de ska bedöma resultaten.</p>
<p>De vackra förväntningar på datorerna som fanns kring millennieskiftet har vänts i sin motsats på förunderligt kort tid. Ingen tror längre att världen kommer att bli bättre av att miljarder människor knyts samman i ett nätverk där de kan utbyta information fritt och okontrollerat. Tvärtom: kontakt är farligt. Om stora mängder främlingar börjar kommunicera kommer de att radikaliseras, vilket leder till rasism, konspirationsteorier och hot – och snart har vi en mobb som stormar parlamentet.</p>
<p>Kanske är informationssamhället en kort historisk parentes mellan en gammal illitterat epok och en lika okunnig och illitterat framtid. Det verkliga informationssamhället kan ha varit det som folkrörelser och studieförbund byggde underifrån vid förra sekelskiftet – se idéhistorikern <strong>Ronny Ambjörnssons</strong> bok <em>Den skötsamme arbetaren</em> (Carlssons 1988). Kommer vi att återvända till något som påminner om medeltiden, till ett samhälle där allt som finns är rykten, fördomar, myter och självsäker okunskap – och kommer vi i så fall att trivas med det? Vi har ju varit där förut.</p>
<p>Om vi inte vill att det ska gå illa är det dags att sluta vara snälla konsumenter som lydigt anpassar oss till den teknik vi råkar få. Vi förtjänar en bättre, mänskligare och mer spännande framtid än den som AI-branschen försöker sälja på oss.</p>
<div class="author-byline">Håkan Lindgren är frilansskribent.
</div>
</div>
