Deutschland ist KI Land

 Häufig wird behauptet, Deutschland wäre rückständig was Künstliche Intelligenz angeht. Die Zahlen sprechen jedoch eine andere Sprache. Die Technology adoption rate misst den Prozentsatz der Bevölkerung, die eine neue Technologie aktiv nutzen. Für "Large language modelle" beträgt sie:

2020, 1%
2021, 3%
2022, 9%
2023, 28%
2024, 42%
2025, 51%
2026, 58%
2030, 82% (Prognose)

Seit 2025 nutzen nach dieser Tabelle die Mehrheit der Deutschen Large language modelle. Die zeitliche Entwicklung seit 2020 verlief ähnlich wie in anderen Ländern auch. Innerhalb weniger Monate explodierte die Zahl der Benutzer. Andres als in 2020 sind large language modelle nicht länger eine Spezialanwendung für Wissenschaftler sondern sie werden von fast allen Menschen genutzt. Die Zahl der Personen die noch nie chatgpt um Rat gefragt haben ist inzwischen eine Minderheit. So ähnlich wie der Anteil jener Personen die noch nie im Internet gesurft haben, oder noch nie das Fernsehen eingeschaltet haben.

Lediglich was den Umgang mit fortschrittlicher Robotik angeht sind die Deutschen konservativ bis ablehnenden eingestellt. Der Prozentsatz an Personen die schonmal mit einem sprachgesteuerten Roboter interagiert haben, dürfte bei unter 1% liegen. Gleichzeitig ist dieser Technologiezweig vermutlich zukünftig sehr entscheidend. Es ist also nicht so, dass die Deutschen aktiv unerprobte Technik ausprobieren und gierig wären auf neues, sondern lieber wartet man ab, bis etwas in den Mainstream einsickert und für die Masse verfügbar ist. Das ist bei sprachgesteuerten Robotern derzeit nicht der Fall.

Deutschland ist KI Land, Teil 2

Die Anzahl täglich versendeter Prompts an Large language modelle zu schätzen ist schwierig aber machbar. Wenn man annimmt dass rund 50% der Bevölkerung diese neuartige Technologie nutzen (selten bis mittelmäßig oft) kann man von rund 80 Mio versendete Prompts täglich ausgehen. Monatlich sind das stolze 2.4 Milliarden Prompts nur aus Deutschland. Das ist eine Menge an KI erzeugter Interaktion, die stattfindet.

Der Wert ist eher zu gering geschätzt und dürfte künftig weiter steigen. Selbst wenn die Deutschen von sich behaupten, KI nicht zu mögen, nutzen sie diese Technologie erstaunlich oft. 

Was tun gegen AI slop?

 Nach der Dead internet Theory besteht ein großteil des Internet aus KI generierten Inhalten wodurch eine Verflachung einsetzt und menschlich erzeugter Content zurückgedrängt wird. Die logische Frage lautet wie schlimm das ist und wie man den Prozess aufhalten kann.

Leider ist dieser Diskurs über AI slop nicht besonders produktiv sondern führt in eine Sackgasse bei dem technische Details ausgeblendet werden. Das Internet rein auf Inhalte zu reduzieren und die Technologie dahinter als gegegeben zu betrachten ist das eigentliche Problem.

Technisch gesehen entstanden KI erzeugte Inhalte ab dem Jahr 2023 mit dem Aufkommen der ersten LLM welche Text, Fotos, Bilder, Videos und Musik erzeugen können. Die Zeit vor 2023 war das Internet menschlich erzeugt. Computer konnten zwar Inhalte anzeigen in einem Webbrowser und über weite Strecken per Glasfaserkabel übertragen aber Computer waren nicht in der Lage Inhalte zu generieren, von kleineren Ausnahmen wie fraktale und Povray raytracing Bildern abgesehen.

Die Kritik an KI erzeugten Inhalte ist eine versteckte Kritik an large language modellen. Diese sind die technische Basis um mit einem simplen Prompt längere Texte zu erzeugen wie Kurzgeschichten, Fachtexte oder Powerpoint Folien. Historisch gesehen war vermutlich das SCIgen Projekt das erste Beispiel für AI slop. Im Jahr 2005 hat ein Computerprogramm die Inhatle von mehreren Powerpoint Folien erzeugt die dann von verkleideten Wissenschaftlern auf einer fachtagung präsentiert wurden.[1] Aus heutiger Sicht könnte man sagen dass Jeremy Stribling et. al. damals AI Slop erzeugt haben und diesen vor anderen Wissenschaftler präsentiert haben.

Es gibt sogar ein objektives Instrument um AI slop zu erkennen und zwar mit Hilfe eines Turing Tests. Dabei werden einer versuchsperson mehrere Texte präsentiert und die Versuchsperson muss entscheiden ob der Autor ein Mensch oder ein Computer war. Kann die Versuchsperson das nicht anhand der Texte ermitteln hat der Computer den Turing Test bestanden.

[1] https://pdos.csail.mit.edu/archive/scigen/#talks

VLA models -- the upcoming revolution in AI

 Since the year 2023, there are Large language models (LLM) available which are soem sort of advanced chatbots. A LLM can answer question, programs a computer code and can paint an image. Even if these systems are looking powerful there is a much more advanced technology available not released yet which is a VLA model.

VLA stands for vision language action model. It can handle text in combination with robotic action which is needed to control biped robots and drones both. The user interface looks similar to a LLM because there is a text box and the user enters a prompt. The difference is, that the AI software will convert the prompt into action. An example prompt might be "walk in a circle" "bring me the red ball".

Similar to a LLM, a VLA Model works with natural language. The AI won't do anything by its own but its a text based interaction between human and machine. The innovation is, that the output of the AI isn't restricted to a text window on the monitor but the AI has access to servo motors in the reality or can control ingame characters in a videogame. Such kind of AI is available in research prototypes and was described in academic papers but its not available as commercial product for everyone.

