Codex CLI voor het automatiseren van dataworkflows: een complete gids

Als je dataproffesional bent, voer je waarschijnlijk elke dag veel repetitieve codetaken uit. Denk aan het profileren van volledig nieuwe datasets, het vanaf nul opzetten van datapijplijnen of het handmatig uitschrijven van tests voor datatransformaties. Dit soort werk is nodig, maar slokt veel tijd op. 

Maar wat als je terminal al die repetitieve boilerplatecode voor je zou kunnen beheren en schrijven, terwijl jij je energie richt op denkwerk en besluitvorming? Daar komt OpenAI's Codex-CLI om de hoek kijken. Het is een zeer capabele AI-codeeragent die rechtstreeks in je command line is ingebouwd en, zoals we zullen zien, ideaal is om dataworkflows te stroomlijnen.

In deze tutorial bespreken we hoe data-analisten en -wetenschappers Codex-CLI kunnen gebruiken om hun meest voorkomende dagelijkse datataken te versnellen. We behandelen alles: van het uitvoeren van een eerste verkennende data-analyse tot het bouwen van volwaardige datapijplijnen en zelfs het maken van geautomatiseerde tests voor je transformaties, allemaal via de terminal zelf.

Wil je meer weten over het bouwen van agentische AI-systemen? Ik raad je sterk aan je in te schrijven voor onze skill track AI Agent Fundamentals, waarin alles wordt behandeld wat je moet weten.

Wat is Codex CLI?

Laten we eerst begrijpen wat Codex CLI is. In de kern is Codex CLI een open-source, terminalgebaseerde codeeragent die is ontwikkeld door OpenAI. 

Het is gebouwd met de programmeertaal Rust, wat het behoorlijk snel en efficiënt maakt. Het belangrijkste om te begrijpen is echter dat het rechtstreeks in je command line draait, waardoor het je bestanden kan lezen, je code kan bewerken en zelfs lokaal commando's kan uitvoeren op je machine.

Hoe Codex CLI verschilt van ChatGPT voor datataken

Hoewel je waarschijnlijk gewend bent om de standaard ChatGPT-webinterface voor je werk te gebruiken, is Codex CLI heel anders. Bij gebruik van de webinterface staat het AI-model volledig los van de omgeving waarin je werkt. 

Met Codex CLI heeft de agent daadwerkelijk directe toegang tot je lokale bestandssysteem. Het kan Python-scripts draaien, naar de output of eventuele fouten kijken, en het behoudt volledig overzicht over je hele projectstructuur zonder dat jij eerst alles hoeft uit te leggen.

Omdat de Codex-agent de macht heeft om je bestanden direct te bewerken en commando's op je machine uit te voeren, zijn er uiteraard verschillende toestemmingsmodi om te zorgen dat jij altijd de controle houdt. De drie toestemmingsmodi zijn:

• Auto (standaard): Codex kan end-to-end werken binnen je huidige projectmap. Als het daarbuiten moet treden of iets met netwerktoegang wil doen, stopt het en vraagt het eerst om toestemming.
• Alleen-lezen: Codex kan je project inspecteren en voorstellen doen, maar raakt geen bestanden aan en voert niets uit totdat jij het plan goedkeurt.
• Volledige toegang: Codex is niet langer beperkt tot de projectmap en kan over je hele machine opereren, inclusief netwerktoegang, zonder te pauzeren voor bevestiging. Gebruik dit alleen wanneer je de repo volledig vertrouwt en je weet dat de taak veilig is.

Als je net begint, raad ik aan om te starten in Alleen-lezen en pas op te schalen zodra je de workflow vertrouwt.

Je kunt toestemmingsmodi wijzigen binnen een draaiende Codex-sessie met /permissions. Dat is de eenvoudigste manier om van Alleen-lezen naar Auto te gaan zodra je er comfortabel mee bent.

/permissions

Wil je Codex vanaf het begin in een strengere modus starten, dan kun je de sandbox- en goedkeuringsvlaggen instellen bij het opstarten. Dit voorbeeld start in een conservatieve alleen-lezen setup die nog steeds om bevestiging vraagt wanneer dat nodig is.

