Populaire onderwerpen
#
Bonk Eco continues to show strength amid $USELESS rally
#
Pump.fun to raise $1B token sale, traders speculating on airdrop
#
Boop.Fun leading the way with a new launchpad on Solana.

Jeffrey Emanuel
Voormalig Quant Investor, nu bezig met het bouwen @lumera (voorheen Pastel Network genoemd) | Mijn open source projecten: https://t.co/9qbOCDlaqM
Agent Coding Lifehack
Ik voel me een beetje schuldig om deze te gebruiken, maar wat maakt het uit.
Wanneer ik de agents vraag om een enorme vergelijkings-/herzieningslus te doen, wat normaal gesproken voorkomt wanneer ik een enorme markdown-planning heb en ik uitgebreide feedback daarop heb gekregen van GPT Pro in de webapp, en vervolgens GPT Pro verder heb laten zien de feedback van dezelfde prompt die aan Opus4.5, Gemini3 met DeepThink, en Grok4 Heavy is getoond (allemaal met de webapps), zelfs Codex met GPT 5.2 hoog zal een hoop dingen missen de eerste keer dat het probeert alle herzieningen te integreren.
Als je het vertelt om "alle" problemen te vinden, omdat het niet weet hoeveel het heeft gemist, gaat het meestal gewoon door totdat het er veel heeft gevonden. Als je het vertelt om door te gaan totdat het er minstens 20 heeft gevonden, komt het meestal terug nadat het 23 problemen/verschillen heeft gevonden.
Dit gaat er natuurlijk vanuit dat er PROBLEMEN zijn, maar die zijn er basically altijd wanneer de plannen 5k+ regels zijn en de herzieningen meer dan 2k+ regels zijn.
Hoe dan ook, de oplossing is om tegen hen te liegen en ze een enorm aantal te geven, en dan blijven ze doorgaan totdat ze ze allemaal hebben ontdekt:
"Doe dit opnieuw, en wees echt super super voorzichtig: kun je alsjeblieft het plan opnieuw controleren en het vergelijken met al die feedback die ik je heb gegeven? Ik ben er zeker van dat je minstens 80 elementen van die complexe feedback hebt gemist of verknald."