Current LLM can simulate the behavior in parts today. Its possible to upload a JPEG image to the internet and the AI can describe the picture with words. Such kind of picture to text annotation seems a bit useless, because its obvious what is shown on the picture. So the feature is used seldom in the reality. Only in combination with actuator control of a robot it makes sense to annotate pictures. Because the robot needs to transform the camera signal into text and then take decisions in response to the information.

Newspaper with AI advertisement

 

The upcoming Claude mythos LLM

 There are rumors available about a new large language model called "Claude mythos" which wasn't released yet. Its not very hard to describe its potential features because existing large language models have a lots of disadvantages.

Chatgpt and co are able to generate source code for example in Python and C but they are not able to execute in a virtual environment. The human user will notice this restriction because the LLM generated code contains sometimes smaller errors. For example the python interpreter might report that in a line 30 something is wrong. The current situation in may 2026 is, that the user has to submit the error message from python to the chatgpt LLM and then the chatbot will create the improved version which might contain another error. It takes a lot of time to produce a runnable software with such a feedback loop.

Suppose a large language model has an internal python interpret which can execute sourcecode and improve it. This would lower the needed feedback loops with a human and allows the LLM to generate error free programs in the frist attempt.

In general its about an environment to test software or test the actions of a robot. The assumption is that Claude mythos will have such a built in environment which improves AI based software engineering drastically.

The proposed abilities of Claude mythos to find bugs in existing software project is perhaps working with the same method. Before its possible to find a bug and fix it, there is a need to simulate the software in a simulator. Such a simulator is used by human programmers since years, its mostly a Gnu compiler which converts c code into binary code plus a virtual machine which is qemu to run the software. Every possible bugfix is compiled first to verify that there is no error in the code and then the binary file is run in a simulator to verify if the software is fixing the problem. The chance is high is that claude mython works with a similar principle.

This would allow a computer not only to generate source code, but also determine the outcome of the generated code. Such an LLM would be more useful than existing LLM which do not have such features. 

Wie Computer das denken lernen

 In der Geschichte der Künstlichen Intelligenz gab es zahlreiche versuche einer Maschine das Denken beizubringen. Zunächst wurde Denken über Algorithmen simuliert. Die Vorstellung war, dass eine denkende Maschine ein Programm abarbeitet und das Ergebnis dann eine Entscheidung ist z.B. den Roboter nach norden zu steuern.

Theoretisch mag das Konzept sinnvoll klingen es scheitert jedoch sobald man versucht einen solchen Algorithmus zu programmieren. Es ist nicht klar, wie man genau anfängt und wie vorhandene Algorithmen verbessert werden können. In der Summe ist der Versuch Denken als Algorithmenausführung zu definieren gescheitert.

Eine neuere und erfolgversprechende Methode dennoch dem Computer das Denken zu lehren ist die natürliche Sprache. Die Annahme lautet dass Denken identisch ist mit Sprachverarbeitung. Um Sprache von einem Computer verbeiten zu können ist ein interaktiver Ansatz möglich. Man sendet an den Roboter z.B. einen Satz wie "fahre nach norden" und der Computer übersetzt den Satz in eine Handlung. Oder man sendet an den Computer ein Wort wie "Apfel" und der Computer zeigt daraufhin das passende Bild mit dem Obst.

Wenn man die interaktion mit dem Computer in datensätzen dauerhaft speichert und darüber neuronale Netze trainiert erhält man moderne LLM Chatbots wie sie seit 2023 entwickelt werden. Diese kommen menschlichen Denken sehr nahe.

Das besondere an der sprachbasierten Künstlichen Intelligenz ist, dass sie nicht länger von Algorithmen definiert ist. ZWar beinhalten Large language modelle auch eine Softwarekomponente doch der weitaus wichtigere Teil ist die .csv Datei worin Frage / Antwort Paare gespeichert sind.

Productivity boost with artificial Intelligence

 Programming in computer science works different in each year. In the 1980s a typical pong clone was realized in Assembly language which takes around 2 weeks until the program is running error free. The result is, that there are two paddles on the screen which can be moved with a joystick and the self created game engine counts the score.

In the 1990s the typical programming language was C which allows to program the same game much faster. Its assumed that the average programmer can create a pong clone in C in around 3 days by using existing graphics libraries and tutorials from the Internet. This might explain why C has replaced assembly programming.

Todays situation in the year 2026 is, that with the help of large language models its possible to create python code for a pong videogame in around 10 minutes. The programmer formulates the text prompt and is testing the generated python code on the local macihne.

In future its likely that the producivity will increase more, perhaps its possobiel to create a pong clone in under 3 seconds and program more advanced software also with Artificial intelligence.

The success of Artificial Intelligence since 2020

 The acceptance of new technology is measured with the user count. In the 1980s expert systems and robotics was available but nobody was using it. These software and hardware was only known in dedicated AI labs.

In contrast large language models available since 2020 are used by large amount of users world wide. Here is a timeline with the estimated number of users:

2020, <1 million
2021, 5 million
2022, 120 million
2023, 500 million
2024, 1200 million
2025, 2100 million
2026, 3500 million

Automatic coding with Google Gemini

 

Since the advent of GPT-3 in 2020 lots of improvement are visible, especially the ability of large language models to code software programs is impressive. To check out the current capabilities a demanding example should be presented. Its a Tetris game written python with a built in feature vector. The feature vector is useful for creating an AI for Tetris.

The prompt consists of a multi-step pipeline. At first, the LLM was asked to create an elaborated prompt which gets executed in the second step.

Create a "Prompt Engineering" cheat sheet designed specifically for architecting software without writing manual code. Domain is: Tetris game including semantic annotation. The annotation is based on a numerical feature vector which determines important properties of the game so that an AI player can use the feature vector to automatically playing the game. The AI doesn't need to be implemented, its enough if the feature vector is shown on the screen and commented in the code.
Execute the Tetris prompt, so that the game is shown as python code.

