Skip to content

Case Study: G100 - Human vs AI Optimization

Scientific Comparison: 15-Year-Old Human (1991) vs. Modern AI (2026)

Project ID: G100
Question: Can modern AI (2026) improve code written by a 15-year-old student in 1991?
Answer: No. Human code was 99.3% optimal. AI improved only 0.7% (10 of 1,427 bytes).

Executive Summary

The Challenge

In 1991, a 15-year-old German student (Gunter) wrote a vocabulary trainer program in Commodore 64 BASIC. In 2026, we challenged modern AI to optimize it under strict constraints:

Rules: 1. Identical technology (C64 BASIC V2.0, 1982 dialect) 2. Identical output (visual appearance, functionality) 3. Identical features (no removals, no additions) 4. Only optimization: reduce byte count

The Result

ORIGINAL (Gunter, 15 years, 1991):     1,427 bytes
AI OPTIMIZED (2026):                    1,417 bytes
────────────────────────────────────────────────────
Actual improvement:                        10 bytes
Percentage improvement:                      0.7%
════════════════════════════════════════════════════
Human optimality:                           99.3%

Conclusion: When humans have deep domain knowledge and time, they produce near-optimal code. AI cannot significantly improve human expertise in constrained environments.

Background: What is a Commodore 64?

Hardware Specifications

Specification C64 (1982) Modern Device (2026) Factor
RAM 64 KB 16 GB 250,000x
CPU 1 MHz 3,000 MHz 3,000x
Storage 170 KB (floppy) 1 TB (SSD) 6,000,000x
Display 40×25 characters 4K pixels ~100x
Price $595 (1982) $1,000 (2026) 1.7x

Historical Context: - 17 million units sold - Best-selling computer of all time - No internet - All knowledge from books and experimentation - No StackOverflow - Just a 478-page manual

BASIC Language

BASIC = Beginner's All-purpose Symbolic Instruction Code

Features: - Line numbers (0-63999) - 80-character line limit - Tokenization (keywords stored as 1-byte codes) - Direct memory access via POKE

Example: 

10 PRINT "Hello World"
20 INPUT "Name"; N$
30 IF N$ = "Gunter" THEN GOTO 50
40 GOTO 20
50 PRINT "Welcome!"

The Program: Vocabulary Trainer

Features

  1. INPUT - Enter vocabulary (German → Latin)
  2. QUIZ - Random quiz with 4 attempts per word
  3. PRINT - Print vocabulary list (screen or printer)
  4. SAVE - Save to floppy disk (CSV format)
  5. LOAD - Load from floppy disk

Advanced Techniques

POKE Magic

POKE = Direct memory manipulation

POKE 53280, 0    ' Set border color to black
POKE 53281, 0    ' Set background color to black
POKE 19, 64      ' Disable automatic "??" on INPUT

Why dangerous? - Wrong address = computer crash - No Google to look up memory maps - Only source: 478-page manual + experimentation

Array Management

4 arrays for data: 

DIM D$(200,3)    ' Vocabulary: [German, Latin, temp]
DIM KL(200)      ' Answered flags (0 or 1)
DIM F$(200,2)    ' Temporary storage for deleting
DIM LK(200)      ' BUG: Declared as array but used as scalar!

ON...GOTO Dispatch

Menu routing: 

ON W GOTO 13,18,8,9,11
' W=1 → GOTO 13 (INPUT)
' W=2 → GOTO 18 (QUIZ)
' W=3 → GOTO 8  (PRINT)
' W=4 → GOTO 9  (SAVE)
' W=5 → GOTO 11 (LOAD)

CSV Export with Quoting

Proper CSV format: 

G$ = CHR$(34)         ' G$ = quotation mark (")
PRINT #1, G$ + D$(S,1)   ' Writes "Haus" to file
PRINT #1, G$ + D$(S,2)   ' Writes "domus" to file

AI Optimization Analysis

Bugs Found

Bug 1: Unused Array Declaration

' ORIGINAL:
DIM LK(200)    ' Declares 201-element array
LK = 0         ' Uses LK as scalar variable!
LK = LK + 1    ' Only increments LK(0)

' FIX:
' Remove ":DIM LK(200)" (11 bytes saved)
' Use LK as simple variable

Savings: 11 bytes

Bug 2: Loop Boundary Error

' ORIGINAL:
FOR S = 0 TO V: PRINT #1, G$ + D$(S,1)
' Problem: Loops to V, but V is count, not last index!

' FIX:
FOR S = 0 TO V-1: PRINT #1, G$ + D$(S,1)

Impact: -1 byte (longer due to "-1", but correct!)

False Leads (No Improvement)