133
Ik heb de miniatuurversie van deze prompt hier opgenomen omdat de serie "Mijn Favoriete Prompts" compact, hapklare, zelfvoorzienende stukjes moet zijn.
Maar vandaag heb ik dit omgevormd tot een werkelijk krankzinnig systeem. Het doet er niet toe of je een andere CRUD-programma in React of een TODO-lijst maakt, maar als je iets behoorlijk ingewikkelds doet in Rust of Golang, of iets dat complexe gegevens omvat, dan is deze aanpak bijna eng in wat het kan doen.
Het is een proces van 2 rondes. Hier is Ronde 1:
---
Lees eerst ALLE AGENTS dot md-bestand en README dot md-bestand super zorgvuldig en begrijp ALLES van beide! Gebruik vervolgens je code-onderzoeksagentmodus om de code, de technische architectuur en het doel van het project volledig te begrijpen.
Dan, zodra je een extreem grondige en nauwkeurige klus hebt geklaard en de hele bestaande systeem en wat het doet, zijn doel, en hoe het is geïmplementeerd en hoe alle onderdelen met elkaar verbonden zijn, diep hebt begrepen, moet je hyper-intensief onderzoeken en studeren en nadenken over deze vragen zoals ze betrekking hebben op dit project:
Zijn er andere grote inefficiënties in het kernsysteem? Plaatsen in de codebasis waar 1) wijzigingen daadwerkelijk het verschil zouden maken in termen van algehele latentie/responsiviteit en doorvoer; 2) zodanig dat onze wijzigingen aantoonbaar isomorf zijn in termen van functionaliteit zodat we zeker weten dat het de resulterende outputs niet zou veranderen gegeven dezelfde inputs; 3) waar je een duidelijke visie hebt op een obviously betere aanpak in termen van algoritmen of datastructuren (let op dat je voor dit, in je overpeinzingen, minder bekende datastructuren en meer esoterische/sophisticated/wiskundige algoritmen kunt opnemen, evenals manieren om de probleem(en) opnieuw te formuleren zodat een ander paradigma wordt blootgelegd, zoals de lijst hieronder (Opmerking: Voordat je enige optimalisatie voorstelt, stel baseline-metrics vast (p50/p95/p99 latentie, doorvoer, piekgeheugen) en leg CPU/allocation/I/O-profielen vast om daadwerkelijke hotspots te identificeren):
- N+1 query/fetch patroon eliminatie
- zero-copy / buffer hergebruik / scatter-gather I/O
- serialisatieformaatkosten (parse/encode overhead)
- begrensde wachtrijen + terugdruk (voorkom geheugenexplosie en tail latentie)
- sharding / gestreepte sloten om concurrentie te verminderen
- memoization met cache-invalideringsstrategieën
- dynamische programmeertechnieken
- convexe optimalisatietheorie
- luie evaluatie / uitgestelde berekening
- iterator/generator patronen om grote collecties te vermijden
- streaming/chunked verwerking voor geheugenbeperkt werk
- voorcalculatie en opzoektabellen
- index-gebaseerde opzoeking vs lineaire scanherkenning
- binaire zoekopdracht (op gegevens en op antwoordruimte)
- twee-pointer en sliding window technieken
- prefix sommen / cumulatieve aggregaten
- topologische sortering en DAG-bewustzijn voor afhankelijkheidsgrafieken
- cyclusdetectie
- unie-vinden voor dynamische connectiviteit
- graf traverseren (BFS/DFS) met vroege beëindiging
- Dijkstra's / A* voor gewogen kortste paden
- prioriteitswachtrijen / heaps
- tries voor prefixbewerkingen
- bloomfilters voor probabilistische lidmaatschap
- interval/segmentbomen voor bereikqueries
- ruimtelijke indexering (k-d bomen, quadtrees, R-bomen)
- persistente/onveranderlijke datastructuren
- copy-on-write semantiek
- object/verbinding pooling
- cache-evictiebeleid selectie (LRU/LFU/ARC)
- batch-bewuste algoritme selectie
- async I/O batching en coalescing
- lock-vrije structuren voor hoge concurrentiescenario's
- werk-stelen voor recursieve parallelisme
- geheugenlay-out optimalisatie (SoA vs AoS, cache-lokalisatie)
- short-circuiting en vroege beëindiging
- string interning voor herhaalde waarden
- geamortiseerde analyse redenering
taking in overweging deze algemene richtlijnen waar van toepassing:
DP TOEPASBAARHEID CONTROLES:
- Overlappende subproblemen? → memoize met stabiele staat sleutel
- Optimale partitionering/batching? → prefix sommen + interval DP
- Afhankelijkheidsgrafiek met herhaalde traversie? → single-pass topologische DP
CONVEX OPTIMISATIE CONTROLES:
- Brute-forcing exacte allocatie/planning? → LP / min-kostenstroom met deterministische tie-breaking
- Continue parameter fitting met expliciete verlies? → geregulariseerde kleinste kwadraten / QP
- Grote decomposable convexe doelstelling? → ADMM / proximale methoden
Let ook op dat als er goed geschreven derde partij bibliotheken zijn waarvan je weet dat ze goed zouden werken, we ze in het project kunnen opnemen).
METHODOLOGIE EISEN:
A) Baseline eerst: Voer de test suite en een representatieve werklast uit; registreer p50/p95/p99 latentie, doorvoer en piekgeheugen met exacte commando's.
B) Profiel voordat je voorstelt: Leg CPU + allocatie + I/O-profielen vast; identificeer de top 3–5 hotspots op % tijd voordat je wijzigingen voorstelt.
C) Equivalentie-orakel: Definieer expliciete gouden outputs + invarianten. Voor grote invoerruimten, voeg eigenschap-gebaseerde of metamorfische tests toe.
D) Isomorfisme bewijs per wijziging: Elke voorgestelde diff moet een korte bewijs schets bevatten die uitlegt waarom outputs niet kunnen veranderen (inclusief ordening, tie-breaking, floating-point gedrag, en RNG zaden).
E) Kansenmatrix: Rangschik kandidaten op (Impact × Vertrouwen) / Inspanning voordat je implementeert; focus alleen op items die waarschijnlijk p95+ of doorvoer betekenisvol zullen verplaatsen.
F) Minimale diffs: Eén prestatie hefboom per wijziging. Geen niet-gerelateerde refactors. Voeg rollback-instructies toe als er enig risico bestaat.
G) Regresie-guardrails: Voeg benchmarkdrempels of monitoring hooks toe om toekomstige regressies te voorkomen.
Gebruik ultrathink.
---
Je kunt dat eenmaal uitvoeren in Claude Code met Opus 4.5 en eenmaal in Codex met GPT 5.2 Codex (ik begon alleen met Hoog omdat Extra Hoog gewoon te langzaam voor me is, tenzij ik op het punt sta naar bed te gaan).
Nadat ze klaar zijn, geef ze elk ongeveer 5 snelle rondes van dit:
"Geweldig. Kijk alles nog eens goed na op voor eventuele duidelijke overzichten of omissies of fouten, conceptuele fouten, blunders, enz. Gebruik ultrathink"
Laat ze dan de outputs opslaan zoals dit:
"OK, sla dat allemaal op als PLAN_FOR_ADVANCED_OPTIMIZATIONS_ROUND_1__OPUS.md"
"OK, sla dat allemaal op als PLAN_FOR_ADVANCED_OPTIMIZATIONS_ROUND_1__GPT.md"
Dan in Claude Code, doe:
"Vergelijk wat je deed met PLAN_FOR_ADVANCED_OPTIMIZATIONS_ROUND_1__GPT.md en neem de beste elementen daarvan en verwerk ze in je plan om een hybride beste van beide werelden superieur plan te krijgen door je oorspronkelijke planbestand ter plaatse te bewerken."
Dan dit:
Herlees AGENTS dot md zodat het nog vers in je geheugen zit. Lees nu ALLES van PLAN_FOR_ADVANCED_OPTIMIZATIONS_ROUND_1__OPUS.md. Controleer dan elke bead super zorgvuldig-- ben je zeker dat het logisch is? Is het optimaal? Kunnen we iets veranderen om het systeem beter te laten werken voor gebruikers? We willen een uitgebreide en gedetailleerde set beads voor dit alles met taken, subtaken, en afhankelijkheidsstructuur overlaid, met gedetailleerde opmerkingen zodat het geheel volledig zelfvoorzienend en zelfdocumenterend is (inclusief relevante achtergrond, redenering/rechtvaardiging, overwegingen, enz.-- alles wat we onze "toekomstige zelf" willen laten weten over de doelen en intenties en het denkproces en hoe het de overkoepelende doelen van het project dient.). De beads moeten zo gedetailleerd zijn dat we nooit meer terug hoeven te verwijzen naar het oorspronkelijke markdown plan document. Reflecteert het nauwkeurig ALLES van het markdown planbestand op een uitgebreide manier? Als wijzigingen gerechtvaardigd zijn, herzie dan de beads of maak nieuwe of sluit ongeldige of niet-toepasbare. Het is veel gemakkelijker en sneller om in "planruimte" te opereren voordat we deze dingen gaan implementeren! OVERSIMPLIFICEER DE DINGEN NIET! VERLIES GEEN ENKELE FUNCTIE OF FUNCTIONALITEIT! Zorg er ook voor dat we als onderdeel van deze beads, uitgebreide eenheidstests en e2e-testscripts met geweldige, gedetailleerde logging opnemen zodat we zeker kunnen zijn dat alles perfect werkt na implementatie. Vergeet niet om ALLEEN de `bd` tool te gebruiken om de beads te maken en te wijzigen en om de afhankelijkheden aan beads toe te voegen."
Dan een paar rondes van:
"Controleer elke bead super zorgvuldig-- ben je zeker dat het logisch is? Is het optimaal? Kunnen we iets veranderen om het systeem beter te laten werken voor gebruikers? Als dat zo is, herzie de beads. Het is veel gemakkelijker en sneller om in "planruimte" te opereren voordat we deze dingen gaan implementeren! OVERSIMPLIFICEER DE DINGEN NIET! VERLIES GEEN ENKELE FUNCTIE OF FUNCTIONALITEIT! Zorg er ook voor dat we als onderdeel van de beads, uitgebreide eenheidstests en e2e-testscripts met geweldige, gedetailleerde logging opnemen zodat we zeker kunnen zijn dat alles perfect werkt na implementatie. Gebruik ultrathink."
Laat dan de zwerm los om het allemaal te implementeren. Maak je dan klaar voor RONDE 2.