The resulting game works fine. It can be executed without an error. There are falling tetris pieces which can be moved with cursor keys and there is also a feature vector visible on the screen at top right. The sourcecode for the entire app is 170 lines of code and is using numpy, pygame and random as libraries.

The most complex element of the software is "the get_feature_vector(self)" routine. Most Tetris implementation found at github have no such a routine because its not needed for a human player. But the feature vector is highly important for automating the game so that the computer decides at which position each pieces should be location. It seems, that current generation of LLMs are understanding what the purpose is and how to implement it in software.

It should be mentioned that some smaller bugs are available. For example the feature "height" is working wrong. Of course, the LLM can fix the issue but this would require a rewrite of the software. Another problem is, that the layout of the screen looks a bit messy. So the game needs to be interpreted as a prototype but not as a final version.

import pygame
import random
import numpy as np

# --- Konfiguration ---
SCREEN_WIDTH = 500
SCREEN_HEIGHT = 600
BLOCK_SIZE = 30
GRID_WIDTH = 10
GRID_HEIGHT = 20
SIDEBAR_X = 320

COLORS = [
    (0, 0, 0), (255, 0, 0), (0, 255, 0), (0, 0, 255), 
    (255, 255, 0), (255, 165, 0), (0, 255, 255), (128, 0, 128)
]

SHAPES = [
    [[1, 1, 1, 1]],
    [[0, 2, 2], [2, 2, 0]],
    [[3, 3, 0], [0, 3, 3]],
    [[4, 4], [4, 4]],
    [[5, 5, 5], [5, 0, 0]],
    [[6, 6, 6], [0, 0, 6]],
    [[7, 7, 7], [0, 7, 0]]
]

class TetrisEngine:
    def __init__(self):
        self.grid = np.zeros((GRID_HEIGHT, GRID_WIDTH), dtype=int)
        self.lines_cleared_total = 0
        self.game_over = False
        self.new_piece()

    def new_piece(self):
        self.current_shape = random.choice(SHAPES)
        self.piece_color = SHAPES.index(self.current_shape) + 1
        self.piece_x = GRID_WIDTH // 2 - len(self.current_shape[0]) // 2
        self.piece_y = 0
        if self.check_collision(self.piece_x, self.piece_y):
            self.game_over = True

    def rotate_shape(self):
        """
        Matrix-Rotation: Transponieren + Zeilen umkehren.
        Semantischer Hinweis: Ändert die Form-Struktur für den Feature-Vektor.
        """
        # List comprehension für 90-Grad Rotation
        new_shape = [list(row) for row in zip(*self.current_shape[::-1])]
        
        # Kollisionsprüfung: Nur rotieren, wenn Platz da ist
        if not self.check_collision(self.piece_x, self.piece_y, new_shape):
            self.current_shape = new_shape

    def check_collision(self, x, y, shape=None):
        if shape is None: shape = self.current_shape
        for r, row in enumerate(shape):
            for c, val in enumerate(row):
                if val:
                    if (x + c < 0 or x + c >= GRID_WIDTH or 
                        y + r >= GRID_HEIGHT or 
                        (y + r >= 0 and self.grid[y + r][x + c])):
                        return True
        return False

    def freeze_piece(self):
        for r, row in enumerate(self.current_shape):
            for c, val in enumerate(row):
                if val:
                    self.grid[self.piece_y + r][self.piece_x + c] = self.piece_color
        self.clear_lines()
        self.new_piece()

    def clear_lines(self):
        full_rows = [i for i, row in enumerate(self.grid) if all(row)]
        for i in full_rows:
            self.grid = np.delete(self.grid, i, axis=0)
            self.grid = np.insert(self.grid, 0, np.zeros(GRID_WIDTH), axis=0)
        self.lines_cleared_total += len(full_rows)

    def get_feature_vector(self):
        col_heights = []
        for c in range(GRID_WIDTH):
            h = 0
            for r in range(GRID_HEIGHT):
                if self.grid[r][c] != 0:
                    h = GRID_HEIGHT - r
                    break
            col_heights.append(h)
        
        agg_height = sum(col_heights)
        holes = 0
        for c in range(GRID_WIDTH):
            found_block = False
            for r in range(GRID_HEIGHT):
                if self.grid[r][c] != 0:
                    found_block = True
                elif found_block and self.grid[r][c] == 0:
                    holes += 1
        
        bumpiness = 0
        for i in range(GRID_WIDTH - 1):
            bumpiness += abs(col_heights[i] - col_heights[i+1])
            
        return [agg_height, holes, bumpiness, self.lines_cleared_total]

def main():
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    clock = pygame.time.Clock()
    font = pygame.font.SysFont("monospace", 16)
    engine = TetrisEngine()

    drop_time = 0
    while not engine.game_over:
        screen.fill((240, 240, 240))
        dt = clock.get_rawtime()
        drop_time += dt
        clock.tick()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT and not engine.check_collision(engine.piece_x - 1, engine.piece_y):
                    engine.piece_x -= 1
                if event.key == pygame.K_RIGHT and not engine.check_collision(engine.piece_x + 1, engine.piece_y):
                    engine.piece_x += 1
                if event.key == pygame.K_DOWN and not engine.check_collision(engine.piece_x, engine.piece_y + 1):
                    engine.piece_y += 1
                if event.key == pygame.K_UP:
                    engine.rotate_shape() # ROTATION TRIGGER

        if drop_time > 400:
            if not engine.check_collision(engine.piece_x, engine.piece_y + 1):
                engine.piece_y += 1
            else:
                engine.freeze_piece()
            drop_time = 0

        # Draw Grid & Piece
        for r in range(GRID_HEIGHT):
            for c in range(GRID_WIDTH):
                if engine.grid[r][c]:
                    pygame.draw.rect(screen, COLORS[engine.grid[r][c]], (c*BLOCK_SIZE, r*BLOCK_SIZE, BLOCK_SIZE-1, BLOCK_SIZE-1))
        
        for r, row in enumerate(engine.current_shape):
            for c, val in enumerate(row):
                if val:
                    pygame.draw.rect(screen, COLORS[engine.piece_color], 
                                     ((engine.piece_x + c)*BLOCK_SIZE, (engine.piece_y + r)*BLOCK_SIZE, BLOCK_SIZE-1, BLOCK_SIZE-1))

        # AI Interface Update
        features = engine.get_feature_vector()
        labels = ["Height", "Holes", "Bumpy", "Lines"]
        title = font.render("AI INPUT VECTOR:", True, (0, 0, 0))
        screen.blit(title, (SIDEBAR_X, 20))
        for i, val in enumerate(features):
            txt = font.render(f"{labels[i]}: {val}", True, (0, 0, 0))
            screen.blit(txt, (SIDEBAR_X, 50 + i*30))

        pygame.display.flip()
    pygame.quit()

