Im Bereich Coding spielt für mich GPT-5.2 aktuell ganz oben mit und übertrifft sogar das bisher beste Modell, Gemini 3.
Was wir aktuell beobachten, ist ein enorm intensiver Wettbewerb zwischen den großen Playern im Bereich Künstliche Intelligenz.
Insbesondere Google, das offensichtlich über schnellere Hardware verfügt, und OpenAI, das weiterhin starke Innovationen liefert, ringen um die Marktführerschaft.
Zmindest OpenAI konzentriert sich mittlerweile gezielt auf ihr Kerngeschäft, um an der Spitze zu bleiben.
Mit der Veröffentlichung von GPT-5.2 und den Gerüchten um Gemini 3.5 zeigt sich, dass niemand zurückstecken möchte.
Am Ende setzen alle Kunden auf das leistungsfähigste Modell, weil es weniger Fehler produziert, was enorm viel Zeit spart.
Gleichzeitig besteht die Gefahr einer KI-Blase, ähnlich der Dotcom-Blase, da derzeit enorme Investitionen getätigt werden, wobei die Einnahmen möglicherweise (noch) nicht mithalten. Für uns Verbraucher ist der Wettbewerb aber vorteilhaft und sorgt für einen Innovationsschub, den wir uns vor wenigen Jahren nicht hätten vorstellen können.
Zurück zur Technik.
Ein Beispiel – ich habe ein SPR-Skript geschrieben, das den Namen einer Funktion oder Prozedur annimmt, den Quelltext dieser Prozedur findet und in die Zwischenablage kopiert, damit ich diesen z.B. einer KI als Kontext geben kann.
Das Skript sollte auch bei mehreren Prozedurnamen, getrennt durch Kommas, jeweils alle Prozeduren in die Zwischenablage kopieren.
Ein einfaches SPR-Skript – aber ein kleiner Fehler hatte sich eingeschlichen.Normalerweise würde man denken, die KI kann da nicht helfen, weil man ihr erst die Befehle des Smart Package Robot erklären müsste.
Aber von wegen:
Ich habe einfach nur das Skript ohne jede Erklärung gepostet und gefragt: „Was macht das?“.
GPT-5.2 hat es perfekt erkannt, die Fehler gefunden und sofort eine lauffähige, korrigierte Version geliefert! Einfach beeindruckend!
Das durchbricht für mich die Coding-Schallmauer!
Früher waren AI-generierte Codes meist fehlerhaft und erforderten viel Nacharbeit.
Aber jetzt – von 10 Generierungen sind ca. 7 direkt fehlerfrei!
Der Rest benötigt meist nur kleine Korrekturen. Das ist eine enorme Verbesserung gegenüber früheren Modellen.
Ein weiteres großes Plus:
Der Kontext ist jetzt richtig umfangreich – vielleicht noch nicht ganz auf Google-Niveau, aber schon richtig gut nutzbar fürs Coding.
Einziger Nachteil, den ich nicht verschweigen will:
Es gibt (anders als bei Google) ein Limit für Dateianhänge.
Zieht man zu viele Dateien rein, muss man bis zu einer Stunde warten, bevor man weitere hinzufügen kann. Das trifft vor allem Nutzer der normalen Plus-Variante.
Fazit: GPT-5.2 kann ich fürs Coding absolut empfehlen!
#GPT52 #Coding #AI #KI #SmartPackageRobot #Gemini3 #Tech #Innovation #Produktivität #SPR #Programmieren #AIRevolution #Fehlerfrei #Automatisierung
Wer es selbst mal ausprobieren will hier ist das script.
Und man kann noch weitergehen:
Man könnte dieses Skript sogar der KI geben und sagen: „Mach daraus ein Skript, das etwas völlig anderes macht.“
Die KI würde dann auf Basis der erkannten Befehle ein komplett neues Skript erstellen, das etwas ganz anderes tut.
Code: Select all
Explain me what this script is doing:
'-----------------------------------------------------------
:doButton13
$$FOL=C:\Pdada\
GUT.Enter Function Name|Function Finder JSON||$$FIT
PRT.Searching $$FIT
GSB.FindAndReturn
RET.
'-----------------------------------------------------------
:doButton14
$$FOL=X:\00_MR\
GUT.Enter Function Name|Function Finder SPR||$$FIT
PRT.Searching $$FIT
GSB.FindAndReturn
RET.
'-----------------------------------------------------------
:DoCheck
IVC.$$FIN=$$BAC|e
GTO.Jmpover
ELS.
IVC.$$FIN=$$BAD|e
GTO.Jmpover
EIF.
EIF.
' Datei einlesen
CFF.$$FIN|$$TMP
VBT.$$TMP
LEN.$$TMP|$$LEA
LEN.$$FIS|$$LEB
JIV.$$LEA<$$LEB|Jmpover
NVC.$$TMP=$$FIS|e
GTO.Jmpover
EIF.
GSB.Remove_Commentlines
$$FUN=FUNCTION $$FIS
$$RES=
IVC.$$CON=$$FUN|e
PRT.Found Start at: $$FIN
BLO.Get First|$$CON|$$FUN|END FUNCTION|$$RES
$$MBT=Found in:$crlf$$$FIN$crlf$
PRT.$$MBT$crlf
CLB.Set Text|$$RES
MSB.100||100
GTO.Jmpover
EIF.
$$FUN=SUB $$FIS
IVC.$$CON=$$FUN|e
BLO.GetFirst|$$CON|$$FUN|END SUB|$$RES
$$MBT=Found in:$crlf$$$FIN$crlf$
PRT.$$MBT$crlf
CLB.Set Text|$$RES
MSB.100||100
GTO.Jmpover
EIF.
:Jmpover
RET.
:Remove_Commentlines
PRT.Checking: $$FIN
TXT.Load Text File|$$FIN|$$FIT
FOR.$$LOS|1|$$FIT
TXT.Get Line Trimmed|$$LOS|$$LIN
JNS.$$LIN|GoOn
GSS.1|1|$$LIN|$$CHR
JIS.$$CHR!$$COS|GoOn
TXT.Set Line To|$$LOS|'-
:GoOn
NEX.
TXT.Get Pure Text|$$CON
RET.
'-----------------------------------------------------------
:AddFile
$$NWL=§§_01
IEF.$$NWL
CFF.$$NWL|$$INP
$$PRO+$crlf$Filename: $$NWL$crlf$
$$PRO+$crlf$$$INP$crlf$
$$PRO+$crlf$
ELS.
PRT.Datei $$NWL existiert nicht?
EIF.
RET.
:enz
END.
'-----------------------------------------------------------
' $$FIS - Name der Function
:FindAndReturn
$$BAC=Backup
$$BAD=unused
GSB.FF_Search
RET.
'-----------------------------------------------------------
:FF_Search
IVC.$$FIT=,
GTO.FF_Koma
ELS.
$$FIS=$$FIT
GTO.FF_Standard
VAV.$$GES=$$GES$crlf$$$RES
EIF.
CLB.Set Text|$$GES
MBX.$$GES
RET.
'-----------------------------------------------------------
:FF_Standard
'FEF.DoCheck|$$FIN|$$FOL|*.inc
FEF.DoCheck|$$FIN|$$FOL|*.inc|(256+1+4)
RET.
'-----------------------------------------------------------
:FF_Koma
VAR.$$GES=
VBT.$$FIT
LEN.$$FIT|$$FIL
JIZ.$$FIL|Kout
PRT.FF_Koma for $$FIT
VBT.$$FIT
VBT.$$FIT|,
STR.Count|$$FIT|,|$$NUM
MBX.NUM:$$NUM
IVV.$$NUM>0
STR.Instr|$$FIT|,|1|$$KOP
GSS.1|($$KOP-1)|$$FIT|$$FIS
STR.Clip Left|$$FIT|$$KOP
MBX.$$FIT//$$FIS
ELS.
VBT.$$FIT
$$FIS=$$FIT
$$FIT=
EIF.
MBX.Search:$$FIS
GSB.FF_SK
VAV.$$GES=$$GES$crlf$$$RES
$$RES=
GTO.FF_Koma
:Kout
RET.
'-----------------------------------------------------------
:FF_SK
PRT.In FF_SK: $$FIS
FEF.DoCheck|$$FIN|$$FOL|*.inc|(256+1+4)
LEN.$$RES|$$LEN
IVV.$$LEN>0
VAV.$$GES=$$GES$crlf$$$RES
EIF.
RET.
Code: Select all
MASTER, das ist ein „Function Finder“-Script, das in einem Ordnerbaum nach PowerBASIC FUNCTION … END FUNCTION bzw. SUB … END SUB sucht, den gefundenen Codeblock extrahiert und in die Zwischenablage + MessageBox ausgibt.
1) Button-Handler: was du startest
:doButton13
Setzt Suchordner:
$$FOL = ...
Fragt dich nach einem Namen (GUT.Enter … ||$$FIT) → landet in $$FIT
Druckt „Searching …“
Ruft GSB.FindAndReturn
=> Sucht im HTP_JSON_Lib.
:doButton14
Setzt Suchordner:
$$FOL = ...
Fragt nach Namen → $$FIT
Ruft GSB.FindAndReturn
=> Sucht im PB_MiniRobot.
2) Einstieg: :FindAndReturn → :FF_Search
:FindAndReturn
Definiert zwei Ordnernamen zum Überspringen:
$$BAC = "Backup"
$$BAD = "unused"
Startet die Suche: GSB.FF_Search
:FF_Search
Prüft, ob dein Input $$FIT Kommas enthält:
Ohne Komma: $$FIS = $$FIT → FF_Standard
Mit Komma: FF_Koma (sucht mehrere Namen nacheinander)
Danach:
CLB.Set Text|$$GES → kopiert Gesamtergebnis in die Zwischenablage
MBX.$$GES → zeigt alles in einer MessageBox
Wichtige Variablen dabei:
$$FIT = Roh-Eingabe (deine Eingabe)
$$FIS = aktuell gesuchter Funktions-/Subname
$$GES = Sammeltext aller Treffer (bei Mehrfachsuche)
3) Datei-Scan: FF_Standard / FF_SK → FEF.DoCheck → DoCheck
:FF_Standard
Ruft: FEF.DoCheck|$$FIN|$$FOL|*.inc|(256+1+4)
Scannt im Ordner $$FOL nach *.inc
Für jede Datei setzt FEF vermutlich $$FIN auf den aktuellen Dateipfad und ruft dein Callback :DoCheck auf.
:FF_SK
Macht dasselbe wie FF_Standard, aber wird pro Eintrag bei Komma-Liste aufgerufen.
Wenn $$RES nicht leer ist, hängt es an $$GES.
4) Pro Datei: :DoCheck (das eigentliche Finden + Extrahieren)
Ablauf pro gefundener *.inc Datei:
Ordner/Dateien überspringen
wenn $$FIN enthält/ist "Backup" → skip
wenn $$FIN enthält/ist "unused" → skip
Datei einlesen
CFF.$$FIN|$$TMP
$$TMP ist danach der Dateiinhalt.
Schnelle Vorfilter
Länge Datei $$LEA vs. Länge Suchstring $$LEB
Wenn Datei kürzer ist als Suchbegriff → skip
Wenn Datei den Suchnamen nicht enthält (NVC.$$TMP=$$FIS|e) → skip
(das ist ein „billiger“ Check, bevor blockweise gesucht wird)
Kommentarzeilen entfernen
GSB.Remove_Commentlines
Ergebnis landet in $$CON (bereinigter Text).
Nach FUNCTION suchen
Baut Suchstart: $$FUN = "FUNCTION " + $$FIS
Wenn $$CON den Start enthält:
BLO.Get First|$$CON|$$FUN|END FUNCTION|$$RES
CLB.Set Text|$$RES → kopiert nur den Codeblock in Clipboard
Meldung „Found in: <Datei>“
Springt raus
Sonst nach SUB suchen
$$FUN = "SUB " + $$FIS
Wenn gefunden:
BLO.GetFirst|$$CON|$$FUN|END SUB|$$RES
Clipboard + Meldung
raus
=> Pro Datei wird der erste passende Block extrahiert.
5) :Remove_Commentlines (wie Kommentare neutralisiert werden)
TXT.Load Text File|$$FIN|$$FIT
→ lädt Datei zeilenweise; $$FIT ist danach offenbar die Zeilenanzahl.
Loop über alle Zeilen:
TXT.Get Line Trimmed → getrimmte Zeile nach $$LIN
wenn leer → weiter
GSS.1|1|$$LIN|$$CHR → erstes Zeichen
wenn erstes Zeichen = $$COS (dein Kommentar-Startzeichen):
TXT.Set Line To|...|' - → ersetzt die ganze Zeile durch '-
TXT.Get Pure Text|$$CON → baut Text wieder zusammen
Ziel: Treffer in Kommentarzeilen verhindern, damit nicht auskommentierter Code als „Fundstelle“ zählt.
6) Mehrfachsuche mit Komma: :FF_Koma
Wenn du z.B. eingibst:
Foo,Bar,Baz
dann:
Zählt Kommas (STR.Count)
Nimmt immer den Teil vor dem ersten Komma als $$FIS
Schneidet den linken Teil aus $$FIT raus (STR.Clip Left)
Sucht (GSB.FF_SK)
Hängt $$RES an $$GES
Wiederholt, bis $$FIT leer ist
Am Ende bekommst du eine Sammel-Ausgabe für alle Namen.
7) :AddFile (Hilfsroutine, hier nicht im Hauptfluss)
Liest eine Datei §§_01 ein, hängt Dateiname + Inhalt an $$PRO.
Wird im gezeigten Suchablauf nicht aufgerufen; ist eher ein „Pack mir Dateiinhalt in einen Report“-Helper.
Kurz gesagt
Du gibst einen Funktionsnamen (oder mehrere, per Komma) ein → Script durchsucht *.inc im gewählten Projektordner → entfernt Kommentarzeilen → findet FUNCTION name oder SUB name → extrahiert den Block bis END FUNCTION/END SUB → kopiert ihn in die Zwischenablage + zeigt Fundort/Ergebnis an.
###########################################################
MASTER, nochmal sauber durchgecheckt: es sind noch ein paar logische Fallen drin (eine davon ist richtig „fies“, weil sie nur bei „nichts gefunden“ oder viel Skip auffällt).
1) Ghost-Treffer im Standardlauf: $$RES wird nicht zuverlässig geleert
In :FF_Standard rufst du nur FEF.DoCheck... auf, aber vorher wird $$RES nicht geleert.
Warum das ein Problem ist:
:DoCheck setzt $$RES= erst nach GSB.Remove_Commentlines.
Wenn eine Datei früh übersprungen wird (Backup/unused, zu kurz, NVC.$$TMP=$$FIS|e), springst du nach Jmpover ohne $$RES zu leeren.
Ergebnis: Wenn vorher mal etwas gefunden wurde, kann $$RES vom alten Lauf stehen bleiben → FF_Search hängt dann ggf. einen alten Block an $$GES, obwohl diesmal nichts gefunden wurde.
✅ Fix (minimal): $$RES= ganz oben in :DoCheck setzen (vor allen early exits):
:DoCheck
$$RES=
IVC.$$FIN=$$BAC|e
GTO.Jmpover
...
Oder zusätzlich/alternativ: in :FF_Standard vor FEF.DoCheck:
:FF_Standard
$$RES=
FEF.DoCheck|$$FIN|$$FOL|*.inc|(256+1+4)
RET.
2) $$GES ist im Standardlauf nicht initialisiert
In FF_Koma machst du VAR.$$GES= – gut.
Im Standardfall (ELS. in FF_Search) aber nicht. Damit kann $$GES alte Inhalte tragen.
✅ Fix: am Anfang von FF_Search immer resetten:
:FF_Search
VAR.$$GES=
$$RES=
IVC.$$FIT=,
GSB.FF_Koma
ELS.
$$FIS=$$FIT
GSB.FF_Standard
VAV.$$GES=$$GES$crlf$$$RES
EIF.
CLB.Set Text|$$GES
MBX.$$GES
RET.
(Und wenn du Fix #1 umgesetzt hast, ist $$RES dort dann auch sicher korrekt.)
3) Inkonsequenter BLO-Befehl: BLO.Get First vs BLO.GetFirst
Du hast:
BLO.Get First|$$CON|$$FUN|END FUNCTION|$$RES
...
BLO.GetFirst|$$CON|$$FUN|END SUB|$$RES
Wenn der Interpreter strikt ist, ist BLO.Get First schlicht ein anderer/ungültiger Befehl → FUNCTION-Extraktion klappt dann nie.
✅ Fix: einheitlich (wahrscheinlich richtig) machen:
BLO.GetFirst|$$CON|$$FUN|END FUNCTION|$$RES
4) Komma-Modus: Tokens werden nicht getrimmt
Wenn der User eingibt: Foo, Bar dann wird $$FIS beim zweiten Token " Bar" (mit Leerzeichen) → keine Treffer.
✅ Fix: direkt nach Token-Extraktion trimmen:
GSS.1|($$KOP-1)|$$FIT|$$FIS
VBT.$$FIS
STR.Clip Left|$$FIT|$$KOP
VBT.$$FIT
Wenn du willst, MASTER, poste ich dir die komplett gepatchten Blöcke (DoCheck, FF_Search, FF_Koma) in einem Stück, so dass du nur Copy/Paste machen musst.