Jeffrey Emanuel17 uur geleden
"Mijn Favoriete Prompts," door Jeffrey Emanuel
Prompt 4: De Grote Brein-Optimizer
"Lees eerst ALLE AGENTS dot md-bestanden en README dot md-bestanden super zorgvuldig en begrijp ALLES van beide! Gebruik vervolgens je code-onderzoeksagentmodus om de code, de technische architectuur en het doel van het project volledig te begrijpen.
Als je dan een extreem grondige en nauwkeurige klus hebt geklaard en het hele bestaande systeem en wat het doet, zijn doel en hoe het is geïmplementeerd en hoe alle onderdelen met elkaar verbonden zijn, diep hebt begrepen, heb ik je nodig om hyper-intensief deze vragen te onderzoeken, bestuderen en overpeinzen zoals ze betrekking hebben op dit project:
Zijn er andere grote inefficiënties in het kernsysteem? Plaatsen in de codebase waar:
1) wijzigingen daadwerkelijk het verschil zouden maken in termen van algehele latentie/reactietijd en doorvoer;
2) en waar onze wijzigingen aantoonbaar isomorf zijn in termen van functionaliteit, zodat we zeker weten dat het de resulterende outputs niet zou veranderen gegeven dezelfde inputs (voor benaderende numerieke methoden kun je "dezelfde" interpreteren als "binnen epsilon afstand";
3) waar je een duidelijke visie hebt op een obviously betere aanpak in termen van algoritmen of datastructuren (let op dat je voor dit punt ook minder bekende datastructuren en meer esoterische/sophisticated/wiskundige algoritmen kunt opnemen, evenals manieren om de probleem(en) opnieuw te formuleren zodat een ander paradigma wordt blootgelegd, zoals convex optimalisatietheorie of technieken voor dynamisch programmeren.
Let ook op dat als er goed geschreven derde-partij bibliotheken zijn waarvan je weet dat ze goed zouden werken, we ze in het project kunnen opnemen). Gebruik ultrathink.
8,64K
OK, hier is Ronde 2 van de Super Big Brained Optimizer Prompt.
Deze post kan gelukkig veel korter zijn dan de geciteerde post, omdat de hele workflow na de initiële prompt identiek is aan Ronde 1, gewoon "1" vervangen door "2" in de bestandsnamen.
Hier is de prompt:
---
Lees ALLEN van de AGENTS md-bestand en README md-bestand super zorgvuldig en begrijp ALLES van beide! Gebruik vervolgens je code-onderzoeksagentmodus om de code, de technische architectuur en het doel van het project volledig te begrijpen.
Wanneer je een extreem grondige en nauwkeurige klus hebt geklaard en de hele bestaande systeem en wat het doet, zijn doel, en hoe het is geïmplementeerd en hoe alle onderdelen met elkaar verbonden zijn, heb ik je nodig om hyper-intensief te onderzoeken en te studeren en te overpeinzen over deze vragen zoals ze betrekking hebben op dit project:
Zijn er andere grove inefficiënties in het kernsysteem? Plaatsen in de codebasis waar 1) wijzigingen daadwerkelijk het verschil zouden maken in termen van algehele latentie/responsiviteit en doorvoer; 2) zodanig dat onze wijzigingen aantoonbaar isomorf zijn in termen van functionaliteit, zodat we zeker weten dat het de resulterende outputs niet zou veranderen gegeven dezelfde inputs; 3) waar je een duidelijke visie hebt op een obviously betere aanpak in termen van algoritmen of datastructuren (let op dat je voor dit, je in je overpeinzingen minder bekende datastructuren en meer esoterische/sophisticated/wiskundige algoritmen kunt opnemen, evenals manieren om de probleem(en) opnieuw te formuleren zodat een ander paradigma wordt blootgelegd, zoals de lijst hieronder (Opmerking: Voordat je enige optimalisatie voorstelt, stel baseline-metrics vast (p50/p95/p99 latentie, doorvoer, piekgeheugen) en leg CPU/allocation/I/O-profielen vast om daadwerkelijke hotspots te identificeren):
- convex optimalisatie (herformulering levert globale optimum garanties)
- submodulaire optimalisatie (greedy geeft constante-factor benadering)
- semiring generalisatie (vereenvoudigt kortste pad, transitieve sluiting, dataflow, parsing)
- matroidstructuurherkenning (greedy is aantoonbaar optimaal)
- lineaire algebra over GF(2) (XOR-systemen, toggle-problemen, foutcorrectie)
- reductie naar 2-SAT (configuratievaliditeit, implicatiegrafen)
- reductie naar min-kosten max-flow (toewijzing, planning, hulpbronnenallocatie)
- bipartiete matchingherkenning (Hongaarse, Hopcroft-Karp)
- DP als kortste pad in impliciete DAG (maakt prioriteitswachtrij DP, Dijkstra-stijl optimalisatie mogelijk)
- convex hull trick / Li Chao-bomen (O(n²) DP → O(n log n))
- Knuth's optimalisatie / divide-and-conquer DP
- Hirschberg's ruimte-reductie (wanneer van toepassing buiten uitlijning)
- FFT/NTT voor convolutie (polynoomvermenigvuldiging, sequentiecorrelatie)
- matrix-exponentiatie voor lineaire recursies
- Möbius-transformatie / subset-convolutie
- persistente/onveranderlijke datastructuren (versiebeheer, terugrol, speculatieve uitvoering)
- suffixautomaat / suffixarray met LCP
- heavy-light decompositie / centroiddecompositie
- link-cut bomen (dynamische boomverbinding)
- monotone wachtrij/deque voor sliding window-extrema
- segmentbomen met luie propagatie
- wavelet-bomen (rang/selectie/kwantiel)
- union-find met terugrol
- Count-Min sketch, HyperLogLog (streaming/sublineair)
- locality-sensitive hashing (benaderende NN)
- bloomfilters / cuckoo-filters
- minimale perfecte hashing
- fractionele cascadering
- Mo's algoritme (offline query sqrt decompositie)
- parametric search / binaire zoekopdracht op antwoord
- bidirectionele zoekopdracht / meet-in-the-middle
- gerandomiseerde algoritmen met rigoureuze verwachte grenzen
- benaderingsalgoritmen met aantoonbare garanties
- work-stealing voor recursieve parallelisme
- lock-free / wait-free datastructuren
- cache-oblivious algoritmeontwerp
- geamortiseerde analyse (om te herkennen wanneer "dure" operaties eigenlijk goedkoop zijn)
Let ook op dat als er goed geschreven derde partij bibliotheken zijn waarvan je weet dat ze goed zouden werken, we ze in het project kunnen opnemen).
METHODOLOGIEVEREISTEN:
A) Baseline eerst: Voer de test suite en een representatieve werklast uit; registreer p50/p95/p99 latentie, doorvoer en piekgeheugen met exacte commando's.
B) Profiel voordat je voorstelt: Leg CPU + allocatie + I/O-profielen vast; identificeer de top 3–5 hotspots op % tijd voordat je wijzigingen voorstelt.
C) Equivalentie-orakel: Definieer expliciete gouden outputs + invarianties. Voor grote invoerruimten, voeg eigenschap-gebaseerde of metamorfische tests toe.
D) Isomorfisme bewijs per wijziging: Elke voorgestelde diff moet een korte bewijs schets bevatten die uitlegt waarom outputs niet kunnen veranderen (inclusief ordening, tie-breaking, floating-point gedrag, en RNG zaden).
E) Kansenmatrix: Rangschik kandidaten op (Impact × Vertrouwen) / Inspanning voordat je implementeert; focus alleen op items die waarschijnlijk p95+ of doorvoer betekenisvol zullen verplaatsen.
F) Minimale diffs: Eén prestatieheffer per wijziging. Geen niet-gerelateerde refactors. Voeg terugrolrichtlijnen toe als er enig risico bestaat.
G) Regressie-guardrails: Voeg benchmarkdrempels of monitoring-haken toe om toekomstige regressies te voorkomen.
Gebruik ultrathink.
---
Nu weet ik wat je denkt... wtf is dat allemaal? Daarom heet het de Big Brained Optimizer prompt, ok?
De frontier-modellen zijn zo slim dat als je ze dingen laat ontwerpen, en meer basisversies van de optimalisatieprompt doet (de korte die ik gaf als Prompt 4 in de "Mijn Favoriete Prompts" serie), weten ze hoe ze al het standaard leetcode interview spul moeten doen en zullen ze het gebruiken.
Maar wat is dat volgende niveau, Terry Tao spul? Je weet wat ik bedoel, de GOEDE SPUL. Nou, dat weten ze ook.
En gaat het relevant zijn voor jouw probleem? Eerlijk gezegd, waarschijnlijk niet. Maar als dat zo is, is dat hoe je de WARE TURBO MODE ontgrendelt.
Voer altijd Ronde 1 uit voordat je Ronde 2 uitvoert, aangezien het 99% van de tijd veel relevanter zal zijn. Maar nadat je Ronde 1 een paar keer hebt gedaan en er niets verandert, kun je Ronde 2 bereiken.
Hoe dan ook, zorg ervoor dat nadat je al deze dingen hebt gedaan, de plannen voor CC en Codex genereert, CC het beste van beide werelden plan combineert, het vijf keer controleert op blunders, het uiteindelijke markdown-plan in kralen omzet, de kralen iteratief optimaliseert, en uiteindelijk de kralen implementeert met een zwerm van CC en Codex-bots met een hoop eenheidstests en e2e integratietests... start een Codex-sessie met GPT 5.2 Extra Hoog en queue ongeveer 20 van deze suckers:
"Ik wil dat je een beetje willekeurig de codebestanden in dit project verkent, codebestanden kiest om diepgaand te onderzoeken en te begrijpen en hun functionaliteit en uitvoeringsstromen door de gerelateerde codebestanden die ze importeren of die door hen worden geïmporteerd te traceren. Zodra je het doel van de code in de grotere context van de workflows begrijpt, wil ik dat je een super zorgvuldige, methodische en kritische controle uitvoert met "verse ogen" om eventuele voor de hand liggende bugs, problemen, fouten, kwesties, domme fouten, enz. te vinden en deze systematisch en nauwgezet en intelligent corrigeert."
-FIN-