if __name__ == "__main__":
    main()
 

Experimente im automatischen Schreiben mittels Luhmann Zettelkasten

 Die Ausgabequalität von large langauge models kann beliebig erhöht werden durch die Verwendung eines Notizsystems auf basis eines Luhmann Zettelkastens. Diese notizen werden ebenfalls von der Künstlichen Intelligenz erzeugt. Als Thema wurde "Geschichte der Technik von 1500 bis 2000" gewählt, weil sowohl geisteswissenschaftler als auch Mathematiker mit der TEchnikgeschcihte halbwegs vertraut sind und es leicht fällt die qualität des erzeugten Texte zu überprüfen.

Für das Experiment wurden diesmal 76 Karteikarten erstellt, also weit weniger als empfohlen wird für eine akademische Hausarbeit. Grund ist, dass bei jedem Durchlauf mit dem large language modell nur je 10 neue Karteikarten generiert werden können mangels Ressourcen der KI.

Das Ergebnis wurde in einem PDF Dokument wie eine wissenschaftliche Darstellung formatiert. DEr vollständigkeit halber sei erwähnt dass der komplette Text von einer KI erzeugt wurde, das also der Autor der Abhandlung eine Maschine war die einen Academic Prompt abgearbeitet hat. Ziel des Experimentes war es die Leistungsfähigkeit von LLMs besser einzuschätzen.

Kommen wir nun zum inhalt des PDF dokuments. Es besteht aus 11 Seiten Text, welches auf basis von 76 Karteikarten erzeugt wurde. Die qualität des Textes ist MIttelmaß, es ist eine reine fleißarbeit wo also die Künstliche Intelligenz wie gefordert alle wichtigen Themen zuerst in Stichworten notiert hat und daraus dann einen Fließtext auf deutsch erzeugt hat. Der Unterschied zu einem Text eines menschlichen Autors besteht darin, dass die Künstliche Intelligenz in kurzer Zeit sehr viel Text zu schreiben und sehr viele Karteikarten zu erzeugen. TEchnisch gesehen ist es denkbar, einen prompt zu formulieren der 1000 Karteikarten über TEchnikgeschichte erzeugt um daraus ein mehrbändiges STandardwerk zu diesem Thema zu erstellen. Alles vollautomatisch versteht sich.

Die eingriffsmöglichkeiten des menschlichen Prompt bedieners beschränken sich darauf die Anzahl der Karteikarten sowie das Thema vorzugeben, der rest ist Aufgabe des LLMs. DAs LLMs liest die vorhandene literatur, extrahiert stichworte, bringt diese in eine Luhmann typische Unordnung und erzeugt dafür den passenden Prosatext inkl. Rechtschreibkorrektur.

Heute verfügbare Large language modelle sind bereits mehr als ausreichend um diese Aufgabe zu bewältigen. Mag sein, dass der erzeugte Texte keine neuen Erkenntnise enthält sondern nur das vorhandene Wissen zusammenträgt. Das passiert aber mit viel fleiß und ohne größeren Fehler.

geschichtedertechnikvon1500bis2000.pdf (191 kb) 

 

 

The art of academic prompting

 In the past, academic papers were written by human scholars. The only technical support was the LaTeX formatting engine released in 1986 and improved over decades. A first attempt to generate academic papers with a context free grammar was made in 2005 based on the Scigen software. But the output quality was poor and such a paper doesn't contain any valuable information.

A more serious attempt to generate a paper with artificial intelligence is a large language model. In theory, such a neural network is more than capable in replacing human authors, the only missing element is an academic prompt. Such a prompt is needed to instruct the LLM to produce high quality output. A simple prompt like "write an arxiv like paper about {topic]" would generate only low quality content and can't compete with a handwritten papers. A much better prompt is given here:

Create a Luhmann zettelkasten, each notecard has a title, a luhmann id and short keypoints. Make sure that the zettelkasten consists of overall 1000 index cards. If this large amount of content can't be created in a single step, delegate the task to multiple instances of Large language models. if the zettekasten was created convert the index cards into an academic paper. The overall topic is [topic].

Such kind of prompt will emulate the chaotic writing process of a human author and will generate a high quality academic paper. It can compete with existing handwritten papers and on the long hand it will replace existing scholarly pipeline based on traditional craftsmanship.

For a human author such a command would be a long term project which will need around 1 year. It takes time to create a Luhmann style zettelkasten because each note card contains the references to academic literature. But a computer can do the same task much faster. 

The inbetween step with a zettelkasten note card system is needed to maintain a memory of the subject. It allows the AI to develop the ideas in an iterative fashion which results into higher quality of the output paper.

The prediction is, that such a LLM prompt will pass the turing test for academic papers, that means, a human peer reviewer can't say if a certain paper was created by a human or a machine. This allows to scale up the automated writing process which replaces outdated human driven academic writting with modern AI generated scholarly content. The amount of annual created papers will explode and at the same time the quality of each paper is much higher. 

Erstellen einer wissenschaftlichen Hausarbeit mit Hilfe von Large Language Modelle zum Thema Halle 54 und die Automatisierung in den 1980er Jahren

 __Einleitung__