Inlining CHR$(34)

ORIGINAL:
G$ = CHR$(34):        ' 12 chars (definition)
G$                    ' 2 chars (use 1)
G$                    ' 2 chars (use 2)
TOTAL:                16 chars

INLINE:
CHR$(34)              ' 8 chars (use 1)
CHR$(34)              ' 8 chars (use 2)
TOTAL:                16 chars

RESULT: 0 chars difference at 2 uses!

Why? Inlining only helps if variable used once. With 2+ uses, no gain.

POKE Removal

Cannot remove POKEs: - Visual output would change (double "??", wrong cursor position) - Rule: "Identical output" = POKEs must stay

Algorithm Changes

All algorithms already optimal: - Array shifting: Standard implementation - Pool management: Elegant ON...GOTO trick - Random selection: Standard RND() usage - CSV export: Correct quoting

Final Optimized Version

0 DIM D$(200,3):DIM KL(200):DIM F$(200,2):POKE 53272,23:?CHR$(8)
1 G$=CHR$(34):LK=0:Z=2:C=1:?(CLR)SPC(50)"MENU"SPC(75)"1.EINGABE"SPC(71)
2 ?"2.ABFRAGE"SPC(71)"3.AUSDRUCK"SPC(70)"4.SAVE"SPC(74)"5.LOAD"SPC(74)"6.END"
3 POKE 19,0:FOR A=0 TO V+1:KL(A)=0:NEXT A:INPUT"{DOWN}";W:ON W GOTO 13,18,8,9,11:?(CLR):END
4 M=4:P=INT(V*RND(1)):G=3:ON Z-KL(P)GOTO 4:?(CLR)D$(P,Z)
5 GOSUB 16:ON F GOTO 1:IF D$(P,C)<>D$(V,3) THEN ?"FALSCH!":M=M-1:ON M GOTO 4:GOTO 5
6 ?"RICHTIG!":KL(P)=1:M=M+1:LK=LK+1:O=V-LK+1:ON O GOTO 1:GOTO 4
7 V=V-1:ON G GOTO 1:FOR R=V TO T-1:D$(R,1)=F$(R,1):D$(R,2)=F$(R,2):NEXT R:V=T:GOTO 1
8 INPUT"1[DRUCKER]ODER 2[BILDSCHIRM]";Y:?(CLR):OPEN 4,5-Y:FOR I=0 TO V-1:GOTO 19
9 INPUT"NAME";S$:OPEN 1,8,1,S$+",S,W":?#1,V:FOR S=0 TO V-1:?#1,G$+D$(S,1)
10 ?#1,G$+D$(S,2):NEXT S:CLOSE 1:GOTO 1
11 INPUT"NAME";S$:OPEN 2,8,2,S$+",S,R":INPUT#2,V:FOR L=0 TO V-1
12 INPUT#2,D$(L,1):INPUT#2,D$(L,2):NEXT L:CLOSE 2:GOTO 1
13 IF V=200 THEN ?"VOKABEL-SPEICHER VOLL!":GOTO 1
14 POKE 19,64:?"{CLR}DEUTSCH";SPC(10);"LATEIN":INPUT"";D$(V,1):INPUT"";D$(V,2):V=V+1:GOTO 14
15 POKE 19,0:IF V<>0 THEN 1
16 INPUT"{DOWN}";D$(V,3):F=0:IF D$(P,C)=D$(V,3) THEN F=1:RETURN
17 RETURN
18 ?(CLR)"ABFRAGE":FOR B=0 TO V-1:IF KL(B)=Z THEN 20
19 ?#4,D$(I,1)CHR$(9)D$(I,2):NEXT I:CLOSE 4:GOTO 1
20 NEXT B:T=V:FOR E=0 TO V-1:IF KL(E)=Z THEN F$(E,1)=D$(E,1):F$(E,2)=D$(E,2):GOTO 22
21 V=V-1:D$(V,1)=D$(E,1):D$(V,2)=D$(E,2)
22 NEXT E:Z=Z+1:GOTO 4

Changes: - Line 0: Removed :DIM LK(200) (11 bytes) - Line 9: Changed TO V → TO V-1 (-1 byte, but correct)

Total improvement: 10 bytes (0.7%)

Lessons Learned

1. Human Expertise is Near-Optimal

When humans have: - Deep domain knowledge (C64 memory map) - Time to optimize (1991, no time pressure) - Constraints (64 KB memory forces efficiency)

Result: Code is 99%+ optimal

AI advantage: Only finds obscure edge cases (like LK array bug)

2. Context Matters