codex --sandbox read-only --ask-for-approval on-request

Codex CLI instellen voor dataprojecen

Er zijn een paar vereisten die je nodig hebt om deze tutorial goed te kunnen volgen. 

• Python 3.10 of hoger geïnstalleerd op je machine
• Basiskennis van de terminal of command line
• pip (Python's pakketbeheerder) geïnstalleerd om packages te beheren
• Ofwel een betaald ChatGPT-account (Plus, Pro, Team, Business, Enterprise) of een OpenAI API-sleutel om toegang te krijgen tot de OpenAI-modellen waarop Codex is gebouwd

Allereerst moet je de Codex CLI op je machine installeren. Open je terminal en installeer de CLI globaal op je systeem met dit commando:

npm install -g @openai/codex

De volgende stap is je account authenticeren, zodat de tool weet wie je bent. Je kunt verifiëren dat alles correct is geïnstalleerd en de agent voor het eerst starten door simpelweg codex in je terminal te typen. Je ziet dan iets als dit:

Zodra je op enter drukt, opent er een browservenster waarin je wordt gevraagd in te loggen met je ChatGPT-account. Na het inloggen ben je klaar om de tool te gebruiken.

Heb je geen betaald ChatGPT-abonnement en wil je in plaats daarvan een API-sleutel gebruiken, dan is er ook de pay-per-use-optie. Je kunt een sleutel verkrijgen via de OpenAI-console.

Je Python-dataomgeving configureren

Voordat we de AI vragen om data-analyse te doen, is het belangrijk dat we onze Python-dataomgeving goed configureren. Dit is essentieel omdat Codex CLI draait binnen de omgeving waarin het op dat moment actief is. Als de agent dus een script moet schrijven dat datawetenschapsbibliotheken gebruikt zoals pandas, scikit-learn of matplotlib, dan moet je ervoor zorgen dat die libraries zijn geïnstalleerd en beschikbaar zijn.

Dit kunnen we doen door een Python-virtuele omgeving te activeren voordat we Codex starten. Hier is een voorbeeld van een setupscript met de exacte commando's die je in je terminal kunt draaien om een virtuele omgeving te maken, de benodigde datapakketten te installeren, deze te activeren en vervolgens de agent te starten:

python3 -m venv data_env
source data_env/bin/activate
pip install pandas scikit-learn matplotlib
codex

Een AGENTS.md-bestand maken voor dataprojecen

Nog een belangrijke stap bij het inrichten van je project is het aanmaken van een bestand genaamd AGENTS.md in je hoofdprojectmap. Zie dit bestand als een set blijvende instructies die de Codex-agent elke keer automatisch leest wanneer het je project opent. Het vertelt de AI hoe jij wilt dat het zich gedraagt en hoe je wilt dat het code schrijft voor deze specifieke werkruimte.

Voor datataken willen we zeker weten dat de gegenereerde code schoon, leesbaar en professioneel is. Hier is een voorbeeld van een AGENTS.md-bestand dat specifiek is afgestemd op een dataproject. Je kunt dit bestand gewoon aanmaken en deze tekst erin plakken:

# Data Project Guidelines


When writing Python code for this project, please strictly follow these rules:
- Enforce PEP 8 formatting standards for all Python code.
- Always use highly descriptive variable names. Do not use generic, lazy names like df, data, x, or y. Instead, use specific names like transaction_data or revenue_series.
- Prefer pandas best practices, such as using vectorized operations instead of iterating through rows.
- Generate clear, descriptive docstrings for every single function.
- Always include Python type hints for function arguments and return values.

Omdat dit bestand elke keer wordt gelezen, onafhankelijk van de taak, is het best practice om het beknopt te houden en je alleen te richten op instructies die voor elke prompt gelden. Voor meer specifieke instructies kun je in plaats daarvan skills gebruiken. 

Codex CLI gebruiken voor Exploratory Data Analysis

Laten we nu naar het echte datavwerk gaan: we beginnen met Exploratory Data Analysis, of EDA. Zoals je waarschijnlijk al weet, is dit bijna altijd het startpunt voor letterlijk elk nieuw dataproject dat je aanpakt. Voordat je modellen of pijplijnen kunt bouwen, moet je weten hoe je data eruitziet. 

Het mooie is dat je met de Codex CLI met één simpele prompt in natuurlijke taal een volledig werkend EDA-script kunt laten genereren.

Het scenario: stel dat we werken met een realistische, synthetische dataset. We hebben een e-commercedataset genaamd transactions.csv die in onze projectmap staat. Deze staat vol met realistische bedrijfsdata zoals order-ID's, user-ID's, aankoop-tijdstempels en transactiebedragen.

Een dataset profileren

Wanneer je zo'n nieuw bestand krijgt, wil je het eerst profileren om de basisstructuur te begrijpen. In plaats van zelf de boilerplate pandas-code te schrijven, kun je letterlijk je terminal openen, waar je Codex-sessie draait, en een prompt intypen zoals deze:

Profile the transactions.csv file. Show shape, dtypes, missing values, and summary statistics.

Wanneer je op enter drukt, leest Codex de eerste regels van je transactions.csv-bestand rechtstreeks van je lokale bestandssysteem. Vervolgens genereert het een compleet Python-script om het profileren uit te voeren en in "suggest"-modus vraagt het of je het wilt draaien. 

Je ziet meteen de exacte vorm van de data, de datatypes van je specifieke e-commercekolommen en precies hoeveel missende waarden je moet aanpakken (voorbeeld hieronder), zonder dat je zelf een regel code hoeft te schrijven.

Visualisaties maken met natuurlijke taal

Getallen in een terminal zijn prima, maar uiteindelijk wil je de data ook visueel zien. Je kunt verrassend complexe visualisaties genereren door simpelweg in gewone taal te beschrijven wat je wilt.

Als je bijvoorbeeld een helikopterview van je e-commercebedrijf wilt, kun je Codex een prompt geven zoals deze:

Create a matplotlib dashboard with 3 subplots showing revenue by month, product categories ranked by sales, and order distribution by day of week.

Dat is best een complexe vraag. Maar Codex analyseert zowel de prompt als je databestand opnieuw, bepaalt hoe de datums gegroepeerd en de omzet gesommeerd moet worden, maakt een stap-voor-stap plan en zet dat om in een robuust matplotlib-script om precies die subplots te genereren.

Hier is een cruciaal punt bij het werken met dit soort AI-agenten: het is van nature een iteratief proces. Wanneer Codex de eerste versie van de visualisatiecode voorstelt, kun je die gewoon goedkeuren om te zien hoe het eruitziet. 

Misschien genereert de eerste versie de grafiek, maar zie je dat de labels op de x-as overlappen en moeilijk leesbaar zijn, of dat de kleuren te fel zijn. Je hoeft het script niet te openen en de matplotlib-parameters handmatig te tweaken. 

Reageer simpelweg met een vervolgpromept, zoals: "De labels onderaan overlappen, draai ze 45 graden en maak de legendakleuren zachter." Codex verfijnt dan het script, draait het opnieuw en geeft je het bijgewerkte, gepolijste dashboard.

Een datapijplijn bouwen met Codex CLI

Zodra je klaar bent met het verkennen van je data en die eerste verkennende analyse, moet je uiteindelijk weg van die rommelige, ad-hoc scripts. 

Wat je eigenlijk wilt, is toewerken naar echte, reproduceerbare, modulaire code. In de datawereld betekent dit meestal het bouwen van een ETL-pijplijn (Extract, Transform, Load). Dat is de standaardmanier om je data binnen te halen, op te schonen en de resultaten op te slaan voor later gebruik.

Om te laten zien hoe dit werkt, gebruiken we een heel praktische situatie. We willen dezelfde e-commercetransactiedata uit ons CSV-bestand inladen, rommelige data opschonen, enkele zakelijke aggregaties berekenen en de uiteindelijke resultaten opslaan in een schoon, nieuw bestand. 

In plaats van al die boilerplate-architectuur zelf te schrijven, kun je de Codex CLI gebruiken om het geheel te scaffolden op basis van een beschrijving op hoofdlijnen.

De pijplijnstructuur scaffolden

De eerste stap is het opzetten van de projectstructuur. Een goede datapijplijn is opgesplitst in aparte bestanden, zodat deze later makkelijk te lezen en te onderhouden is. Je kunt de Codex-agent dit zware werk voor je laten doen. In je terminal geef je bijvoorbeeld deze prompt:

Create a project layout for an ETL pipeline. I need separate Python modules for extraction, transformation, and loading, plus a main entry point script to run them all.

Codex maakt die bestanden vervolgens in je map aan. Als je na goedkeuring van de actie naar je bestandsstructuur kijkt, zie je een nette, professionele architectuur die er ongeveer zo uitziet:

etl_pipeline/
├──__init__.py
├── extract.py
├── transformation.py
└── loading.py
– run_etl.py

De reden dat Codex voor precies deze architectuur kiest, is dat het de verantwoordelijkheden van je code scheidt. Je inleeslogica staat volledig los van je reken- en businesslogica, precies zoals data engineers hun werk horen te structureren.

Transformatielogica schrijven

Laten we nu de transformatie beschrijven die we op onze data willen toepassen. In een ETL-pijplijn is de transformatielogica meestal het lastigst, maar we kunnen Codex de details laten afhandelen met een prompt. Stel dat we missende waarden willen opruimen en precies willen berekenen hoeveel geld elke order opleverde.

Je kunt rechtstreeks in de CLI een prompt typen zoals:

In transformation.py, write a function that takes the transactions data, drops any rows where the user ID is missing, and creates a new derived column called 'revenue' by multiplying the 'quantity' column by the 'unit_price' column.

Omdat Codex je transactions.csv-bestand kan lezen, kent het de échte kolomnamen. Het gaat niet raden en iets schrijven als df['qty'] * df['price'] en hopen dat het werkt. Het kijkt naar je bestand, ziet dat je kolommen daadwerkelijk quantity en unit_price heten, en schrijft precies de correcte pandas-code om dat script te laten werken.

De pijplijn draaien en valideren

Nadat de code is gegenereerd, is de laatste stap het end-to-end draaien van de pijplijn om te controleren of alles werkt. Je kunt Codex gewoon zeggen, "Run het script run_etl.py."

Tijdens het draaien zie je alle terminaloutput direct voor je, en dat kan er zo uitzien:

Het nieuwe processed_transactions.csv zou er ongeveer zo uit moeten zien:

In de echte wereld gaat er weleens iets stuk. Misschien zat er een rare stringwaarde verstopt in een numerieke kolom, wat een TypeError veroorzaakte. Als dat gebeurt, hoef je niet in paniek te raken of de foutmelding naar een webbrowser te kopiëren en plakken. Codex CLI vangt de fout automatisch op, leest de Python-traceback en corrigeert vaak z'n eigen code door ter plekke een oplossing voor te stellen.

Dit benadrukt echt de kern van de iteratieve lus bij het werken met een AI-codeeragent: 

1. Geef Codex een prompt
2. Beoordeel het voorgestelde plan
3. Keur de codewijzigingen goed
4. Inspecteer samen de terminaloutput
5. Verfijn met een nieuwe prompt

Het is een continue, gezamenlijke cyclus die werkende software veel sneller oplevert dan alles met de hand intypen.

Tests schrijven voor datatransformaties met Codex CLI

Je code testen is cruciaal zodat je niet per ongeluk dingen stukmaakt in productie, maar het is nog steeds de stap die bijna altijd wordt overgeslagen.

Tests schrijven is saai, zeker wanneer je alleen snel inzicht uit een nieuwe dataset wilt halen; alles stilzetten om unittests te schrijven voelt dan als een enorme klus. Maar met de Codex CLI in je terminal valt die drempel eigenlijk weg.

pytest-tests genereren op basis van bestaande code

Als je tests wilt genereren voor de transformatiecode die we zojuist hebben geschreven, hoef je de terminal niet te verlaten of een leeg bestand te openen. We kunnen een standaard Python-testframework gebruiken zoals pytest. Geef Codex gewoon een simpele prompt zoals deze:

Write high-quality, maintainable pytest tests for the transform module. Test null handling, extreme edge cases like zeroes or negative values, type casting, and revenue calculation.

Codex kijkt dan terug naar het bestand transformation.py dat het eerder maakte. Het leest je logica, begrijpt wat de functies moeten doen en genereert vervolgens een gloednieuw testbestand voor je. Hieronder zie je wat er in je terminal kan verschijnen nadat Codex klaar is met het genereren van die tests. 

In mijn geval genereerde het een nieuw script test_transformation.py in een nieuwe map tests, dat controleert of de aangewezen transformatiefuncties hun werk correct doen.

Codex schrijft niet alleen generieke assertions, maar maakt ook heel realistische, kleine synthetische datainputs (fixtures genoemd) om je functies te belasten. Het creëert bewust randgevallen, zoals rijen met volledig missende user-ID's of negatieve aankoophoeveelheden, om zeker te weten dat je transformatielogica die rare, kapotte scenario's robuust en correct afhandelt.

Datavalidatiechecks

De Pythoncode zelf testen is één ding, maar als dataprofs moeten we ook de daadwerkelijke data testen die door die code stroomt. Dit wordt meestal datavalidatie genoemd. Je wilt echte assertions genereren die de algemene kwaliteit van de data controleren voordat je die aan stakeholders doorgeeft of in een dashboard laadt.

Je kunt dit demonstreren door Codex te vragen een specifiek datavalidatiescript te genereren. Typ gewoon een prompt zoals:

Create a data validation script that runs after the very end of the pipeline. It should check that the schema matches our expectations, ensure the null-percentage for user_id is exactly 0%, and verify that all revenue values are greater than or equal to zero.

Codex geeft dan een apart validatiescript dat fungeert als laatste vangnet voor je project. Je kunt dit eenvoudig configureren als een laatste post-stap aan het eind van je pijplijn. 

Zo vangt het script het meteen af en geeft het een foutmelding als de structuur van de rauwe CSV-data morgen plots verandert of als een vreemde glitch ineens negatieve omzetwaarden veroorzaakt. Het zorgt ervoor dat je pijplijn geen slechte data stilzwijgend doorgeeft aan je businessgebruikers.

Repetitieve datataken automatiseren met Codex CLI

Tot nu toe hebben we vooral gekeken naar hoe je de Codex CLI interactief gebruikt, met typen over en weer. Maar voor dataprofs die deze tool echt willen integreren in hun dagelijkse workflow, zijn er meer geavanceerde gebruikspatronen die je saaie werk vrijwel op de automatische piloot kunnen zetten.

Jupyter Notebooks converteren naar productiescripts

Jupyter Notebooks zijn fantastisch om in eerste instantie met data te spelen en te verkennen, maar ze zijn behoorlijk onhandig wanneer het tijd is om die code betrouwbaar in productie te draaien. Meestal ben je uren bezig met cellen kopiëren, in Python-bestanden plakken en alle rare problemen met globale variabelen oplossen.

Met Codex CLI kun je de agent simpelweg naar je notebook laten wijzen en het zware werk laten doen. Open je terminal en typ een prompt precies zoals deze:

Refactor analysis.ipynb into a modular Python package with separate files for data loading, transformation, visualization, and a main.py entry point.

Na goedkeuring leest Codex de JSON-structuur van je notebookbestand, haalt de daadwerkelijke Python-code eruit, negeert willekeurige outputlogs en organiseert alles opnieuw. 

Als je de structuren vóór en na bekijkt, zijn ze totaal verschillend. Voorheen had je één gigantisch bestand analysis.ipynb waarin alles door elkaar stond. 

Na afloop zie je een nette, professionele map met aparte bestanden data_loader.py, transformer.py en visualizer.py (de namen kunnen bij jou anders zijn), allemaal netjes bij elkaar gebracht door een main.py-script. Het overbrugt in één klap de kloof tussen je rommelige verkennende analyse en echte, production-ready software-engineering.

codex exec gebruiken voor niet-interactieve automatisering

Soms wil je helemaal niet met de chatinterface werken. Als je geautomatiseerde pijplijnen bouwt, zoals checks die draaien vlak voordat je code met je team deelt, wil je dat de AI z'n werk op de achtergrond doet, volledig op de automatische piloot. 

Daarvoor is het commando codex exec bedoeld. Het is specifiek ontworpen om Codex in scripts en niet-interactieve omgevingen te draaien, zonder dat bij elke stap om toestemming wordt gevraagd.

Om een praktisch voorbeeld te geven, draaien we een snelle test. We kunnen codex exec gebruiken als een gesimuleerde CI/CD-check om automatisch slechte data te detecteren/valideren.

Open je terminal en typ precies dit commando:

codex exec --skip-git-repo-check "Read transactions.csv. Write and run a quick python script to check if the 'quantity' column contains any negative numbers. If it does, print 'DATA VALIDATION FAILED: Negative quantities detected.' If it is clean, print 'DATA VALIDATION PASSED'." 2> /dev/null

Wanneer je op enter drukt, draait Codex niet-interactief. Het opent de gebruikelijke interactieve chatinterface niet, en het goedkeuringsgedrag hangt af van de geconfigureerde goedkeuringsvlaggen en standaardinstellingen; mogelijk moet je bepaalde acties nog toestaan, tenzij je goedkeuringen uitschakelt. Voor meer informatie raad ik de Codex-documentatie aan.

Het schrijft snel het validatiescript, voert het uit op je lokale CSV-bestand en spuugt het eindresultaat direct uit naar je standaard terminaloutput, zolang de map als vertrouwd wordt beschouwd en de goedkeuringen zo zijn geconfigureerd dat dit is toegestaan. Je zou een output op je console moeten zien die er ongeveer zo uitziet:

Deze aanpak heeft veel use-cases. Stel je voor dat je dit commando zoals het is gebruikt in een pre-commit hook of GitHub Actions-workflow. Als je pijplijn ooit data tegenkomt waarin een kolom ontbreekt, NaN-waarden bevat of ander onverwacht gedrag vertoont, kan Codex dat meteen detecteren, zonder dat je al die PyTest- en validatiescripts handmatig hoeft te schrijven.

Best practices voor dataprofs met Codex CLI

Bij het gebruik van AI-tools voor datataken bepaalt de manier waarop je met de agent communiceert volledig de kwaliteit van de Python-code die je terugkrijgt. Laten we enkele best practices bekijken om je workflow zo soepel en professioneel mogelijk te houden.

Effectieve prompts schrijven voor datataken

Het allereerste om te beheersen is het schrijven van effectieve prompts. Je kunt de AI niet gewoon vragen om "de data op te schonen" en perfecte resultaten verwachten. Hier is hoe je je verzoeken zou moeten structureren:

• Wees specifiek: Wees specifiek over de daadwerkelijke kolomnamen, de exacte datatypes die je wilt en het verwachte outputformaat waar je naar op zoek bent. Zeg bijvoorbeeld in plaats van een vage vraag expliciet iets als, "cast de kolom 'purchase_date' naar datetime en output een samengevatte CSV."

• Verwijs direct naar bestanden: Een handige truc is om je bestanden direct te verwijzen met de @-syntaxis in je prompt. Als je @transactions.csv typt, dwingt dat Codex om dat specifieke bestand meteen in de context te lezen. 

• Breek complexe taken op: Misschien wel het belangrijkste: probeer taken altijd op te delen in kleinere eenheden in plaats van Codex te laten handelen op één enorme megaprompt. Gebruik de speciale planmodus van Codex om eerst een concept te maken en het daarna stap voor stap uit te voeren voor complexe taken.

Wil je je prompting naar een hoger niveau tillen, volg dan onze cursus Prompt Engineering with the OpenAI API.

Wanneer je welke toestemmingsmodus gebruikt

Zoals eerder aangestipt heeft de CLI verschillende toestemmingsmodi, en het is belangrijk om te weten wanneer je welke gebruikt. Hier is een gids:

• Alleen-lezen: Gebruik dit wanneer je de tool nog aan het leren bent of wanneer je met gevoelige productiedata of onbekende taken werkt. Het houdt jou stevig aan het roer.
• Auto (werkruimte): Als je meer vertrouwd bent, is Auto ideaal voor routinematige transformaties en refactors in een project dat veilig onder versiebeheer staat. Codex kan bestanden bewerken en scripts draaien binnen de projectmap, maar vraagt nog steeds voordat het iets risicovols buiten die scope doet.
• Volledige toegang: Bewaar dit voor sandbox-experimenten of eenmalige analyses waarbij je snelheid belangrijker vindt dan veiligheid. In deze modus heeft Codex brede toegang tot je machine en vraagt het om minder bevestigingen, dus gebruik het alleen met repo's en taken die je volledig vertrouwt.

Je dataworkflows reproduceerbaar houden

Het reproduceerbaar houden van je dataworkflows is tot slot erg belangrijk voor elke datapro. Eén van de grootste regels is om Codex altijd te draaien binnen een geïnitialiseerde Git-repository. Omdat Codex bestanden gaat schrijven en bewerken op je machine, betekent Git-tracking dat je precies kunt zien wat de AI heeft gedaan en het ongedaan kunt maken als er iets misgaat.

Zorg er ook zeker voor dat je het eerder gemaakte bestand AGENTS.md commit, samen met je projectcode. Zo profiteert je hele team van exact dezelfde codestandaarden en instructies als een andere data scientist je repository clonet en Codex opent. 

Hetzelfde geldt voor alle agent skills die je hebt gedefinieerd voor individuele taken. Ter inspiratie kun je onze gids met meer dan honderd top agent skills voor Codex en andere agentische codeertools bekijken.

En als je meerdere dagen aan een zware analyse werkt, hoef je niet elke ochtend opnieuw te beginnen. Gebruik gewoon het commando codex resume in je terminal om door te gaan met datasessies over meerdere dagen. Het laadt direct je vorige chat, zonder de waardevolle context te verliezen van wat jij en de agent gisteren deden.

Werk je meerdere dagen aan een intensieve analyse, dan hoef je niet elke ochtend overnieuw te beginnen. Je kunt simpelweg het commando codex resume in je terminal gebruiken om door te gaan met data‑projecten over meerdere sessies. Het heropent je laatste Codex-sessie in dat project zodat je verder kunt waar je gebleven was, met de vorige conversatie, plannen en bestandswijzigingen nog in context (onder voorbehoud van normale model- en geschiedenislmmiieten).

Voor meer best practices in agentisch coderen kun je ook onze gids Claude Code Best Practices bekijken. Hoewel Claude Code en Codex verschillen, zoals we hebben aangegeven in onze vergelijking Codex vs Claude Code, zijn veel van de grondbeginselen ook op Codex van toepassing.

Conclusie

We hebben Codex CLI ingericht specifiek voor je datavwerk en je lokale Python-omgevingen. Van daaruit hebben we stap voor stap EDA-scripts vanaf nul gegenereerd, reproduceerbare ETL-datapijplijnen gebouwd, geautomatiseerde transformatietests geschreven (die veel te vaak worden overgeslagen) en tot slot geavanceerde manieren verkend om die superrepetitieve dagelijkse datataken te automatiseren. 

Het belangrijkste om te onthouden is dat we dit allemaal rechtstreeks vanaf de command line deden, zonder heen en weer te springen naar een webbrowser. Codex CLI overbrugt effectief de frustrerende kloof tussen rommelige, verkennende data-analyse en echte, productie-waardige data engineering. 

Ben je geïnteresseerd in het bouwen van een complexere agent met Codex CLI? Bekijk dan onze Codex CLI MCP Tutorial. Die leidt je door het proces van het maken van een agent voor een financieel portfoliodashboard.