Von Large Language modellen wie chatgpt und Google Gemini ist bekannt dass sie kleinere Recherchen unterstützen können und technisch in der Lage sind, die Rechtschreibkorrektur einer wissenschaftlichen Ausarbeitung zu übernehmen. Unklar war hingegen, ob Large Language modelle auch eine komplette Hausarbeit verfassen können. Eine solche Aufgabe erfordert üblicherweise einen menschlichen Aufwand von 1 Monat und länger und liegt damit außerhalb der Leistungsfähigkeit heutiger KI Systeme. Dies behauptet zumindest der https://metr.org/ benchmark. Danach können die derzeit leistungsfähigen neuronale Netze Programmier Aufgaben ausführen für die Menschen rund 10 Stunden benötigen, z.B. das Implementierungen eines Netzwerkprotokolls.

Will man längere komplexe Tasks mit Hilfe von LLMs bearbeiten benötigt man eine spezielle Reward funktion, ein Multiagentensystem oder ähnliche Hilfsmittel weil sonst die Gefahr besteht, dass die KI sich in einer endlos Schleife verfängt, Also bereits erstellten Quellcode oder vorhandene Texte erneut editiert ohne dass ein erkennbarer Fortschritt sichtbar wird.

Im folgenden Fall wurde ein anderes Konzept verwendet, was als Luhmann Zettelkastenmethode bekannt ist. Diese Methode wird in den Geisteswissenschaften verwendet um eine Hausarbeit zu ordnen und hilft ebenfalls dabei die Interaktion mit einem Large language modell zu strukturieren.

Als Thema der Hausarbeit wurde gewählt "Halle 54 Automatisierung in den 1980er Jahren" weil es gut eingrenzbar ist und mit etwas Literaturrecherche leicht in einen wissenschaftlichen Text überführt werden kann. Zuerst benötigt man einen Prompt um das Problem für ein LLM zu schildern:

__Prompt__

titel: Die Halle 54 bei VW als gescheitertes Automatisierungsprojekt in den 1980er Jahren

Aufgabe: Erstelle 8 Luhmann Karteikarten zum Titel. Jede Karteikarte enthält eine Luhmann ID, einen Titel, und Stichpunktartige Notizen welche ruhig chaotisch sein können. Stelle sicher dass weitere künftige Karteikarten angefügt werden können. Ausgabesprache ist Deutsch.

Inhalt: Ungefähr im Jahr 1983 gab es beim Autohersteller VW ein Robotik Automatisierungsprojekt in der Halle 54. Damals wurden computergesteuerte Roboter eingesetzt um das Ziel der Vollautoamtisierung der Fahrzeugproduktion umzusetzen. Später stellte sich heraus, dass der angestrebte hohe Automatisierungsgrad technisch nicht machbar ist. Die damalige Hard- und Software blieb hinter den hohen Erwartungen zurück.
-----
Beides, erzeuge ingesamt 8 weitere Karteikarten.
Ja, und erzeuge weitere Karten zur verwendeten Software beim Halle 54 Projekt (wenn es dazu Informationen gibt)
Erstelle für die bisherigen Karteikarten einen Strukturzettel als Gliederung für eine wissenschaftliche Hausarbeit.
Nein, beginne stattdessen mit dem Schreiben des Volltextes für das Kapitel "1. Einleitung: Der Traum von der menschenleeren Fabrik" auf basis der vorhandenen Karteikarten. Der Volltext sollte rund 800 Worte enthalten.
-----

Wie im prompt gefordert erzeugte die KI zuerst einmal Karteikarten und zwar 24 stück. Anschließend wurde ein Strukturzettel erstellt, also eine Karteikarte die auf andere Karteikarten verweist. Diese Karteikarten wurden dann in einen Fließtext überführt der hier vollständig abgedruckt ist.

Im Fließtext verstreut finden sich Referenzen zu den Luhmann Karteikarten, z.B. "(ID 3.5)". Der Text ist also nur die Ausformulierung der vorhandenen Notizen. Über den Zwischenschritt "Karteikarten" ist es möglich, auch sehr umfangreiche Themen abzubilden.

__Kritik__

Für das vorliegende Experiment wurden lediglich 24 Karteikarten plus 1 Strukturzettel von einem LLM erstellt. Für eine echte wissenschaftliche Hausarbeit benötigt man mehr Karteikarten und zwar ungefähr 100+.

__Volltext __

 halle54.pdf

Hohe Einstiegshürden für lokale LLMs

 Obwohl es im Internet viele Tutorials gibt wie man auf der Workstation ein Large language model betreiben kann ist objektiv gesehen das Unterfangen zum Scheitern verurteilt. Eine aktuelle PC Workstation für 1000 EUR ist um den Faktor 500 zu klein und zu wenig leistungsfähig um einen halbwegs aktuellen Chatbot zu betreiben. Und es geht hier lediglich um Textchatbots nicht um um generative Bilderzeugung oder generative Audiogenerierung. 

Zu den Details. Die Basis für jeden chatbot der mittels neuronaler Netze betrieb wird ist ein Word embeddings model. Es gibt dazu mehrere Opensource Projekte wie Fasttext oder gensim die mit vortrainierten Word embeddings ausgestattet sind. Allerdings ist die Datei die man sich aus dem Internet herunterladen muss stolze 5 GB groß. Und diese Datei ist als minimal Word embedding zu verstehen. Wenn man die Datei im RAM entpackt steigt der Speicherbedarf auf 16 GB An. Und damit hat man nur das word embedding also eine Zuordnung von Worten aus dem Lexikon zu semantischen Kategorien in Matrizenschreibweise. Will man dieses word embedding model für ein Question answering problem anwenden oder damit lokale Textdateien indizieren erhöht sich der Speicherbedarf weiter.

