AI-ul care scrie cod: de la o formulă la o criză de apă
Înainte să deschidem un asistent, hai să vedem de unde vine și ce pune în mișcare — pentru că povestea asta ne privește direct pe noi, cei care lucrăm cu apă, sedimente și deltă.
Psihologul Mircea Miclea propune o paralelă: dacă revoluția industrială a multiplicat clasele sociale (muncitori, maiștri, ingineri, manageri), AI le va reduce înapoi la două mari categorii.
- Aristocrații epistemici — minoritatea care citește, reflectează, gândește critic. Folosesc AI ca instrument, dar nu depind de el: știu ce întrebări să pună, pentru că au deja cunoștințele „la purtător”.
- Iobagii epistemici — au delegat efortul mental tehnologiei. Folosesc AI ca să scrie compunerile, să rezolve tema, să decidă pentru ei. Dacă le iei accesul, valoarea lor scade la zero.
Suntem încă în fereastra în care putem alege. Singura cale ca să nu devii „iobag” e efortul cognitiv asumat: citește, învață, antrenează-ți mintea — limitează divertismentul facil. Despre asta e tot restul modulului.
Dacă AI-ul scrie tot mai mult din cod, valoarea ta nu mai e sintaxa. E formularea clară a problemei și verificarea rezultatului — fix lucrurile pe care le exersăm în următoarele 45 de minute. Și, ca cercetători de mediu, suntem printre primii care ar trebui să folosească aceste unelte conștient de amprenta lor.
La finalul sesiunii vei putea
Cum decurge sesiunea
| Etapă | Instrumente | |
|---|---|---|
| Predare | ||
| 1 | Model mental: LLM-ul ca junior rapid, sigur pe el. Când merită / când nu | demo |
| 2 | Anatomia unui prompt bun. Rețeta și bucla iterativă | Claude (live) |
| 3 | Verificarea rezultatelor: checklist-ul pe exemple reale din Deltă | Claude · Colab |
| 4 | Reproductibilitate și onestitate: versiuni, seed, citarea AI | — |
| Hands-on & discuție | ||
| 5 | Exercițiu hands-on cu un asistent | Colab + asistent |
| 6 | Discuție și Q&A | — |
Cinci idei de dus acasă
Model mental
Un LLM prezice textul cel mai plauzibil, nu adevărul. Nu rulează codul, nu-ți vede datele și nu știe versiunea ta de bibliotecă. E un coleg junior foarte rapid și foarte sigur pe el — care uneori inventează cu aceeași convingere cu care are dreptate.
→ Tratează orice răspuns ca pe o propunere, nu ca pe un adevăr.
Context > formulare scurtă
Garbage in, garbage out. Fără context, modelul împrăștie; cu context, lovește ținta. Un prompt bun = Context + Date (formă, unități, CRS, nodata) + Sarcină + Format + Constrângeri.
→ Două minute de context economisesc cinci iterații.
Bucla iterativă
Rar nimerești din prima. Prompt → rulează → citește eroarea → re-promptează. Lipește eroarea completă și un fragment din date, nu o reformulare a ei.
→ Trei iterații țintite bat un prompt „perfect".
Verificarea e treaba ta
Cod care rulează ≠ cod corect. Cea mai periculoasă căsuță e „rulează, dar greșit": niciun mesaj de eroare, dar rezultat fals. Tu rămâi recenzorul — tu cunoști unitățile, CRS-ul și ordinul de mărime.
→ Codul tăcut și plauzibil e cel mai înșelător.
Reproductibilitate & onestitate
Fixează versiunile (pip freeze), pune un seed, notează că ai folosit un asistent. Nu lipi date nepublicate în prompt. LLM-ul halucinează DOI-uri și referințe — verifică orice citare.
→ Dacă nu poți reproduce, nu poți publica.
Când merită să folosești AI — și când nu
- scrii cod repetitiv / boilerplate (citit-scris fișiere, plotări, parsing)
- explorezi o bibliotecă sau un API nou
- refactorizezi, adaugi docstrings sau comentarii
- transformi pseudocod ori pași descriși în cod
- scrii teste sau generezi date de exemplu
- traduci cod dintr-un limbaj în altul
- logica e științifică, critică și subtilă (fizica modelului, bugete de sediment)
- ai date sensibile sau nepublicate în prompt
- ai nevoie de o referință sau citare exactă
- e o sarcină mică pe care o știi pe de rost (mai rapid manual)
- codul intră direct în producție fără review
- nu ai cum să verifici rezultatul
Prompt slab vs prompt bun
Context (ce ai deja) · Date (formă, dtype, unități, CRS, nodata) · Sarcină (ce vrei exact) · Format (ce să-ți returneze) · Constrângeri (ce biblioteci să folosească / evite). Dacă e o sarcină subtilă, adaugă și un exemplu input → output.
xarray.Dataset `ds`, var `t2m` (°C), dims (time, lat, lon), pas zilnic, EPSG:4326extrage seria la Sulina (45.15°N, 29.65°E) prin interpolare, apoi media lunarăpandas.Series lunară + grafic matplotlib cu axe etichetatedoar xarray + matplotlib; fără bucle for; comentează fiecare pasExemplul 1 — serie de timp lunară la Sulina
Scrie cod Python să-mi scoți temperatura pentru Sulina și să faci media lunară.
De ce e slab: nu spune ce structură de date are, ce unități, ce coordonate are Sulina sau ce să returneze. Asistentul ghicește — și de obicei greșit (citește un CSV inexistent, inventează coordonate, întoarce un array fără etichete).
Context: am un xarray.Dataset `ds` cu variabila `t2m` (temperatura aerului la 2 m, unități °C), dimensiuni (time, lat, lon), pas zilnic, CRS geografic EPSG:4326. lat crește spre nord, lon spre est. Sarcină: extrage seria de timp la Sulina (45.15°N, 29.65°E) prin interpolare biliniară, apoi agreg-o la medie lunară. Format: returnează un pandas.Series indexat pe lună + un grafic matplotlib cu axa Y etichetată „Temperatura (°C)" și titlu „Sulina — medie lunară". Constrângeri: folosește doar xarray (.interp, .resample) și matplotlib; fără bucle for peste timp; comentează fiecare pas pe o linie.
Exemplul 2 — mască de apă (NDWI) dintr-un GeoTIFF
Aici tocmai capcanele din Modulul 2 (CRS, nodata) sunt locul unde un LLM te poate duce frumos în șanț.
Calculează NDWI pentru imaginea mea satelitară.
De ce e slab: nu știe ce benzi sunt unde, ce reprezintă valorile, cum sunt marcați pixelii lipsă. Riști împărțire la zero pe nodata, NDWI pe benzile greșite și pierderea CRS-ului la salvare.
Context: am un GeoTIFF Sentinel-2 deschis cu rioxarray ca DataArray `da`, dimensiuni (band, y, x). Banda 1 = Verde (B3), banda 2 = NIR (B8), reflectanță în [0, 1]. CRS = EPSG:32635 (UTM 35N). Pixelii lipsă sunt marcați cu nodata = 0. Sarcină: calculează NDWI = (Verde − NIR) / (Verde + NIR) și o mască binară apă/uscat (NDWI > 0). Maschează pixelii nodata ÎNAINTE de împărțire, ca să nu intre în calcul. Format: un DataArray `ndwi` (float32, păstrează CRS și transform) + un DataArray boolean `apa` + suprafața de apă în km² (din rezoluția pixelului). Constrângeri: păstrează metadatele rio; evită diviziunea la zero (np.where pe numitor); doar rioxarray / xarray / numpy, fără apeluri GDAL directe.
Checklist pentru orice cod generat
- Dimensiuni și unități — shape-ul e cel așteptat? °C sau K? m sau km? grade sau metri (CRS)?
- NaN și valori-limită — ce se întâmplă pe nodata, pe împărțire la zero, pe marginea grilei?
- Funcții/biblioteci inventate — există într-adevăr
xr.smooth()saugpd.reproject_to_utm()? (Spoiler: nu.) - Performanță plauzibilă — ordinul de mărime e corect? O suprafață de apă de 10⁶ km² în Deltă e o alarmă.
- Comparare cu un calcul manual — rulează pe un caz mic, cunoscut, unde știi răspunsul.
Capcana CRS / orientarea axei (specific Deltei)
.rio.crs și sensul axei y înainte de orice clip/reproject. Dacă harta apare răsturnată: da.isel(y=slice(None, None, -1)) sau origin='upper' în imshow.resample vs isel — agregare sau selectare?
resample(time='1ME').mean() face media ferestrei (corect pentru climatologie). isel(time=slice(None, None, 30)) doar selectează fiecare al 30-lea timestamp. Un LLM le confundă des — și ambele „rulează". Citește ce ți-a dat.Întreabă asistentul să se verifice singur
De evitat
- Vibe coding pe orb — lipești cod și-l rulezi fără să-l citești.
- Accepți primul răspuns la un prompt vag, în loc să dai context și să iterezi.
- Nu dai versiunile bibliotecilor → cod cu API vechi sau prea nou (xarray, pandas se schimbă).
- Crezi numerele fără sanity-check de unități și ordin de mărime.
- Funcții care „sună bine" dar nu există — verifică în documentația oficială.
- Lipești date sensibile / nepublicate în prompt (date de proiect, măsurători neîncărcate, GDPR).
- Te bazezi pe LLM pentru fapte și citări — halucinează referințe și DOI-uri convingător.
Ce model? Și cum codezi cu el acum
În mai 2026, modelele „de frontieră" (Claude, GPT, Gemini) sunt foarte apropiate pe sarcini de cod — toate în jur de 80% pe SWE-bench Verified, testul standard pe probleme reale din GitHub. Diferențele dintre ele contează azi mai puțin decât unealta (agentul) în care le folosești.
Cifre orientative (mai 2026). Benchmark-urile sunt zgomotoase și parțial „contaminate" — citește-le ca direcție, nu ca verdict.
- Claude (Opus 4.7) — puternic pe cod multi-fișier și agenți; ancora workshop-ului.
- GPT (5.x / Codex) — agentic, „computer use", context de 1M token.
- Gemini (3.1 Pro) — cel mai ieftin la nivel de frontieră + 1M context; nativ în Colab.
Cea mai bună calitate — dar codul tău pleacă spre un furnizor extern.
- Qwen3-Coder-Next — făcut pentru agenți de cod; rulează pe hardware consumer puternic.
- Gemma 4 (Google, Apache-2.0) — cel mai practic default local; intră în ~8 GB VRAM.
- DeepSeek V4 · GLM · Kimi — aproape de frontieră pe sarcini bine definite.
Le rulezi cu Ollama / llama.cpp / LM Studio — gratis, offline, datele rămân la tine.
Acum un an, modelele open-weight erau „experimente". Azi sunt la ~10 puncte de cele mari și se folosesc în pipeline-uri reale — un model local poate egala generația precedentă de frontieră, dar gratis și privat. Ritmul e amețitor: complexitatea sarcinilor pe care le duce un agent se cam dublează la fiecare ~6 luni.