Az építőelemek szabják meg az AI-támogatott fejlesztés plafonját
Az AI olcsóvá tette a kódgenerálást, de a tévedés költségét nem csökkentette. A közös package-ek, explicit contractok, futtatható szabályok és megbízható kapuk ma meghatározzák, mennyi hasznos munkát tud kihozni egy csapat az AI-támogatott fejlesztésből.

Nem a gépelés a probléma, hanem az üres lap
Ha megkérünk egy erős modellt, hogy építsen egy feature-t egy üres repóban, valószínűleg kapunk valamit, ami elindul. Mellé kapunk egy új konfigurációs mintát, hibaformátumot, loggingkonvenciót, dátumkezelést és repository-réteget is. Külön-külön mindegyik döntés védhető lehet. Együtt olyan rendszert alkotnak, amit senki nem tervezett meg.
Adjuk ugyanezt a feladatot ugyanannak a modellnek egy olyan kódbázisban, ahol van közös konfigurációs package, egységes route-definíció, egy hibaformátum, egy loggingbeállítás és CI-ban kikényszerített architektúra-szabályrendszer. Sokkal kevesebb dologról kell döntenie, mert a meglévő elemekből dolgozhat.
Az AI-támogatott fejlesztésnek ez a része kevés figyelmet kap, mert régi és látványtalan. Az építőelemek minősége mindig is korlátozta, hogy egy csapat milyen gyorsan tud biztonságosan haladni. Az AI-jal sokkal több kód ütközik ebbe a korlátba, ezért a gyenge alapok hamarabb és gyakrabban kiderülnek.
Az építőelemek négy fajtája
Az „építőelem” alatt gyakran library-t értünk, pedig egy AI-native munkafolyamat 4 tágabb kategóriára támaszkodik:
- Runtime-elemek: közös package-ek, amelyek futásidőben dolgoznak. Konfiguráció, HTTP-kezelés, auth, logging, monitoring, generált API-kliensek. Kód, amit nem kell újra megírni.
- Contractelemek: API-, event- és adatsémák valamilyen szabványos formátumban, például OpenAPI, AsyncAPI vagy JSON Schema. A rendszerhatár definíciója, még az implementáció előtt.
- Szabályelemek: architekturális invariánsok, rétegzési szabályok, elnevezési és ownershipkonvenciók. Mi megengedett, mi tilos, és miért.
- Folyamatelemek: a kapuk. Review, jóváhagyás, CI-checkek, budget, branch protection. Ahol egy változásnak bizonyítania kell, mielőtt továbbmegy.
Egy mérnök az utóbbi kettőt hónapok alatt szívja magába. Egy agentnek nincs ilyen előélete: kap egy context window-t, és azt, amit beleteszünk. Ezért az számít, mennyi tervezői szándék érhető el olyan formában, amelyet a cég történetét nem ismerő szereplő is fel tud dolgozni, és amely alapján a munkája ellenőrizhető. Ehhez képest a modellválasztás sokkal kevésbé számít.
Ha a válasz az, hogy „nagyrészt a fejekben és a kódban”, akkor olyan outputot kapunk, ami helyesnek látszik, közben pedig fokozatosan eltávolodik a rendszertől.
A korlátok teszik jóvá a generált kódot
Production rendszereknél a több szabadság és a jobb prompt ritkán adja a legmegbízhatóbb eredményt. A hasznos korlátok többet érnek.
A modell a kapott kontextushoz tartozó legvalószínűbb kódot állítja elő. Üres kontextussal a „legvalószínűbb” az internet átlagát jelenti: tutorialokat, blogsnippeteket és elhagyott repókat. Szűkített kontextussal a „legvalószínűbb” azt a mintát jelenti, amit a kódbázisunk már ötvenszer használ.
Az alábbiak mind hasznosan szűkítik a mozgásteret:
- egy közös package, ami az adott problémát már megoldja
- egy séma, ami definiálja, mi számít érvényes payloadnak
- egy rétegzési szabály, ami tiltja a kerülőutat
- egy teszt, ami elbukik, ha valaki mégis a kerülőutat választja
- egy scaffold, ami a helyes vázat adja, még a generálás előtt
Ez hétköznapi platform engineering, azon a ponton alkalmazva, ahol a legtöbbet számít: még a generálás előtt.
A kontextus szűkös, a jó package pedig tömörítés
Az építőelemek kontextust is megtakarítanak, a kontextus pedig véges és drága.
Minden token, amit a modell arra költ, hogy újra felfedezze, hogyan működik az adott kódbázisban az autentikáció, olyan token, amit nem a tényleges problémára fordít. Minden fájl, amit el kell olvasnia egy konvenció kikövetkeztetéséhez, egyben latency, költség és újabb esély arra, hogy kicsit rosszul következtessen.
Egy jól megtervezett package tömörítés. Ha egy közös config package ott van a kontextusban, az agentnek nem kell 6 környezetváltozó-betöltő implementációt elolvasnia, hogy kitalálja a házi stílust. Egyetlen importsor kivált egy teljes felderítést.
Ugyanez igaz a contractokra. Egy route-séma rövidebben írja le az interfészt, mint az implementáció, egyértelmű, és géppel ellenőrizhető. Minden promptnál jobb prompt, mert egyben teszt is.
Nagyobb szervezeteknél itt kezd érdekes lenni a költségoldal. A Platform engineering 2.0: An evolution for the AI era riport (Weave Intelligence, Broadcom megbízásából, 2026) számokkal is alátámasztja ezt: a fejlesztők két-tízszer több kódot generálnak, a token spend pedig új és jórészt láthatatlan költségkategóriaként érkezik, amire a legtöbb szervezetnek nincs eszköze. Ekkora méretben a tömörítés már nem ízlés kérdése, hanem megjelenik a számlán.
Mit érdemes kiemelni, és mit nem
Egy jól használható package-katalógust ritkán terveznek meg előre. A miénk egy ERP-monorepóból nőtt ki, ahol ugyanaz a kód rendre két helyen jelent meg, és a legtöbb jó katalógus hasonlóan indul.
A szétválasztás fontosabb bármilyen listánál. A generikus elemek mehetnek egyik rendszerből a másikba: a konfiguráció, a HTTP-routing, az auth-kliensek, a logging, a monitoring, a generált API-kliensek, az audit log hash-elése, valamint a közös lint-, formázási és fordítóbeállítások. A terméklogika viszont maradjon abban a repóban, amelyikhez tartozik: a domain value objectek, az üzleti számítások és egy adott termék platformmagja.
Ha túl sokat publikálunk, olyan frameworkünk lesz, amihez senki nem mer hozzányúlni. Ha semmit, négyszer írjuk meg az audithash-függvényt, az egyik verzió pedig finoman eltér a többitől.
A szabályunk szigorú: akkor emelünk ki valamit, ha generikus, egy dolgot csinál, és már most van valódi felhasználója a repóban. Előbb nem. Az a package, amelyet egy elképzelt második felhasználó kedvéért emelünk ki, az első felhasználó igényeihez fagyasztja be az API-ját.
A szabály csak akkor szabály, ha fut
Az általunk látott vállalati kódbázisokban bőven vannak standardok, de sok közülük csak leírt szövegként létezik. Egy wikioldal leírhatja, hogy „a domain-kód nem importálhatja az adatbázisréteget”; egy CI-check meg is akadályozza, hogy ilyen import productionbe kerüljön.
Ez a különbség eddig is számított. Ha agentek is dolgoznak a kódon, döntővé válik, mert egy agent készségesen betartja az összes dokumentált konvenciót, amit megmutattak neki, és megsérti azt az egyet, ami csak implicit volt. Nincs benne az az ösztön, ami szólna, hogy pont ez a kerülőút okozta a tavalyi incidenst.
Ezért írjuk le az invariánsokat, aztán tegyük futtathatóvá őket. Azokkal a szabályokkal érdemes kezdeni, amelyek megsértése drága, és gépileg könnyen észrevehető:
- egy modul csak azt teszi elérhetővé, ami a publikus belépési pontján szerepel, a modulok közötti mély importok CI-hibát okoznak
- egy modul pontosan egy adatbázissémát birtokol, a sémák közötti join és foreign key tilos
- minden írás egy use case-en keresztül megy, ami a tranzakciót birtokolja
- minden eventet egy outboxon keresztül publikálunk, soha nem közvetlen brokerhívással a domain-kódból
- a rendszeridőt injektáljuk, az infrastruktúrán kívül soha nem olvassuk közvetlenül
- a domain-mennyiségeknek, például a pénznek, saját típusuk van, soha nem puszta számok
- a sémák a forrás, a generált contractok csak olvashatók
- generált kódot soha nem szerkesztünk kézzel
Mindegyikhez kell kikényszerítés: architektúracheck, lintszabály, típushatár vagy teszt. A teljes csomag egy paranccsal fusson minden pull requestre, így az ember és az agent ugyanazon a kapun megy át. Az ERP-platformunkban 22 ilyen invariáns van, és 18 architektúracheck ellenőrzi őket minden pull requestnél. Másokat a típusok, a package-határok és a tesztek kényszerítenek ki. Azt a néhányat, amelyet semmilyen eszköz nem tud kifejezni, például hogy mikor kell egy változáshoz döntési dokumentum, a reviewer ellenőrzi, új check pedig csak akkor készül, ha a meglévő eszközök egyike sem tudja kikényszeríteni a szabályt.
A kikényszerítéstől lesz a style guide olyan, amit egy autonóm szereplő is követni tud. Ha a változás nem mergelhető a szabály betartása nélkül, kevésbé számít, hogy az agent megjegyezte-e a leírást.
Vizuál: mire van szüksége egy agentnek, és honnan jön
flowchart TD
A[Feladatleírás] --> Z[Agentkontextus]
B[Közös package-ek] --> Z
C[API- és event contractok] --> Z
D[Architekturális invariánsok] --> Z
E[Repó konvenciós fájl] --> Z
Z --> F[Generált változás]
F --> G[Architektúracheckek]
F --> H[Típusellenőrzés és contractvalidáció]
F --> I[Tesztek]
G --> J{Átmegy a kapun}
H --> J
I --> J
J -->|nem| Z
J -->|igen| K[Pull request emberi review-ra]
Ne csak az eredményt, a munkát is kapukkal vegyük körül
A CI az eredményt ellenőrzi. Ha agenteket felügyelet nélkül futtatunk, magát a munkát is kapukkal kell körülvenni, a kód megszületése előtt és után is. A saját software factory-nk egy olyan mintát követ, amely nem függ semmilyen konkrét eszköztől.
Az első kapu még azelőtt áll, hogy bármelyik modell elindulna. Feladat csak céllal és elfogadási kritériumokkal kerülhet a sorba, és ezeket az írja meg, aki a változást kéri. Ezek az ember saját ellenőrzési céljai, és minden későbbi lépést hozzájuk mérünk.
Ezután bontsuk lépésekre a feladatot, és minden lépés friss kontextusban fusson, amely csak az előző lépés tömörített eredményét kapja meg:
- Research: olvassuk be a célrepót, és készítsünk térképet az érintett kódról, minden állítás mellett fájl- és sorhivatkozással.
- Plan: a researchből számozott fázisú terv készül, fázisonként az érintett fájlokkal és egy ellenőrző paranccsal, és minden elfogadási kritériumhoz tartozik egy fázis, amely ellenőrzi.
- Implement: nem indul el, amíg egy ember jóvá nem hagyja a tervet. Legenerálja a változást, pull requestet nyit, és megvárja a repó saját CI-át. Ha az elbukik, egy korlátozott javítási kísérletet kap.
- Review: egy friss kontextus csak az elfogadási kritériumokat, a jóváhagyott tervet, a keletkezett diffet és a CI-eredményét látja, és egyetlen kérdésre válaszol: azt szállítja ez a diff, amiben megállapodtunk? Ha a terv és a kritériumok ellentmondanak egymásnak, a kritériumok döntenek.
A reviewer soha ne lássa a kódot előállító gondolatmenetet, mert akkor az meggyőzheti. A szándékot hasonlítja az eredményhez, vagyis azt a munkát végzi, amit egy jó emberi reviewer is, és amiben a változás szerzője általában a leggyengébb. A verdikt a megállapításokból következzen, ne a modell összefoglalójából: egy nem teljesült kritérium changes requested-et jelent, még akkor is, ha a reviewer „összességében rendben” minősítést adott. A bukó vagy hiányzó CI-eredmény ugyanezt a verdiktet vonja maga után, mert egy modell véleménye nem írhat felül egy piros checket. A verdiktet olyan status checkként publikáljuk, amelyet a repó kötelezővé tehet, így egy elutasított változást nem lehet véletlenül mergelni.
Egy feladathoz holdouthalmaz is tartozhat: olyan ellenőrzési forgatókönyvek, amelyeket csak a reviewer lát. A tervező és az implementáló lépés soha nem kapja meg őket, így a generátor nem tudja az értékelési szempontokhoz igazítani a munkáját, a reviewernek pedig mindegyikről bizonyítékkal alátámasztva kell megmondania, hogy teljesül-e.
A lépések köré tegyünk guardraileket, amelyek nélkül a felügyelet nélküli futás nem lenne biztonságos:
- Emberi tervjóváhagyás: implementáció nélküle nem indul. Ez az az egy kapu, amit érdemes kézben tartani.
- Premise check: ha a default branch továbblépett a research óta, implementálás előtt ellenőrizzük, hogy a probléma még létezik-e, hiszen a terv régebbi kódra készült.
- Stop the line: amíg a célrepó default branchén bukó checkek vannak, nincs implementáció. A research és a tervezés engedélyezett marad, mert így értjük meg, mi romlott el.
- Költségplafon: minden futás a futásonkénti limit, a feladat budgetje és a projekt plafonja közül a legszűkebbet kapja, plusz egy időkorlátot. Az a futás, amelynek elfogyott a budgetje, az első modellhívás előtt elbukik.
- Watchdog: álljon le az új munka, ha ugyanaz a feladat újra és újra elindul, vagy a költés haladás nélkül nő. A futásonkénti limitek nem látják a több futáson átívelő mintát.
- A visszafordíthatatlan változás draft marad: ha egy változás nehezen vonható vissza, vagy kézi lépést igényel, a pull request draft marad, amíg egy ember fel nem engedi.
- Egyetlen egresspont: minden modellhívás egy proxyn megy át. Egyik lépés sem beszél közvetlenül a szolgáltatóval.
A feladat, a budgetje, az eredménye és a review verdiktje kerüljön egy helyre, oda, ahol az emberek amúgy is követik a munkájukat. Egy agent munkájának nyoma csak akkor ér valamit, ha valaki el is olvassa.
Ezt az eszközt is ugyanazokból az elemekből építsük, amelyeket kikényszerít. A miénk ugyanazokra a közös package-ekre és contractokra épül, mint azok a rendszerek, amelyeken az agentjei dolgoznak, így minden standardnak ő az első felhasználója. Egy kényelmetlen package-et azok veszik észre, akik nap mint nap használják, és az építőelemek minden javítása mindkét oldalt javítja.
Vizuál: a futási pipeline és a kapui
flowchart TD
A[Feladat céllal, elfogadási kritériumokkal és budgettel] --> B[Research: kódtérkép fájl- és sorhivatkozásokkal]
B --> C[Plan: elfogadási kritériumokhoz rendelt fázisok]
C --> D{Ember jóváhagyja a tervet}
D -->|nem| C
D -->|igen| P{A probléma még létezik az aktuális branchen}
P -->|nem| X[Feladat lezárva: a probléma már nem áll fenn]
P -->|igen| E{Default branch zöld}
E -->|nem| F[Blokkolva: stop the line]
E -->|igen| G[Implement: pull request, CI, egy javítási kísérlet]
G --> H[Review: kritériumok, terv, diff és CI-eredmény, friss kontextus]
H --> I{Nincs nyitott megállapítás}
I -->|nem| J[Changes requested, vissza a sorba]
I -->|igen| K[Emberi review és merge]
A biztonságnak a platformba kell költöznie
AI-workloadoknál a szivárgást tiltó utasítás gyengébb, mint egy olyan architektúra, amelyben a modell soha nem kapja meg a védett adatot. Az utasítás betartása együttműködést feltételez, az architektúra nem.
A minta egy határfolyamat a rendszereink és a modellszolgáltató között. Csak ez a folyamat ismeri a szolgáltatói kulcsot, és csak ez hívhat kifelé. Determinisztikusan ismeri fel a személyes adatokat: adószámot, személyi és TAJ-azonosítót, bankszámla- és kártyaszámot, ellenőrzőösszeggel ott, ahol a formátum definiál ilyet, telefonszámot, e-mail- és postai címet, neveket. Minden talált értéket a futás idejére visszafordítható tokenre cserél, a válasz útján visszaállítja az eredetit, és minden áthaladást utólag nem módosítható audit logba ír. A felismerés minőségét CI-kapu kényszeríti ki: egy címkézett korpuszon teljesíteni kell a recall és a precision küszöbét, mielőtt a határfolyamat élesbe mehet.
Ezt hívja a platform engineering-riport „security shifts down”-nak. A shift-left előbbre hozta a biztonságot az időtengelyen, és több eszközt meg több felelősséget adott a fejlesztőnek. A shift-down a platformba építi be, ahol a fejlesztő nem látja, és egy prompttal sem kerülhető meg.
A riport néven nevezi az új támadási felületeket is: shadow AI sprawl, prompt injection, model poisoning és inference-adatszivárgás, amelyek közül egyet sem talál meg SAST- vagy DAST-eszköz egy élő inference streamben. Egy determinisztikus, auditált határ az utolsót azon a rétegen kezeli, amelyik erre a legalkalmasabb.
A mérettel együtt nő a platform jelentősége
Mindez elsőre egy kis csapat rendezett setupjának tűnhet. Nagy szervezetben azonban még fontosabb az építőelem-kérdés, mert minden inkonzisztencia több felhasználót érint.
Az eltérések a felhasználók számával együtt drágulnak. Ha 10 csapat külön oldja meg a konfigurációt, 10 helyen kell hozzányúlni a következő migrációnál, a következő CVE-nél és a következő compliance-követelménynél.
Az agentek ráadásul a felhasználók egy új típusát jelentik. A riport ebben egyértelmű: az AI-agentek több mint egy évtized óta az első új platformpersona, és API-kat használnak, nem felületeket. Verziózott, dokumentált API-k, scope-olt jogosultságok, nem emberi identitás, audit logging, budgetkontroll és egresskontroll kell nekik. Ezek mind platformképességek, nem pedig fejlesztői preferenciák. Ha a platformunk nem tudja kifejezni, hogy „ez a szereplő ezeket teheti, legfeljebb ennyiért, és itt a nyoma”, akkor nem tudunk biztonságosan agenteket futtatni, bármilyen jó is a modell.
A bounded autonomy-nak konkrét összetevői vannak. Azok a csapatok, amelyek a gyakorlatba ültetik, 7 területet különítenek el: identitás, kontextus, képesség, végrehajtás, kiértékelés, biztonság és observability. A fenti kapuk pontosan erre a listára képezhetők le. A tervjóváhagyás és a stop the line képességkorlát. Az elfogadási kritériumok, a review-lépés és a holdoutforgatókönyvek a kiértékelés. A határfolyamat a biztonság. A futási logok, az artifactok és az audit log az observability. A költségplafon és a watchdog a végrehajtást korlátozza. Semmi nem modellspecifikus benne, így túléli a következő modellt.
Közben a költség is kiemelt mutatóvá válik. Iparági átlagban nagyjából 35% a cloudpazarlás, még mielőtt az AI-infrastruktúra rárakódna, az agentic fejlesztésből származó token spend pedig olyan kategória, amire a legtöbb szervezetnek egyáltalán nincs eszköze. Egy futásonkénti költségplafon, amely menet közben leállítja a futást, kis fejlesztés, mégis ez választja el a kísérletet a költségvetési incidenstől.
A modularitás véd a gyors változás ellen. A CNCF-ökoszisztéma a 2018-as nagyjából 50 projektről mára több mint 200-ra nőtt, a modellképességek és agentminták pedig ennél is gyorsabban cserélődnek. Most senki nem a véglegesen helyes eszközt választja. Annyit tehetünk, hogy egy eszköz cseréje ne gyűrűzzön végig a rendszeren, ehhez pedig ugyanaz a moduláris, API-first, verziózott, contractalapú fegyelem kell, amitől a package-eket egyáltalán érdemes kiemelni.
Aztán ott a golden path problémája, ahol az agentek felborítják a korábbi számítást. A standardizált sablonok, amik korábban a deployok többségét kiszolgálták, elkezdik blokkolni azt a csapatot, amelyik valami újat csinál, és minden kivétel visszafut a platformcsapathoz. Amikor a scaffolding, a contract-generálás és a migrációs munka olcsóvá válik, a platformcsapat több utat engedhet meg magának ahelyett, hogy egyet védene. Egy golden pathből a bővítés költsége csinál ketrecet.
Régi gyakorlatok, nagyobb érték
Minden gyakorlat, amitől a szoftver az AI előtt biztonságosan változtatható volt, ma is ugyanazt a munkát végzi. A többségük többet ér, mint korábban, mert a szűk keresztmetszet elmozdult.
A contract-first tervezés korábban dokumentáció és koordinációs eszköz volt. Ma egyben prompt és kapu is: megmondja az agentnek, mit építsen, és megmondja a CI-nak, hogy azt építette-e. A spec-first jó ötlet volt akkor is, amikor a contractokat csak emberek használták. Ma, amikor már nem csak ők, szinte kötelező.
A tesztek szerepe is megváltozott. Egy agent újra és újra lefuttatja a test suite-ot, így az a generálás fitnessfüggvénye lesz, nem csak utólagos védőháló. Egy gyenge suite ma már nem csak hibákat enged át: azt is megtanítja a ciklusnak, hogy a hibás kód elfogadható.
A code review lett a szűk keresztmetszet. Ha az írás olcsó, az ellenőrzés a szűkös erőforrás, és az is megváltozott, mire való: kevesebb elgépelésvadászat, több „azt csinálja ez a diff, amiben megegyeztünk, és csak azt”.
A kicsi, egy témára szorítkozó változások most többet számítanak, nem kevesebbet. Amikor a generálás olcsó, csábító nagy diffeket szállítani. Ne tegyük. A review a korlát, és a review költsége gyorsabban nő, mint a diff mérete.
A CI marad a kikényszerítő réteg. Az agentek azt követik, ami ki van kényszerítve, nem azt, ami dokumentálva van. Előbb-utóbb mindenki más is így tesz, az agenteknél ez csak azonnal látszik.
Az observability gyorsabban megtérül. Ha több kód megy ki gyorsabban, több előre nem látott probléma jut el a productionig. A strukturált loggingból, a tracingből és a metrikákból derül ki, mit szállított valójában a felgyorsult pipeline.
A döntési dokumentumok fedik le azt az egyetlen dolgot, amit nem lehet a forrásból újragenerálni: a miértet. Egy ADR, ami egy trade-offot magyaráz, soronként többet ér szinte bárminél, amit írunk, mert ez az a kontextus, amitől a következő változás helyes lesz, nem csak hihető.
A sort a trunk tisztán tartása zárja. A stop the line régi gyártási ötlet, és ugyanazért működik, amiért mindig: törött alapra építeni sokszorozza a kárt. Az automatizálás gyorsabban sokszorozza.
A magyarázat egyszerű. Az AI megváltoztatta egy megoldásjelölt előállításának költségét, és nagyjából ott hagyta az ellenőrzés költségét, ahol volt. Ezért minden gyakorlat, ami az ellenőrzést javítja, felértékelődik. Minden gyakorlat, ami csak az előállítás sebességét javította, leértékelődik.
Máshová kerül a mérnöki munka
Tapasztalatunk szerint kevesebb idő megy el implementációk gépelésére, és több jut az interfészek specifikálására, invariánsok definiálására, scaffoldok építésére, valamint a szándék és az eredmény összevetésére. A senior mérnöki munka a rendszertervezés felé tolódik.
A dokumentációból futtatható kontextus lesz. Egy konvenciós fájl a repó gyökerében, path-scoped instrukciós fájlok, feladatra triggerelt eljárások. Mindegyiket minden futás beolvassa, ezért ha hibásak, kijavítják őket, így naprakészek maradnak. Ez az első dokumentáció, aminek működő visszacsatolása van.
Megjelenik a nem funkcionális követelmények egy új csoportja is: egresskontroll, spend cap, nem emberi identitás, akcióaudit és tervjóváhagyás. Öt éve ezek egyike sem került backlogra. Ma előfeltételei annak, hogy agenteket futtassunk egy éles kódbázison, és a platformcsapathoz tartoznak.
Hol romlik el
A megközelítés karbantartást igényel, és kiszámítható módokon romlik el:
- a package-eket felhasználók nélkül emelik ki, és egyetlen use case köré fagy be az API
- a „közös” pass-through wrapperek és homályos utilmodulok szemétlerakója lesz
- a szabályok csak szövegként léteznek, és soha nem kényszerítik ki őket
- a tervjóváhagyás gumibélyegzővé silányul, ami pont az egyetlen érdemi emberi kaput számolja fel
- ugyanaz a rendszer írja és hagyja jóvá a változást
- az autonómia előbb bővül, mint ahogy a budget, az audit és az egresskontroll elkészül
- az elemkatalógus gyorsabban nő, mint a karbantartási hajlandóság
A javítás mindegyik esetben ugyanaz, mint az agentek előtt volt: legyünk szelektívek, csak kevés építőelemet tartsunk, és azokat használjuk is, tegyük futtathatóvá a szabályokat, és hagyjunk embert azokon a döntési pontokon, ahol a döntést nem tudjuk olcsón visszacsinálni.
Előbb építsünk pályát, aztán növeljük a sebességet
Az AI-támogatott fejlesztést az alapján érdemes megítélni, hogy mire épül a generált kód, nem az alapján, hogy mennyit tud írni a modell. Erős package-ek, explicit contractok, kikényszerített invariánsok és megbízható kapuk mellett a változás illeszkedik a meglévő rendszerhez. A csak fejekben élő standardok hihetőnek tűnő eltéréseket termelnek, amelyeket gyakran csak productionben veszünk észre.
Ha most kezdjük, a sorrend fontosabb az eszközöknél:
- Írjuk le az invariánsokat, amelyekre már most is támaszkodunk, és a legdrágább kettőt-hármat futtassuk CI-ban.
- Csak azokat a közös elemeket emeljük ki, amelyeknek már több felhasználójuk van a kódbázisban.
- Minden olyan határon, amelyhez agentek nyúlnak, a contract előzze meg az implementációt.
- Minden feladathoz követeljünk meg elfogadási kritériumokat, és mielőtt több autonómiát adunk az agenteknek, vezessük be a tervjóváhagyást, a kritériumokhoz mért review-t és a költségplafont.
Az eszközök sokat változtak. A contract-first tervezés, az egyértelműen bukó tesztek, a szándékhoz mért review, a kicsi diffek, a kikényszerített CI, az observability és a leírt döntések nem. Ma ezek döntik el, hogy az AI a hasznos munkát vagy csak a rendszer szétcsúszását gyorsítja fel.
Ha nem világos, ezek közül mi hiányzik egy meglévő rendszerből, és mivel érdemes kezdeni, erre ad írásos választ a kéthetes architektúrareview: rangsorolt, 90 napos roadmapet.