Eine halbwegs solide Hardware um lokale Large language modelle zu betreiben startet bei Anschaffungskosten von 500k EUR. Darin enthalten ist RAM in Höhe von 16 Terabyte. Diese Hardware ist keine Workstation mehr sondern wäre ein Superminicomputer, der unerschwinglich ist für Privatpersonen und allenfalls von Universitäten oder Firmen betrieben werden kann. Mit so einem System ist es in der Tat möglich, einen chatbot aufzusetzen bestehend aus word embeddings, der fasttext library plus einiger Volltextdatenbanken. Auch für künftige Projekte wären die veranschlagten 16 TB RAM ausreichend, das heißt man könnte Experimente machen in Richtung maschinelle Übersetzung oder im automatischen Programmieren.

Wie ein kleiner Blick auf die Kosten zeigt, sind lokale LLM Systeme außerhalb der Möglichkeiten von privatanwendern. Diesen verbleibt nur auf Cloud Anbieter zu setzen, wo also die Hardware im Internet betrieben wird und der Nutzer lediglich Zugriff erhält auf den chatbot. Entweder über den webbrowser oder eine API schnittstelle.

Selbstverstänglich kann man kritisch fragen, ob man nicht auch mit weniger Aufwand ein lokales LLM betreiben kann. Das man also word embeddings nutzt die kompakter sind und vielleicht nur 10 MB benötigen. Leider lautet die 'Antwort darauf nein, sowas ist technisch nicht möglich. Die ersten Large language modelle wie GPT-2 wurden ab den Jahr 2022 entwickelt. Will man ohne Word embeddings und ohne sehr große Datensätze ein Projekt durchführen müsste man Technologie verwenden vor diesem Stichtag. Es gab auch vor 2022 bereits Software zur natural language processing und chatbots. Zu nennen wäre das AIML dateiformat worin man wissensbasen für chatbots speichert. Diese Systeme sind sehr genügsam was die Hardware betrifft und laufen auf normalen Desktop PCs. Leider besteht der nachteil dass AIML chatbots und äöltere dokument retrieval systeme eine sehr geringe leistung aufweisen. Ein AIML Chatbot ist eine Art von Spieleprogram womit man einen simulierten Dialog führen kann, aber was keinen echten Nutzen hat. Deshalb haben sich diese älteren Chatbots auch nie durchsetzen können. Es gibt keine Nachfrage nach solchen Systemen. Etwas ähnliches gilt für das sehr alte Eliza system, was technisch ein chatbot ist, aber für den Anwender keinen nutzen besitzt. Es ist durchaus interessant mit Eliza einen Dialog zu führen, aber nachdem man das 10 minuten gemacht hat, erkennt man die Limitierungen des Konzepts.

Moderne Large Language modelle die ab 2022 entstanden können als weiterentwicklung früherer Chatbots verstanden werden. Ihre Leistung ist höher aber gleichzeitig sind auch die Hardware anforderungen höher. 

Word embeddings as the bottleneck in large language models

 Before a computer can process written information the dataset corpus needs to be transformed into a numerical representation. Otherwise the neural network can't be trained on the data. The problem is, that nearly all input datasets are formulated in English. There are a list of question answer pairs stored in a .csv file. A typical entry might be:
"What is the north?", "Its a direction similar to east and west"
"What is red?", "Its a color similar to blue or green".

These pairs are highly sense making for humans but a computer won't understands the words. Every existing neural network architecture requires numerical data in a floating point range. Unfortunately, the example dataset has no floating point numbers but only words.

Even if the problem is obvious it was discovered very late in computer science. First attempt for document retrieval doesn't require a word embedding model. Because classical text retrieval was realized with full text search engines. The algorithm compares the input sentence with a database and returns the correct document. Only if the text retrieval should be realized with a neural network, there is a need to convert the documents into a vector space which is the task of a word embedding model like word2vec or fasttext.

Modern large language models are built with word embeddings models in the background. These embedding make sure, that the neural network understands the sentences in the corpus. The word embedding model influences how fast and accurate the resulting chatbot is. For example, a minimalist bag of word model with a vocabulary of 100 words won't understand or generate an academic paper because the translation from a full text document into a vector space doesn't work well enough.

A domain specific bag of words model is perhaps the most minimal example for word embedding and should be explained for a point & click adventure game. There are only 4 verbs (walkto, pick, drop, use) and 4 nouns (key, stairs, door, ball). Each word is assigned to a number and possible sentences looks like:

"walkto door" = (0,2)
"pick key" = (1,0)
"use ball" = (3,3)

The first number in the vector is submitted to neuron #1 while the second number is submitted to neuron #2. Most existing point&click adventures doesn't implement a dedicated word embedding model to store the internal communication vocabulary, but for exploring new tools and NLP techniques it makes sense to introduce word embeddings into video games. 

Estimate the hardware requirement for large language models

Since the advent of chatgpt in 2023, most people are familiar how to use these AI systems for executing prompts. Even non programmers are able to generate stories and create summaries of existing content in the internet. Endless amount of tutorials are available who explaining what an LLM is and how to use it to answer questions.

A seldom explored but also interesting subject is how to run a large language model on the own computer. The first misconception is, that beginners think that a large language model can be installed similar to a new Linux distribution. All what is needed is an older PC and a fast internet connection. Unfortunately, this is an underestimation about the complexity of the situation.

A more realistic assumption is, that a dedicated supercomputer is needed which costs around 1 million US$ to run a large language model. To verify this claim let us go a step backward and describe a minimalist version of a real llm.

So called, vector databases, are advanced full text databases for semantic search. They are less advanced than large language models, but more powerful than simple SQL databases. A typical example is to convert the content of wikipedia into a vector database and use the information to answer simple Question&answer problems. For example the user might ask “What is Paris?”, or “Tell me about machine learning” and the computer program has to retrieve the information from the vector database and gives a short and precise answer.

To realize such a vector database on a computer, around 12 CPU cores and 100 GB of RAM are needed. So we can say, that a vector database which is hosting a simple wikipedia dataset requires a high end root server which costs around 10000 US$.