Jeffrey Emanuel17 uur geleden
Ik heb de miniatuurversie van deze prompt hier opgenomen omdat de serie "Mijn Favoriete Prompts" compact, hapklare, zelfvoorzienende stukjes zou moeten zijn.
Maar vandaag heb ik dit omgevormd tot een werkelijk krankzinnig systeem. Het is niet relevant of je een andere CRUD-programma in React of een TODO-lijst maakt, maar als je iets behoorlijk ingewikkelds doet in Rust of Golang, of iets dat met complexe gegevens te maken heeft, is deze aanpak bijna eng in wat het kan doen.
Het is een proces van 2 rondes. Hier is Ronde 1:
---
Lees ALLEN van de AGENTS dot md-bestand en README dot md-bestand super zorgvuldig en begrijp ALLES van beide! Gebruik vervolgens je code-onderzoeksagentmodus om de code, de technische architectuur en het doel van het project volledig te begrijpen.
Dan, zodra je een extreem grondige en nauwkeurige klus hebt geklaard en de hele bestaande systeem en wat het doet, zijn doel, en hoe het is geïmplementeerd en hoe alle onderdelen met elkaar verbonden zijn, diep hebt begrepen, moet je hyper-intensief onderzoeken en studeren en nadenken over deze vragen zoals ze betrekking hebben op dit project:
Zijn er andere grote inefficiënties in het kernsysteem? Plaatsen in de codebasis waar 1) wijzigingen daadwerkelijk het verschil zouden maken in termen van algehele latentie/responsiviteit en doorvoer; 2) zodanig dat onze wijzigingen aantoonbaar isomorf zijn in termen van functionaliteit zodat we zeker weten dat het de resulterende outputs niet zou veranderen gegeven dezelfde inputs; 3) waar je een duidelijke visie hebt op een obviously betere aanpak in termen van algoritmen of datastructuren (let op dat je voor dit, in je overpeinzingen minder bekende datastructuren en meer esoterische/sophisticated/wiskundige algoritmen kunt opnemen, evenals manieren om de probleem(en) opnieuw te formuleren zodat een ander paradigma wordt blootgelegd, zoals de lijst hieronder (Opmerking: Voordat je enige optimalisatie voorstelt, stel baseline-metrics vast (p50/p95/p99 latentie, doorvoer, piekgeheugen) en leg CPU/allocation/I/O-profielen vast om daadwerkelijke hotspots te identificeren):
- N+1 query/fetch patroon eliminatie
- zero-copy / buffer hergebruik / scatter-gather I/O
- serialisatieformaatkosten (parse/encode overhead)
- begrensde wachtrijen + terugdruk (voorkom geheugenopblazen en tail latentie)
- sharding / gestreepte sloten om contentie te verminderen
- memoization met cache-invalideringsstrategieën
- dynamische programmeertechnieken
- convexe optimalisatietheorie
- luie evaluatie / uitgestelde berekening
- iterator/generator patronen om grote verzamelingen te vermijden
- streaming/chunked verwerking voor geheugenbeperkt werk
- voorcalculatie en opzoektabellen
- index-gebaseerde opzoeking vs lineaire scanherkenning
- binaire zoekopdracht (op gegevens en op antwoordruimte)
- twee-pointer en sliding window technieken
- prefix sommen / cumulatieve aggregaten
- topologische sortering en DAG-bewustzijn voor afhankelijkheidsgrafieken
- cyclusdetectie
- unie-vinden voor dynamische connectiviteit
- graf traverseren (BFS/DFS) met vroege beëindiging
- Dijkstra's / A* voor gewogen kortste paden
- prioriteitswachtrijen / heaps
- tries voor prefixbewerkingen
- bloomfilters voor probabilistische lidmaatschap
- interval/segmentbomen voor bereikopvragingen
- ruimtelijke indexering (k-d bomen, quadtrees, R-bomen)
- persistente/onveranderlijke datastructuren
- copy-on-write semantiek
- object/verbinding pooling
- cache-evictiebeleidselectie (LRU/LFU/ARC)
- batch-bewuste algoritme-selectie
- async I/O batching en coalescing
- lock-vrije structuren voor hoge-contentie scenario's
- werk-stelen voor recursieve parallelisme
- geheugenlay-out optimalisatie (SoA vs AoS, cache-lokalisatie)
- short-circuiting en vroege beëindiging
- string interning voor herhaalde waarden
- geamortiseerde analyse redenering
taking into consideration these general guides where applicable:
DP TOEPASBAARHEID CONTROLES:
- Overlappende subproblemen? → memoize met stabiele staat sleutel
- Optimale partitionering/batching? → prefix sommen + interval DP
- Afhankelijkheidsgrafiek met herhaalde traversie? → single-pass topologische DP
CONVEXE OPTIMALISATIE CONTROLES:
- Brute-forcing exacte allocatie/planning? → LP / min-kostenstroom met deterministische tie-breaking
- Continue parameter fitting met expliciete verlies? → geregulariseerde kleinste kwadraten / QP
- Grote decomposable convexe doelstelling? → ADMM / proximale methoden
Let ook op dat als er goed geschreven derde partij bibliotheken zijn waarvan je weet dat ze goed zouden werken, we ze in het project kunnen opnemen).
METHODOLOGIE EISEN:
A) Baseline eerst: Voer de test suite en een representatieve werklast uit; registreer p50/p95/p99 latentie, doorvoer en piekgeheugen met exacte commando's.
B) Profiel voordat je voorstelt: Leg CPU + allocatie + I/O-profielen vast; identificeer de top 3–5 hotspots op % tijd voordat je wijzigingen voorstelt.
C) Equivalentie-orakel: Definieer expliciete gouden outputs + invarianten. Voor grote invoerruimten, voeg eigenschap-gebaseerde of metamorfische tests toe.
D) Isomorfisme bewijs per wijziging: Elke voorgestelde diff moet een korte bewijs schets bevatten die uitlegt waarom outputs niet kunnen veranderen (inclusief ordening, tie-breaking, floating-point gedrag, en RNG zaden).
E) Kansenmatrix: Rangschik kandidaten op (Impact × Vertrouwen) / Inspanning voordat je implementeert; focus alleen op items die waarschijnlijk p95+ of doorvoer betekenisvol zullen verplaatsen.
F) Minimale diffs: Eén prestatie hefboom per wijziging. Geen niet-gerelateerde refactors. Voeg rollback begeleiding toe als er enig risico bestaat.
G) Regresie guardrails: Voeg benchmarkdrempels of monitoring hooks toe om toekomstige regressies te voorkomen.
Gebruik ultrathink.
---
Je kunt dat eenmaal uitvoeren in Claude Code met Opus 4.5 en eenmaal in Codex met GPT 5.2 Codex (ik begon alleen met Hoog omdat Extra Hoog gewoon te langzaam voor me is, tenzij ik op het punt sta naar bed te gaan).
Nadat ze klaar zijn, geef ze elk ongeveer 5 snelle rondes van dit:
"Geweldig. Kijk alles nog eens goed na op voor eventuele voor de hand liggende over het hoofd geziene zaken of omissies of fouten, conceptuele fouten, blunders, enz. Gebruik ultrathink"
Laat ze dan de outputs opslaan zoals dit:
"OK, sla dat allemaal op als PLAN_FOR_ADVANCED_OPTIMIZATIONS_ROUND_1__OPUS.md"
"OK, sla dat allemaal op als PLAN_FOR_ADVANCED_OPTIMIZATIONS_ROUND_1__GPT.md"
Dan in Claude Code, doe:
"Vergelijk wat je deed met PLAN_FOR_ADVANCED_OPTIMIZATIONS_ROUND_1__GPT.md en neem de beste elementen daarvan en verwerk ze in je plan om een hybride beste van beide werelden superieur plan te krijgen door je oorspronkelijke planbestand ter plaatse te bewerken."
Dan dit:
Herlees AGENTS dot md zodat het nog vers in je geheugen zit. Lees nu ALLES van PLAN_FOR_ADVANCED_OPTIMIZATIONS_ROUND_1__OPUS.md. Controleer dan elke bead super zorgvuldig-- ben je zeker dat het logisch is? Is het optimaal? Kunnen we iets veranderen om het systeem beter te laten werken voor gebruikers? We willen een uitgebreide en gedetailleerde set beads voor dit alles met taken, subtaken, en afhankelijkheidsstructuur overlaid, met gedetailleerde opmerkingen zodat het geheel volledig zelfvoorzienend en zelfdocumenterend is (inclusief relevante achtergrond, redenering/rechtvaardiging, overwegingen, enz.-- alles wat we onze "toekomstige zelf" willen laten weten over de doelen en intenties en het denkproces en hoe het de overkoepelende doelen van het project dient.). De beads moeten zo gedetailleerd zijn dat we nooit meer terug hoeven te raadplegen naar het oorspronkelijke markdown plan document. Reflecteert het nauwkeurig ALLES van het markdown planbestand op een uitgebreide manier? Als wijzigingen gerechtvaardigd zijn, herzie dan de beads of maak nieuwe of sluit ongeldige of niet-toepasbare. Het is veel gemakkelijker en sneller om in "plannenruimte" te opereren voordat we deze dingen gaan implementeren! OVERSIMPLIFICE DINGEN NIET! VERLOREN GEEN FUNCTIES OF FUNCTIONALITEIT! Zorg er ook voor dat we als onderdeel van deze beads, uitgebreide eenheidstests en e2e test scripts met geweldige, gedetailleerde logging opnemen zodat we zeker kunnen zijn dat alles perfect werkt na implementatie. Vergeet niet om ALLEEN de `bd` tool te gebruiken om de beads te maken en te wijzigen en om de afhankelijkheden aan beads toe te voegen."
Dan een paar rondes van:
"Controleer elke bead super zorgvuldig-- ben je zeker dat het logisch is? Is het optimaal? Kunnen we iets veranderen om het systeem beter te laten werken voor gebruikers? Zo ja, herzie de beads. Het is veel gemakkelijker en sneller om in "plannenruimte" te opereren voordat we deze dingen gaan implementeren! OVERSIMPLIFICE DINGEN NIET! VERLOREN GEEN FUNCTIES OF FUNCTIONALITEIT! Zorg er ook voor dat we als onderdeel van de beads, uitgebreide eenheidstests en e2e test scripts met geweldige, gedetailleerde logging opnemen zodat we zeker kunnen zijn dat alles perfect werkt na implementatie. Gebruik ultrathink."
Laat dan de zwerm los om het allemaal te implementeren. Maak je dan klaar voor RONDE 2.
3
Boven
Positie
Favorieten