De architectuur van gezond verstand: waarom de radicale eenvoud van Phlo de toekomst van full-stack is

Moderne webontwikkeling is al vijftien jaar verwikkeld in een debat dat ons in een complexiteitsval heeft geleid. We hebben de bewezen stabiliteit van server-side PHP, dat nog steeds stilletjes 70% van het web aandrijft, ingeruild voor een gefragmenteerde wereld van hydratatiemismatches, fragiele build-ketens en afhankelijkheidsbomen die geen enkele architect echt kan auditen. De afstand tussen de lagen van een typische stack is zo groot geworden dat niemand het hele plaatje nog in zijn hoofd heeft.

Phlo is een bewuste afwijking van die norm: een verticaal geïntegreerde stack (taal, applicatieplatform, server en operaties) ontworpen om het eigenaarschap terug te winnen van deze opgeblazen standaarden. Door de afstand tussen frontend en backend te verkleinen tot een enkel mentaal model, biedt het een weg terug naar stabiliteit, voorspelbaarheid en technische controle.

Hier zijn vijf belangrijke punten uit die architectuur.

AI-agenten zijn eerste-klasse burgers

De meeste frameworks zijn ontworpen voor mensen en worden slechts getolereerd door AI. Phlo is gebouwd op het idee dat een framework dat bestaat als één gesloten lus, met één enkele bron van waarheid, iets is dat een agent daadwerkelijk kan begrijpen.

Het platform levert een speciale SKILL.md referentie voor LLMs, zodat een agent aan de codebase kan werken zonder voorafgaande training. De workflow begint met reflect::context, een enkele oproep die identiteit, route/view tellingen, geladen pakketten en recente fouten retourneert, een snelle oriëntatiesnapshot, met aparte oproepen beschikbaar voor de volledige route- en view-lijsten zelf. Dat maakt deel uit van een ontwerp met twee vlakken: reflect:: en build:: draaien buiten de app, snel en alleen de bron lezend, terwijl phlo_eval binnen de live app draait zodat een agent code kan uitvoeren tegen echte data om gedrag te verifiëren.

Dezelfde eigenschappen die Phlo leesbaar maken voor een mens (één gesloten lus, bron-gemapte fouten, één vaardigheidsdocument) maken het ook hanteerbaar voor een agent, en het behandelen daarvan als een eerste-klasse doel vermenigvuldigt wat een klein team kan doen.

De inzet op nul afhankelijkheden

In een industrie waar een "Hello World" project honderden megabytes aan niet-auditabele vendor code binnenhaalt, is Phlo's nul-afhankelijkheidsstandpunt een verdediging van leesbaarheid. Voor een platform waarvan de hele premisse toezicht is, zou een uitgestrekte vendor boom de architectuur van binnenuit ondermijnen.

In plaats van een pakketkerkhof te beheren, behandelt de engine van nature:

• een geïntegreerde CSS transpiler,
• een ingebouwde JS minifier,
• een interne icon-sprite bouwer,
• een native SPA runtime.

Door dat oppervlak in eigendom te hebben, vermijdt Phlo de afhankelijkheidschaos die moderne JavaScript-stacks teistert, en blijft de engine klein genoeg om in zijn geheel begrepen te worden.

Een regel-gebaseerde parser, geen AST

Phlo maakt de verrassende keuze voor een regel-gebaseerde parser in plaats van een traditionele Abstract Syntax Tree. De parser is een paar honderd regels, leesbaar in één zitting. Omdat regel N in de .phlo bron direct overeenkomt met een bekende regel in de gegenereerde PHP, is bron-mapping bijna gratis, en zijn foutpagina's uitzonderlijk nauwkeurig.

De regels zijn strikt: een verklaring eindigt bij de regelafbreking, en een regel die eindigt op (, [, {, }, , of . wordt behandeld als een impliciete voortzetting. De afweging is reëel: een lege regel beëindigt een view, dus je kunt geen lege regels gebruiken voor visuele spatiëring binnen een HTML-blok. Phlo's antwoord daarop is betere diagnostiek, niet een vergevingsgezinde parser: een schending stopt de build met het bestand en de regel, onmiddellijk. Een lossere grammatica zou de regel versoepelen ten koste van de leesbaarheid van de parser, en dat is geen afweging die Phlo maakt.

Realtime als een toevoeging, geen vereiste

Phlo Realtime voegt een WebSocket-laag toe die aanvullend is in plaats van fundamenteel. Een app blijft een normale request-response app en "licht alleen op" met realtime gedrag zodra de Phlo Daemon naast het draait.

Het is een in-process model: de daemon bezit de socketverbindingen en dispatches evenementen (auth, connect, receive, close) naar je app via dezelfde worker pool die overal elders wordt gebruikt, een eenmalig proces per evenement op een ontwikkelhost, een resident pool op een release host zonder opstartkosten per evenement. Omdat socket evenementen op dezelfde manier worden behandeld als routes, is er geen speciale runtime om te leren, en blijft de database de bron van waarheid in plaats van dat de status in langdurig geheugen leeft.

Het terugwinnen van eigenaarschap van de cloud standaard

De "serverless" standaard rekent per verzoek, dus de kosten schalen met succes. Phlo keert terug naar een model waarbij de kosten de machine volgen, niet het verzoekvolume: de rekening blijft voorspelbaar of je nu tien gebruikers of tienduizend hebt.

Phlo schaalt horizontaal met identieke, share-nothing nodes achter een load balancer. Om verder te gaan, houdt de worker modus de app resident in het geheugen, en objPers laat een dure resource zoals een databaseverbinding overleven tussen verzoeken, zodat een worker geen verse verbinding kosten hoeft te betalen bij elke oproep. Het instellen van prop %MySQL.objPers = true koopt de prestaties van een resident pool zonder de eenvoud van het gewone PHP-model op te geven.

Het doel van dit alles

Phlo's doel is om een klein team het toezicht te geven dat een gefragmenteerde stack hen meestal kost. Het verenigt taal en platform via het apply() protocol: de server stuurt DOM-commando's, de client past ze toe, en er is geen handgeschreven client-side lijm nodig om in sync te blijven met de backend.

De meest nuttige stap die op dit moment beschikbaar is, is misschien niet meer abstractie, maar een model dat klein genoeg is om daadwerkelijk in je hoofd te houden: betaalbaar, in eigendom, en gebouwd om zowel met een mens als een agent aan het toetsenbord te werken.