In contrast, a dedicated large language model is more advanced than a simple semantic search on wikipedia articles. The underlying database is larger and the pipeline until an answer can be generated is more complex. Its for sure, that a large language model requires more but not less powerful hardware. Very small large language model which are working very slow can be executed on hardware which costs around 100k US$. Such kind of hardware goes beyond simple consumer hardware and consists of multiple CPU, larger amount of RAM and very important dedicated GPUs. If the attempt is to tun a state of the art llm in average performance, the initial mentioned supercomputer for 1 million US$ is required. The situation can be compared with the advent of Unix in the mid 1980s. Mainframe computer during the 1980s for running Unix were more expensive than simple 8bit homecomputers.

task	price US$
desktop PC	1000
vector database with wikipedia	10000
vector database for multiple documents	50k
minimalist large language model	100k
Large language model	1000k

To explore the capabilites of a supercomputer for 1 million US$ in detail we have to go back to the mid 1980s. During that period a DEC VAX 8600 was equipped with a 32bit CPU running at 12 Mhz, 16 MB RAM, multiple harddrives with 2 Gigabyte in total and a DECnet network. A typical usecase of a such a 1 million US$ would be database processing or a Telnet server.

For today's perspective, the goal of running a database server with only 16 MB of RAM and a 12 Mhz CPU sounds a bit optimistic, because such a configuration allows only to create smaller databases with low workload. But, the described configuration was state of the art in the mid 1980s. There was no computer available which was much faster.

The assumption is that the same dilemma is available today in the year 2025. If the goal is to run a state of the art large language model, there is a need to use a supercomputer grade hardware for around 1 million US$.

Can AI replace human programmers?

 In the year 2025, there is no clear answer available to this question. Maybe its possible to replace human programmers with an AI, or maybe not. What we can say for sure is, that for simpler tasks AI is more powerful than a human.

These simpler tasks are the chess game, the Tetris videogame and also the ability to answer programming related questions. The first chess AI which was superior over a human grandmaster was Deep blue from 1997. Playing Tetris on a grandmaster level was also demonstrated. What is missing is the proof for more advanced tasks. Despite the existence of Large language models, most existing software was written by human programmers. There are some tools available like git and programmer friendly IDE which claim to improve the efficiency but coding remains a human task. What current AI systems are able to do is to solve minor tasks within a programming project, for example to program a hello world app in python or answer a detail programming question.

The task of creating an entire application which consists of thousands lines of code is a demanding problem. Some progress was made into this direction but the outcome remains unclear. What we can say for sure is, that in the future the importance of Large language models for programming tasks will growth.

A possible benchmark to judge about an AI is its ability to contribute to existing software projects. The AI needs to create a commit which gets accepted within a project as a sense making contribution. If an AI is able to do so mulitiple times for different projects this would be a proof, that the AI can replace human programmers.

From a technical perspective, a commit is changeset in an existing project. It can be a bugfix or an additional feature. At least for simpler projects like a prime number generator or a tgictactoe videogame, current LLMs are able to do so out of the box with current technology. The open question is, if they are able to do so for more advanced projects like larger video game or en entire operating system.

Real world software projects consists of 10000 and more lines of code. In addition there is longer documentation and discussion available in a forum which needs to understood before a commit can be created. Even for an AI from the year 2025, it would a complex task.

AI generated window desktop

 

A minimalist GUI prototype written in Python and pygame was generated with an AI. Its possible to click on the file bar but executing additional programs is not possible. The source code consists of 180 lines of code and was entirely created by a large language model:

import pygame
import sys

# --- Pygame Initialization ---
pygame.init()

# --- Screen Dimensions ---
SCREEN_WIDTH = 1000
SCREEN_HEIGHT = 700
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Pygame: Desktop Simulation")

# --- Colors ---
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
LIGHT_BLUE = (173, 216, 230)
LIGHT_GREEN = (144, 238, 144)
DARK_GRAY = (50, 50, 50)
TOOLBAR_GRAY = (70, 70, 70)
BUTTON_HOVER = (90, 90, 90)
BUTTON_ACTIVE = (120, 120, 120)

# --- Font for text ---
font_small = pygame.font.Font(None, 24) # For menu items, etc.
font_medium = pygame.font.Font(None, 30) # For window titles
font_large = pygame.font.Font(None, 36) # For main elements

# --- Desktop Background ---
desktop_bg_color = (60, 60, 100) # A dark blue/purple for a desktop feel

# --- Taskbar/Top Bar Properties ---
taskbar_height = 40
taskbar_rect = pygame.Rect(0, 0, SCREEN_WIDTH, taskbar_height)
start_button_rect = pygame.Rect(5, 5, 80, 30) # x, y, width, height
start_button_text = "Start"
start_menu_active = False
start_menu_rect = pygame.Rect(5, taskbar_height, 150, 150) # Example menu size
start_menu_items = ["Terminal", "Browser", "Editor", "Settings"]
start_menu_item_rects = [] # To store rects for click detection

