Ik stelde het oplossen van PHPCS violations in OpenLucius al veel te lang uit. Er waren altijd interessantere dingen te doen: nieuwe functies bouwen, bestaande functionaliteit verbeteren en het product beter maken.
Honderden PHPCS-overtredingen oplossen was niet bepaald waar ik mijn tijd aan wilde besteden.
Ik had PHPCBF, de automatische fixer die bij PHP_CodeSniffer wordt geleverd, al geprobeerd. Die loste veel problemen op, maar er bleef nog steeds ontzettend veel werk over. Ik verloor mijn interesse en ging verder met leukere werkzaamheden.
Tijd voor AI.
Door PHP_CodeSniffer (PHPCS), PHPCBF, een opgeslagen foutrapport in een .txt-bestand en Junie (een AI code agent van JetBrains) te combineren, vond ik een praktische manier om het resterende werk aan te pakken. Na verschillende iteraties had ik honderden gerapporteerde fouten en waarschuwingen opgelost, zonder elke overtreding handmatig te hoeven corrigeren.
Deze aanpassingen zijn toegepast op de nieuwste release van OpenLucius 3.0.0-beta2, gepubliceerd op 17 oktober 2026. Je vindt het project op Drupal.org en kunt de releasegeschiedenis bekijken.
Een samenvatting van de belangrijkste lessen:
- Gebruik PHPCBF om het eerste grote deel van de problemen op te lossen.
- Voer PHPCS uit en schrijf de uitvoer naar een .txt-bestand.
- Laat de AI het .txt-bestand lezen en de overtredingen oplossen.
- Laat PHPCS de resultaten controleren en laat de AI-agent de resterende fouten en waarschuwingen met betrekking tot de Drupal-codestijl oplossen.
- Werk iteratief: code agents lossen niet alle fouten op met één prompt. Ik had per module 2 tot 5 iteraties nodig.
- Houd wijzigingen en Git-commits klein. Werken per module werkte voor mij het beste. Controleer de wijzigingen voordat je ze commit en test relevante module functionaliteit als eindgebruiker, in alle beschikbare rollen.
- Laat AI het repetitieve werk uitvoeren, maar blijf altijd alert op AI-slop.
Waarom Drupal-coderingsstandaarden belangrijk zijn
Drupal heeft vastgestelde PHP coderingsstandaarden die ontwikkelaars helpen om consistente, leesbare en maintainable code te schrijven. Het Drupal Coder-project integreert deze standaarden met PHP_CodeSniffer, waardoor overtredingen automatisch kunnen worden opgespoord.
PHP_CodeSniffer (PHPCS) detecteert en rapporteert overtredingen van coderingsstandaarden. De bijbehorende tool, PHP Code Beautifier and Fixer (PHPCBF), corrigeert automatisch de overtredingen waarvoor een automatische oplossing beschikbaar is.
Als je deze problemen niet controleert, kan een module na verloop van tijd honderden overtredingen bevatten. Zelfs wanneer afzonderlijke aanpassingen eenvoudig zijn, kan het handmatig oplossen ervan tijdrovend en kostbaar zijn.
Dat was precies mijn situatie met OpenLucius.
Ik wilde de codekwaliteit verbeteren, maar ik besteed mijn tijd liever aan het bouwen van nuttige functies dan aan het corrigeren van honderden opmaak- en documentatieproblemen.
AI-code agents bieden hiervoor een uitstekende oplossing: in plaats van elke gerapporteerde overtreding handmatig aan te pakken, geef je een agent een duidelijk afgebakende opdracht, laat je de wijzigingen uitvoeren en gebruik je PHPCS om het resultaat te controleren.
Stap 1: Begin met PHPCBF
Voordat ik een AI-agent inschakelde, liet ik PHPCBF eerst automatisch oplossen wat mogelijk was.
Voor de ledenmodule van OpenLucius gebruikte ik bijvoorbeeld de volgende opdracht:
phpcbf --standard=Drupal \
web/modules/openlucius/core/ol_members
Hiermee worden veel overtredingen opgelost zonder dat daarvoor een AI-model nodig is. Afhankelijk van de geïnstalleerde regels en beschikbare fixers kan de tool problemen corrigeren zoals witruimte, inspringing en andere opmaakfouten.
PHPCBF kan echter niet alles oplossen. Sommige overtredingen vereisen zinvolle documentatie, wijzigingen in naamgevingsconventies of inzicht in de onderlinge samenhang van verschillende onderdelen van de applicatie.
Na het uitvoeren van PHPCBF had ik nog steeds een aanzienlijke hoeveelheid werk te doen.
Dat was het moment waarop AI nuttig werd.
Raadpleeg voor installatie- en gebruiksinstructies de Drupal-documentatie over PHP_CodeSniffer.
Stap 2: Genereer een PHPCS-rapport voor de AI-agent
In plaats van AI te vragen om de volledige codebase op te schonen op basis van een prompt, genereerde ik een rapport met de resterende overtredingen.
Ik gebruikte de volgende opdracht:
phpcs --standard=Drupal \
web/modules/openlucius/core/ol_members \
-d memory_limit=1000M \
> /tmp/phpcs_ol_members.txt
Het rapport gaf me een concrete lijst met problemen die opgelost moesten worden.
Vervolgens gaf ik Junie, met het model Qwen3.6-27B-FP8, een veel gerichter geformuleerde opdracht:
Fix all PHPCS warnings and errors mentioned in
/tmp/phpcs_ol_members.txt. Don't recheck your results.
Hierdoor werd de taak een stuk overzichtelijker. De agent had een specifiek doel en een referentiebestand met de gerapporteerde overtredingen, in plaats van een open opdracht om de codekwaliteit te verbeteren.
Bovendien bespaart dit je veel AI-credits.
Ik bewaarde het rapport ook als referentie voor het opschoningsproces. Nadat de broncode was gewijzigd, genereerde ik het rapport opnieuw voor de volgende controleronde.
Een PHPCS-rapport beschrijft de code zoals die was op het moment waarop het rapport werd gegenereerd. Zodra de agent bestanden wijzigt, kunnen de regelnummers in het rapport verouderd zijn of kunnen overtredingen al zijn opgelost. Daarom moet je PHPCS opnieuw uitvoeren.
Stap 3: Pak één Drupal-module tegelijk aan
De meest effectieve aanpak voor mij was om module voor module te werken, in plaats van AI te vragen alles in één keer op te schonen.
De ledenmodule van OpenLucius was hiervan een goed voorbeeld. Mijn eerste rapport bevatte het volgende aantal fouten in drie PHP-bestanden:
| Bestand | Gerapporteerde fouten |
|---|---:|
| `MembersForm.php` | 72 |
| `MembersController.php` | 47 |
| `OlMembers.php` | 226 |
| **Totaal** | **345** |
De agent pakte problemen aan met de volgorde van imports, ongebruikte imports, docblocks, naamgeving van properties, booleans en hoofdlettergebruik. Ook witruimte, array-syntaxis en inspringing werden aangepakt, om maar een paar voorbeelden te noemen.
Sommige property names moesten worden gewijzigd van snake_case naar camelCase om aan de geselecteerde code standaarden te voldoen.
Hoewel veel van deze wijzigingen mechanisch waren, waren ze niet allemaal puur cosmetisch. Het hernoemen van een property kan gevolgen hebben voor andere delen van de applicatie, waaronder servicedefinities, constructor argumenten en verwijzingen elders in de code.
Daarom hield ik de opdracht beperkt en vermeed ik onnodige refactoring.
Groepeer wijzigingen per module: om de code onderhoudbaar te houden, groepeer ik wijzigingen bij voorkeur per module en commit ik ze waar mogelijk afzonderlijk. Dit maakt het werk eenvoudiger te beoordelen en helpt later bij het onderzoeken van regressies.
Houd CSS en JavaScript gescheiden: ik zou PHP-wijzigingen ook scheiden van wijzigingen in JavaScript en CSS. Hiervoor zijn verschillende tools nodig en ze brengen verschillende risico's met zich mee. Een opschoning van PHP code standaarden mag niet ongemerkt veranderen in een niet-gerelateerde refactoring van de frontend.
Sla CSS- en JS-bibliotheken van derden over, omdat deze elders worden onderhouden en het aanpassen ervan wordt beschouwd als een hack van de core als je ze wijzigt.
Stap 4: Herhaal de PHPCS-controlecyclus
De kern van deze werkwijze is de feedback-lus tussen de AI-agent en PHPCS.
Nadat de agent wijzigingen had aangebracht, voerde ik PHPCS opnieuw uit, bekeek ik de resterende bevindingen en gaf ik de bijgewerkte resultaten terug aan de agent. Dit proces herhaalde ik gedurende meerdere iteraties.
De werkwijze was eenvoudig:
- Voer PHPCBF uit om automatisch corrigeerbare overtredingen op te lossen.
- Genereer een PHPCS-rapport met de resterende problemen.
- Vraag de agent om de gerapporteerde overtredingen op te lossen.
- Voer PHPCS opnieuw uit op de gewijzigde code.
- Herhaal dit totdat de betreffende module geen overtredingen meer bevat.
De agent voert de wijzigingen uit, maar PHPCS zorgt voor de onafhankelijke controle.
Na verschillende iteraties rapporteerde de laatste PHPCS-controle nul fouten in de drie PHP-bestanden.
Stap 5: Controleer de diff en test de wijzigingen
AI kan ervoor zorgen dat code PHPCS doorstaat, terwijl er tegelijkertijd ergens anders een onbedoelde wijziging wordt geïntroduceerd. Daarom blijft het essentieel om de daadwerkelijke diff te controleren.
In mijn geval vereiste het hernoemen van properties ook aandacht voor de bijbehorende servicedefinities, bijvoorbeeld in ol_members.services.yml. Constructor argumenten en dependency injection moesten consistent blijven met de PHP-code.
Een agent kan een naamgevingsfout in een PHP-bestand succesvol oplossen, maar een gerelateerd onderdeel van de code over het hoofd zien.
Daarom controleer ik de wijzigingen en voer ik relevante tests uit nadat de agent klaar is. Afhankelijk van de omvang van de wijzigingen kan dit bestaan uit PHP syntax controles, het legen van de Drupal-cache, het inspecteren van logs en het handmatig testen van de getroffen functionaliteit.
Ik vermijd ook om de agent JavaScript, CSS of bibliotheken van derden, zoals Summernote, te laten aanpassen tijdens een taak rond PHP code standaarden, tenzij daar een specifieke reden voor is.
Het doel is om de codekwaliteit te verbeteren zonder de logica of functionaliteit te veranderen.
Waarom een agent via de CLI beter werkte dan chat
Ik had weinig succes met het oplossen van dit probleem via een gewone chatinterface. Ik probeerde ChatGPT, maar dat leverde verkeerde resultaten op.
De taak omvatte veel bestanden, honderden gerapporteerde overtredingen en verschillende controlerondes. Codefragmenten naar een chatbot kopiëren en de voorgestelde wijzigingen vervolgens handmatig toepassen, was bovendien geen praktische werkwijze.
Een agent die rechtstreeks in de repository werkt, paste veel beter bij deze taak. De agent kon bestanden inspecteren, wijzigingen aanbrengen, opdrachten uitvoeren en het rapport in de juiste context verwerken.
Ik leerde echter dat het niet per se de beste aanpak was om de agent onbeperkte verantwoordelijkheid voor de volledige taak te geven.
Een kleinere opdracht met expliciete grenzen werkte beter. Het rapport definieerde wat aandacht nodig had en PHPCS gaf na elke ronde objectieve feedback.
Leer je agent kennen
Dit hielp me ook om te begrijpen hoe ik effectief met AI-Code agents kan werken. Je leert je agent kennen: wat hij betrouwbaar kan uitvoeren, waar hij duidelijkere instructies nodig heeft en wanneer het beter is om een taak op te splitsen in kleinere onderdelen.
Waarom open source deze aanpak aantrekkelijk maakt
Gelukkig bestaat open source. Het geeft ontwikkelaars de vrijheid om hun code te inspecteren, tools lokaal uit te voeren en zelf te bepalen hoe ze AI in hun workflow integreren. Zonder zich al te veel zorgen te hoeven maken over de vraag of AI van hun code leert en deze vervolgens met de buitenwereld deelt.
Laat staan environment keys: die horen niet in Git, maar kunnen lokaal worden ingevoerd om alles werkend te krijgen.
OpenLucius is open source, waardoor ik controle heb over de repository en de tools die ik kies. Je kunt het OpenLucius-project op Drupal.org bekijken, inclusief de beschikbare releases en projectinformatie.
Ook bij open source is het belangrijk om te begrijpen welke gegevens de agent verstuurt, over welke machtigingen hij beschikt en of zijn netwerktoegang geschikt is voor het project.
Een afgeschermde container, duidelijk afgebakende opdrachten en onafhankelijke controles dragen allemaal bij aan een beter beheersbare workflow.
Optionele beveiliging: voer de AI coding agent uit in een container
Je kunt een AI coding agent uitvoeren in een voldoende afgeschermde container. Dit biedt een extra isolatielaag tussen de agent en de rest van mijn ontwikkelomgeving.
Een container biedt geen volledige veiligheidsgarantie. De effectiviteit hangt af van de configuratie, waaronder file system koppelingen, inloggegevens, machtigingen en netwerktoegang. Toch is een goed afgeschermde omgeving een verstandige voorzorgsmaatregel wanneer een agent bestanden kan wijzigen en opdrachten kan uitvoeren.
Ik heb ook geëxperimenteerd met Claude Code via de CLI en gevraagd om alles rechtstreeks af te handelen. Dit proces vereiste echter extra tools, autorisatieverzoeken en veel te veel credits.
OpenLucius 3.0.0-beta2: coding standards bijgewerkt
De in dit artikel beschreven opschoning is toegepast op de nieuwste release van OpenLucius 3.0.0-beta2, gepubliceerd op 17 oktober 2026.
Je kunt het project en de release-geschiedenis hier bekijken:
Dit is een praktisch voorbeeld van hoe je AI kunt gebruiken om een bestaande Drupal codebase te verbeteren, zonder van een taak rond coding standards een onbegrensd refactoring project te maken.
Het belangrijkste resultaat was niet simpelweg dat een AI-agent honderden regels code had aangepast. Het was dat de wijzigingen duidelijk waren afgebakend, met PHPCS waren gecontroleerd en in het project waren opgenomen.
Veelgestelde vragen
Kan AI Drupal-PHPCS-fouten automatisch oplossen?
AI-codeeragenten kunnen veel gerapporteerde overtredingen van Drupal-coderingsstandaarden oplossen, waaronder problemen met opmaak, de volgorde van imports, documentatie en naamgevingsconventies. De wijzigingen moeten echter altijd worden gecontroleerd door PHPCS opnieuw uit te voeren en de diff te beoordelen.
Wat is het verschil tussen PHPCS en PHPCBF?
PHPCS detecteert en rapporteert overtredingen van coderingsstandaarden. PHPCBF corrigeert automatisch de overtredingen waarvoor een fixer beschikbaar is. Door beide tools samen te gebruiken, leg je een praktische basis voor het opschonen van code met behulp van AI.
Welke AI-codeeragent kan worden gebruikt voor Drupal-ontwikkeling?
Een agent die repositorybestanden kan inspecteren, code kan aanpassen, terminalopdrachten kan uitvoeren en de uitvoer daarvan kan interpreteren, kan deze werkwijze ondersteunen. Ik gebruikte Junie in de PHPStorm-IDE. Deze ondersteunt "10+ modellen via BYOK".
"Plan met een krachtig model, implementeer met een snel model. Dezelfde kwaliteit, tegen een fractie van de kosten."
Ik vind het prettig dat je toonaangevende modellen kunt uitproberen zonder je volledig te hoeven registreren en credits te moeten kopen.
Is het veilig om een AI-agent een Drupal-codebase te laten aanpassen?
Dit kan op een veiligere manier door de machtigingen van de agent te beperken, deze in een voldoende geïsoleerde omgeving uit te voeren, de omvang van elke opdracht te beperken en alle wijzigingen te controleren. Een container vermindert bepaalde risico's, maar vormt geen volledige beveiligingsgrens.
Garandeert het doorstaan van PHPCS dat Drupal-code correct werkt?
Nee. PHPCS controleert de coderingsstandaarden die door de geselecteerde regels worden gedekt. Het garandeert niet dat de code tijdens runtime correct werkt, dat dependency injection juist is ingesteld of dat er geen functionele regressies zijn ontstaan. Tests en codebeoordelingen blijven noodzakelijk.
Conclusie: besteed minder tijd aan repetitief onderhoud en verbeter de codekwaliteit
Ik had het opschonen van PHPCS in OpenLucius veel te lang uitgesteld, omdat ik mijn tijd liever besteed aan het bouwen van nuttige functies dan aan het corrigeren van honderden overtredingen van coderingsstandaarden.
AI bood me een praktische manier om deze achterstand eindelijk aan te pakken.
De combinatie van PHPCBF, een opgeslagen PHPCS-rapport in een .txt-bestand, Junie en herhaalde controles veranderde een vervelende handmatige taak in een beheersbaar proces. Na verschillende iteraties had ik veel van de gerapporteerde fouten in drie PHP-bestanden opgelost en leverde de laatste Drupal-PHPCS-controle nul fouten op.
Deze aanpassingen zijn opgenomen in OpenLucius 3.0.0-beta2, beschikbaar via het OpenLucius-project op Drupal.org.
De les is niet dat je AI blindelings een volledige codebase moet laten aanpassen. Het gaat erom de agent een specifieke opdracht te geven, bestaande tools het resultaat te laten definiëren en controleren, en menselijke beoordeling onderdeel van het proces te laten blijven.
PHPCBF lost op wat het automatisch kan corrigeren. AI neemt een groot deel van het repetitieve werk voor zijn rekening. PHPCS controleert de coderingsstandaarden. Tests helpen het gedrag van de applicatie te verifiëren. En ik blijf verantwoordelijk voor het beoordelen van de wijzigingen voordat ze onderdeel worden van OpenLucius.
Nu kan ik weer aan nieuwe functies werken.
En misschien nog belangrijker: onderweg heb ik geleerd hoe ik effectiever met mijn AI-codeeragent kan samenwerken. 🚀
Redactionele opmerking: ik heb ook AI-tools gebruikt om te helpen bij het structureren en redigeren van dit artikel. De experimenten en observaties zijn gebaseerd op mijn eigen ontwikkelingservaring.