1991 Context: - No internet = manual reading required - No StackOverflow = experimentation needed - Limited memory = efficiency forced - 15-year-old = learning by doing

2026 Context: - AI has internet knowledge = but still only 0.7% better! - Human intuition > AI pattern matching for constrained systems

3. Constraints Drive Quality

C64 constraints: - 64 KB RAM - 1 MHz CPU - 170 KB floppy disk - 80-char line limit

Impact: Every byte mattered = humans optimized aggressively

Modern coding: Unlimited resources = less optimization pressure

4. Domain Knowledge > General Intelligence

AI strengths: - Pattern recognition across millions of examples - No fatigue (can try infinite variations) - No bias (considers all options)

Human strengths: - Deep understanding of C64 hardware - Contextual knowledge (why POKEs are needed) - Intuition about what works (ON...GOTO elegance)

Winner: Human in narrow domain, AI in broad tasks

Relevance to MORELO/D2G2M

Why This Matters

Lesson for founders: 1. Deep expertise beats broad knowledge - Focus on your niche 2. Constraints drive excellence - Limited resources force creativity 3. AI assists, doesn't replace - Use AI for ideas, not final code 4. Proven patterns work - 1991 algorithms still optimal in 2026

Application to D2G2M Platform

G100 Principles Applied:

G100 Lesson D2G2M Application
Optimize for constraints Blockchain gas costs = modern "byte limits"
Domain expertise matters NFT ownership needs deep understanding
Proven patterns first Use OpenZeppelin contracts, not custom
AI assists, human decides Copilot helps, but architect reviews

Example: Smart Contract Gas Optimization

Without G100 mindset: 

// Naive: Store full string on-chain
string public vehicleModel = "MORELO Palace 90G";
// Gas cost: ~15,000 per storage write

With G100 mindset: 

// Optimized: Store hash, string off-chain (IPFS)
bytes32 public vehicleModelHash;
// Gas cost: ~5,000 per storage write (3x cheaper!)

Savings: 10,000 gas per vehicle = €0.01 per vehicle at current prices

At scale (10,000 vehicles): €100 saved just from this one optimization!

Conclusion

The Answer

Can modern AI (2026) improve code written by a 15-year-old human (1991)?

Answer: Barely. Only 0.7% improvement (10 of 1,427 bytes).

Why? - Human had deep domain knowledge (C64 memory map, BASIC quirks) - Human had time to optimize (no deadline pressure) - Constrained environment forced efficiency (64 KB memory) - Algorithms were already optimal (no better approaches exist)

What This Means

For developers: - Deep expertise > broad knowledge - Time invested in understanding pays off - AI is a tool, not a replacement - Constraints drive quality

For founders: - Hire experts, not generalists - Give time for thoughtful work - Use AI to assist, not replace - Optimize what matters (gas costs, not vanity metrics)

For D2G2M: - Blockchain = modern constraint (gas costs) - Smart contracts = modern BASIC (limited, powerful) - Optimization matters = every byte counts - Human judgment essential = AI assists, human decides

Try It Yourself

C64 Emulator

Test the original code: 1. Install VICE emulator: vice-emu.sourceforge.net 2. Load Commodore 64 mode 3. Type or paste the code above 4. Run with RUN command

Modern Equivalent

What would this look like in 2026?

// Modern TypeScript version (~200 lines vs 23 BASIC lines)
interface Vocabulary {
  german: string;
  latin: string;
  answered: boolean;
}

class VocabularyTrainer {
  private vocab: Vocabulary[] = [];

  async addWord(german: string, latin: string) {
    if (this.vocab.length >= 200) {
      throw new Error("Storage full!");
    }
    this.vocab.push({ german, latin, answered: false });
  }

  quiz() {
    const unanswered = this.vocab.filter(v => !v.answered);
    if (unanswered.length === 0) return;

    const word = unanswered[Math.floor(Math.random() * unanswered.length)];
    let attempts = 4;

    while (attempts > 0) {
      const answer = prompt(`Translate: ${word.german}`);
      if (answer === word.latin) {
        word.answered = true;
        alert("Correct!");
        return;
      }
      attempts--;
      alert(`Wrong! ${attempts} attempts left`);
    }
  }

  save() {
    const csv = this.vocab.map(v => 
      `"${v.german}","${v.latin}"`
    ).join("\n");
    // Save to localStorage or download as file
  }
}

Comparison: - C64: 1,427 bytes, 23 lines, no dependencies - Modern: ~2,000 bytes, 200+ lines with dependencies, but readable!

Takeaway: Modern code trades bytes for readability. C64 had no choice!

References

Related: - D2G2M Vision - Architecture Overview - Gas Optimization Strategies (Coming soon)