# --- Window Properties (as classes for easier management) ---
class Window:
    def __init__(self, x, y, width, height, color, title, content_text=""):
        self.rect = pygame.Rect(x, y, width, height)
        self.title_bar_height = 25
        self.title_bar_rect = pygame.Rect(x, y, width, self.title_bar_height)
        self.content_rect = pygame.Rect(x, y + self.title_bar_height, width, height - self.title_bar_height)
        self.color = color
        self.title = title
        self.content_text = content_text
        self.active_menu_message = "" # To show what menu item was clicked

        # Menu button rects (File and Edit)
        self.file_menu_rect = pygame.Rect(self.title_bar_rect.x + 5, self.title_bar_rect.y + 2, 40, self.title_bar_height - 4)
        self.edit_menu_rect = pygame.Rect(self.title_bar_rect.x + 50, self.title_bar_rect.y + 2, 40, self.title_bar_height - 4)

    def draw(self, surface):
        # Draw window content area
        pygame.draw.rect(surface, self.color, self.content_rect)
        pygame.draw.rect(surface, BLACK, self.content_rect, 2) # Border

        # Draw title bar
        pygame.draw.rect(surface, TOOLBAR_GRAY, self.title_bar_rect)
        pygame.draw.rect(surface, BLACK, self.title_bar_rect, 2) # Border

        # Draw title text
        title_surface = font_medium.render(self.title, True, WHITE)
        title_rect = title_surface.get_rect(centerx=self.title_bar_rect.centerx, centery=self.title_bar_rect.centery)
        surface.blit(title_surface, title_rect)

        # Draw menu buttons (File, Edit)
        pygame.draw.rect(surface, DARK_GRAY, self.file_menu_rect)
        file_text = font_small.render("File", True, WHITE)
        file_text_rect = file_text.get_rect(center=self.file_menu_rect.center)
        surface.blit(file_text, file_text_rect)

        pygame.draw.rect(surface, DARK_GRAY, self.edit_menu_rect)
        edit_text = font_small.render("Edit", True, WHITE)
        edit_text_rect = edit_text.get_rect(center=self.edit_menu_rect.center)
        surface.blit(edit_text, edit_text_rect)

        # Draw content text
        content_surface = font_small.render(self.content_text, True, BLACK)
        content_rect = content_surface.get_rect(topleft=(self.content_rect.x + 10, self.content_rect.y + 10))
        surface.blit(content_surface, content_rect)

        # Draw active menu message
        if self.active_menu_message:
            message_surface = font_small.render(self.active_menu_message, True, BLACK)
            message_rect = message_surface.get_rect(topleft=(self.content_rect.x + 10, self.content_rect.y + 40))
            surface.blit(message_surface, message_rect)

    def handle_click(self, pos):
        if self.file_menu_rect.collidepoint(pos):
            self.active_menu_message = "File menu clicked!"
            return True
        elif self.edit_menu_rect.collidepoint(pos):
            self.active_menu_message = "Edit menu clicked!"
            return True
        return False

# Create our two custom windows
window1 = Window(100, 100, 350, 250, LIGHT_BLUE, "My Documents", "Welcome to Window One!")
window2 = Window(500, 350, 400, 280, LIGHT_GREEN, "Application", "This is Window Two.")

# --- Game Loop ---
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.MOUSEBUTTONDOWN:
            mouse_pos = event.pos

            # Handle Start button click
            if start_button_rect.collidepoint(mouse_pos):
                start_menu_active = not start_menu_active # Toggle menu visibility
            elif start_menu_active and start_menu_rect.collidepoint(mouse_pos):
                # Check if a start menu item was clicked
                for i, item_rect in enumerate(start_menu_item_rects):
                    if item_rect.collidepoint(mouse_pos):
                        # In a real app, you'd launch something here
                        print(f"Launched: {start_menu_items[i]}")
                        window1.content_text = f"Launched: {start_menu_items[i]}"
                        start_menu_active = False # Close menu after selection
            else: # If click outside start menu, close it
                start_menu_active = False

            # Handle clicks on window menus
            window1.active_menu_message = "" # Clear previous messages
            window2.active_menu_message = ""
            if window1.handle_click(mouse_pos):
                pass # Handled by window object
            elif window2.handle_click(mouse_pos):
                pass # Handled by window object

    # --- Drawing ---
    screen.fill(desktop_bg_color) # Desktop background

    # Draw Taskbar/Top Bar
    pygame.draw.rect(screen, TOOLBAR_GRAY, taskbar_rect)
    pygame.draw.rect(screen, BLACK, taskbar_rect, 1) # Border

    # Draw Start button
    pygame.draw.rect(screen, DARK_GRAY, start_button_rect)
    pygame.draw.rect(screen, BLACK, start_button_rect, 1)
    start_text_surface = font_medium.render(start_button_text, True, WHITE)
    start_text_rect = start_text_surface.get_rect(center=start_button_rect.center)
    screen.blit(start_text_surface, start_text_rect)

    # Draw Start Menu if active
    if start_menu_active:
        pygame.draw.rect(screen, TOOLBAR_GRAY, start_menu_rect)
        pygame.draw.rect(screen, BLACK, start_menu_rect, 2)
        start_menu_item_rects = [] # Clear and re-populate for current frame
        for i, item in enumerate(start_menu_items):
            item_y = start_menu_rect.y + 10 + i * 30
            item_rect = pygame.Rect(start_menu_rect.x + 5, item_y, start_menu_rect.width - 10, 25)
            start_menu_item_rects.append(item_rect)

            # Check for hover effect (optional but nice for menus)
            if item_rect.collidepoint(pygame.mouse.get_pos()):
                pygame.draw.rect(screen, BUTTON_HOVER, item_rect)

            item_text_surface = font_small.render(item, True, WHITE)
            item_text_rect = item_text_surface.get_rect(topleft=(item_rect.x + 5, item_rect.y + 2))
            screen.blit(item_text_surface, item_text_rect)


    # Draw Windows
    window1.draw(screen)
    window2.draw(screen)

    # --- Update the Display ---
    pygame.display.flip()

# --- Quit Pygame ---
pygame.quit()
sys.exit()

AI revolution in one picture

 

caption: screenshot of Hugging faces on June 23, 2025

Hugging faces is an online repository which collects multiple large language models (LLM) in one place.[1] In its recent version, there are so many different LLMs available that a dedicated directory is needed to provide an overview, see the screenshot.

The website was launched in jun 2021, while the improvement with the dedicated directory is available since Feb 2025. There are AI models available for nearly every possible task like text generation, music generation, image understanding, robot control and of course OCR. Even if the website is only 4 years old, many new and improved neural networks were added. Such kind of repository wasn't available before 2021.

In contrast to former attempts of creating AI, the hugging faces website is addressing a non technical larger audience. Instead of explaining how to program a back propagation algorithm in C or discussing the latest academic papers, the user can start an AI of choice and interact with the system for creating pictures, talk with a chatbot or convert a music into another music. The underlying technology is always the same. 99.9% of the available large language models were created with dataset based neural networks which is also called Deep learning.

[1] https://huggingface.co/spaces