I den første artikkelen i denne serien forklarte vi hvordan du klargjør en datamaskin for vibe coding. Vi installerte Linux, konfigurerte Codex og Antigravity, koblet til GitHub og publiserte vår første applikasjon ved hjelp av Railway.
Vi klarte å utvikle en liten applikasjon med kunstig intelligens uten å skrive koden selv.
Men det var en prøve. Vi ba Codex programmere, kontrollerte at det virket og brukte deretter Antigravity til å gjennomgå resultatet. Det fungerer som en start, men hvis vi vil jobbe med virkelige prosjekter, trenger vi bedre organisering.
Hva skjer når vi har flere funksjoner vi ennå ikke har laget? Hvordan hindrer vi KI-en i å endre filer den ikke skal røre? Hvem sjekker at en løsning er godt planlagt før den programmeres? Og hvordan vet vi at det vi publiserer, er nøyaktig det vi har kontrollert?
For å svare på disse spørsmålene har jeg gradvis bygget opp min egen arbeidsmetode. Jeg har ikke funnet opp noe revolusjonerende: Jeg har tilpasset vanlige metoder fra profesjonell programvareutvikling til et miljø der KI-agenter gjør en stor del av arbeidet.
Jeg forklarer hvordan du organiserer og bruker metoden, steg for steg. Kanskje kan det hjelpe deg å gjøre det samme.
Slik organiserer jeg arbeidet med KI-agenter
Ideen er enkel: én kunstig intelligens utvikler, og en annen reviderer arbeidet, mens vi beholder kontrollen over de viktige beslutningene.
Selv bruker jeg fem grunnleggende verktøy:
| Verktøy | Funksjon |
| Codex | Analyserer, planlegger, programmerer, tester og dokumenterer. |
| Antigravity | Reviderer planen og koden uavhengig. |
| GitHub | Lagrer koden, versjonene og Pull Requests. |
| Linear | Organiserer oppgaver, tester, revisjoner og statuser. |
| Notion | Tar vare på krav, beslutninger og prosjekthistorikk. |
I tillegg bruker jeg et par andre: Local WP ved utvikling med WordPress og Convex eller Supabase dersom det er en nettapplikasjon som trenger en database.
Notion er valgfritt, men jeg anbefaler det for mellomstore prosjekter. Vi skal se hvorfor senere.
Vi må heller ikke bruke akkurat disse applikasjonene. Vi kan for eksempel erstatte Codex med Claude Code eller bruke en annen agent som revisor. Det viktigste er å holde ansvarsområdene adskilt.
Hele prosessen er:
- Krav.
- Teknisk plan.
- Første revisjon.
- Utvikling og testing.
- Andre revisjon.
- GitHub.
- Utrulling.
- Verifisering.
Trinn 2 (Codex) og 3 (Antigravity) kan gjentas flere ganger: Hvis Antigravity finner et problem, retter Codex det, og vi gjentar gjennomgangen. Tanken er å gå frem gjennom sykluser med arbeid og kontroll, uten å gå videre til neste fase så lenge vesentlige problemer er uløst.
I min arbeidsmetode er to revisjoner obligatoriske, men hvor grundige de er, avhenger av hvor kompleks utviklingen er. Den første vurderer hva vi skal gjøre, og den andre kontrollerer hva vi faktisk har gjort.
Og én viktig ting: et GO fra revisoren er ikke det samme som tillatelse til å publisere. Den beslutningen er fremdeles vår.
Trinn 1. Klargjør arbeidsmiljøet med Codex
Vi tar utgangspunkt i datamaskinen vi konfigurerte i den første veiledningen. Codex, Antigravity og GitHub fungerer allerede, så vi skal ikke gjenta installasjonene.
Vi åpner en terminal i prosjektmappen og starter Codex:
cd ~/Proyectos/mi-proyecto
codex
Nå kommer noe av det jeg liker best ved å jobbe med agenter: Vi trenger ikke konfigurere hele prosjektstrukturen manuelt. Vi kan be Codex gjøre det.
Prompt 1. Konfigurer arbeidsmiljøet
Jeg vil klargjøre dette prosjektet for en KI-overvåket utviklingsprosess.
Du skal fungere som analytiker og utvikler. Antigravity skal være den uavhengige revisoren. Vi bruker GitHub til koden, Linear til oppgavene og eventuelt Notion til dokumentasjonen.
Undersøk prosjektet og kontroller tilgjengelige tilkoblinger. Foreslå faste instruksjoner, nødvendig minimumsdokumentasjon, tillatelsesregler og en prosess med to obligatoriske revisjoner: av den tekniske planen og av koden.
Implementeringer, viktige Git-operasjoner og utrullinger krever menneskelig godkjenning. Oppgaver lukkes først etter verifisering i produksjon.
Presenter først en konfigurasjonsplan. Ikke opprett filer eller endre tjenester før du har fått godkjenning.
Codex bør analysere hva vi har tilgjengelig, og fortelle oss hva som mangler.
Vanligvis må vi utføre enkelte operasjoner selv:
- Logge inn i Linear eller Notion.
- Godkjenne en integrasjon.
- Godta tillatelser eller opprette en tilkobling som krever autentisering i nettleseren.
SVÆRT VIKTIG: Vi må ikke gi fra oss passord eller token ved å lime dem rett inn i chatten.
Vi bruker autentiseringsmekanismene til hver tjeneste (Github og Claudflare har slike) og gir bare nødvendige tillatelser.
Når konfigurasjonen er godkjent, kan Codex klargjøre filene og organisere verktøyene.
Men vi skal selvsagt kontrollere at det faktisk er gjort, så vi ber den verifisere det. En agent kan ikke opprette en tilkobling til Linear hvis miljøet mangler en kompatibel integrasjon.
Trinn 2. Organiser dokumentasjonen uten å fylle kodearkivet med filer
For å arbeide med agenter trenger vi noe samtalene alene ikke gir oss: prosjektets operative hukommelse.
Tenk deg at vi har utviklet i flere uker og starter en ny Codex-økt. Vi vil ikke forklare hele arkitekturen på nytt, hvilke verktøy vi bruker, hvilke filer den kan endre, og hvordan utrullingen fungerer.
For å unngå dette bruker vi to grunnleggende dokumenter i kodearkivet:
- AGENTS.md: faste instruksjoner til Codex, grenser for hva den kan gjøre, og utviklingsregler.
- PROJECT.md: beskrivelse av prosjektet, grunnleggende arkitektur, miljøer og lenker til dokumentasjonen.
Codex kan lage dem ut fra kravene våre.
Og hva trenger vi Notion til?
I små prosjekter kan Markdown-filer være nok til å dokumentere endringer og beslutninger. Men når vi samler opp funksjoner, beslutninger, krav og arkitekturendringer, ender vi med altfor mange dokumenter i kodearkivet.
Derfor anbefaler jeg Notion for mellomstore prosjekter.
Der lagrer vi først og fremst PRD (Product Requirements Document), tekniske beslutninger og prosjekthistorikk. Linear inneholder oppgavene, statusene deres, revisjonene og testene. GitHub tar vare på koden.
Det interessante er at Notion og Linear først og fremst skal brukes av agentene selv. Codex skriver og oppdaterer dokumentasjon, sjekker kravene før programmeringen og registrerer resultatene. Antigravity må kunne lese denne informasjonen for å revidere.
Vi trenger ikke skrive side opp og side ned med dokumentasjon manuelt. Vårt ansvar er å kontrollere at kravene og de viktige beslutningene gjenspeiler det vi ønsker.
Trinn 3. Definer hva vi vil utvikle
Vi bruker et ekte utviklingsarbeid jeg har gjort for dette nettstedet, som eksempel.
På nettstedet mitt viste taggsidene innleggene i kronologisk rekkefølge. Jeg ville forbedre dem slik at de fremhevet det mest interessante innholdet uten at den vanlige listen forsvant.
Dette er den typen behov vi kan beskrive for Codex med vanlig språk, vel vitende om at en slik forespørsel etterlater mange åpne spørsmål.
- Hvor mange artikler skal vi fremheve?
- Hvordan avgjør vi hvilke som er relevante?
- Hva skjer med resten?
- Skal det fungere på alle sidene?
- Hvilke elementer vil vi ikke endre?
Før vi analyserer noe som helst, bør vi avklare dette.
Prompt 2. Forbered krav og teknisk plan
Jeg vil utvikle denne funksjonen: [BESKRIVELSE].
Les prosjektets instruksjoner og dokumentasjon. Gjør behovet om til verifiserbare krav og akseptansekriterier. Opprett eller oppdater PRD og organiser nødvendige oppgaver i Linear.
Undersøk den eksisterende koden og foreslå den enkleste løsningen som oppfyller kravene. Identifiser berørte filer, risikoer, alternativer og tester.
Ikke programmer ennå. Spør meg om funksjonelle beslutninger du ikke kan ta ut fra tilgjengelig informasjon, og klargjør planen for uavhengig revisjon.
Dette er en av de viktigste forskjellene fra bare å be en KI programmere noe.
Codex kan hjelpe oss å gjøre en idé om til en spesifikasjon. Vi bestemmer om spesifikasjonen dekker behovet vårt.
Når det gjelder taggene, for eksempel, kunne ikke akseptansekriteriet bare være at fremhevede artikler dukket opp. Vi måtte også bevare navigasjonen, unngå uønskede duplikater og sørge for at de ulike sidene fungerte riktig.
Når opplegget er godkjent, registrerer Codex det og utarbeider den tekniske planen.
Vi har fortsatt ikke skrevet en eneste linje kode.
Design av brukergrensesnittet
I dette tilfellet visste jeg nøyaktig hvordan jeg ville ha designet, så jeg ba ikke om visuelle forslag. Men ved andre anledninger ville jeg bedt om dem her, slik at agenten kunne ta hensyn til dem før den foreslo en teknisk løsning.
Hvis du vet hvordan det skal være, forklarer du det selvsagt bare. Og hvis funksjonen gjelder backend og ikke frontend, trenger du heller ingen mockuper.
Trinn 4. Første revisjon: Kontroller planen med Antigravity
Nå kommer den andre agenten vår inn i bildet.
Vi åpner en ny terminal i samme prosjektmappe og kjører:
agy
I min nåværende prosess kjøres Antigravity manuelt. Vi lar ikke Codex starte den automatisk og fortsette uten at vi har gjennomgått resultatet.
Vi vil at den skal være en uavhengig revisor, ikke enda en programmerer som begynner å endre filer.
Prompt 3. Revider den tekniske planen
Oppfør deg utelukkende som uavhengig teknisk revisor.
Gjennomgå prosjektinstruksjonene, kravene og planen Codex har foreslått. Vurder om løsningen er gjennomførbar, tilstrekkelig enkel, sikker og kompatibel med eksisterende funksjonalitet.
Kontroller risikoene, mulige regresjoner og om de planlagte testene er gode nok.
Gi en begrunnet vurdering: GO, betinget GO eller NO-GO. Oppgi uttrykkelig dersom du mangler tilstrekkelig dokumentasjon.
Identifiser konkrete problemer og nødvendige rettelser. Ikke endre noen filer.
Hvorfor revidere før utviklingen?
Fordi en løsning kan være perfekt programmert og likevel være en dårlig løsning.
Kanskje den innfører en unødvendig avhengighet, dupliserer eksisterende informasjon, kjører for mange spørringer eller gjør fremtidig vedlikehold vanskeligere.
For taggene var det for eksempel ikke nok å lage et system for fremhevede artikler. Vi måtte også vurdere hvordan rekkefølgen skulle beregnes uten å kjøre trege operasjoner hver gang noen besøkte en side.
Hvis revisoren finner problemer, sender vi rapporten til Codex. Den reviderer planen, og vi gjennomgår den igjen ved behov.
Vi starter ikke programmeringen før vi har en godkjent plan og menneskelig tillatelse til å implementere den.
Trinn 5. Codex utvikler og gjennomfører testene
Med godkjent plan begynner implementeringen.
Codex arbeider i en gren av kodearkivet. Har du lest den første delen, kjenner du Git og GitHub, så vi trenger ikke gå gjennom hvordan de brukes igjen.
Det nye er at vi ikke programmerer direkte på den stabile versjonen av prosjektet. Vi klargjør endringene separat slik at de kan gjennomgås før de slås sammen.
Prompt 4. Implementer funksjonen
Jeg godkjenner utvikling i tråd med den godkjente og reviderte planen for [LINEAR-OPPGAVE].
Arbeid i en egen gren, og begrens endringene til det godkjente omfanget.
Implementer løsningen, kjør relevante tester og sjekk mulige regresjoner. Dokumenter resultatene i Linear.
Klargjør hele diffen, identifiser de endrede filene og lever dokumentasjonen som trengs til den andre revisjonen.
Ikke utfør merge eller utrulling. Stopp når utviklingen er klar for gjennomgang.
Codex kan endre filer, kjøre tester og rette feil innenfor omfanget vi har godkjent.
Men vi må passe på én ting: at KI-en påstår at en funksjon virker, betyr ikke at det er verifisert.
Vi trenger dokumentasjon. Avhengig av prosjektet kan det være automatiserte tester, kjøreresultater, funksjonelle kontroller eller en kombinasjon.
Vi må også skille mellom det Codex faktisk har testet, og det den ennå ikke kan verifisere.
Tilbake til eksempelet vårt: Det holder ikke å kontrollere at tre fremhevede artikler vises. Vi må se hva som skjer når færre artikler er tilgjengelige, når man bytter side, eller når innhold mangler forventede data, for eksempel en artikkel som ikke er oversatt til ett av språkene.
Agenten må dokumentere disse kontrollene og eventuelle begrensninger.
Trinn 6. Andre revisjon: Gjennomgå den faktiske koden
Funksjonen er ferdig utviklet, men vi skal ennå ikke publisere den.
Vi går tilbake til Antigravity og ber den gjennomgå den endrede koden, ikke bare rapporten Codex har utarbeidet.
Prompt 5. Revider implementeringen
Oppfør deg som uavhengig teknisk revisor for [LINEAR-OPPGAVE].
Gjennomgå hele diffen, den godkjente planen, kravene og testdokumentasjonen.
Se etter funksjonelle feil, sikkerhetsproblemer, regresjoner, unødvendig kompleksitet og endringer utenfor det godkjente omfanget.
Gi en begrunnet vurdering og angi funn etter fil og plassering der det er mulig.
Registrer SHA-256-hashen til den reviderte diffen, slik at nøyaktig hvilken versjon som ble gjennomgått, kan identifiseres.
Ikke endre filer, og ikke godkjenn commits, merges eller utrullinger.
To detaljer er viktige.
For det første må Antigravity kunne lese de samme reglene og kravene som Codex brukte. Ellers risikerer den å godkjenne en teknisk korrekt løsning som ikke oppfyller det vi ba om.
For det andre må vi bevare dokumentasjon av hele det reviderte endringssettet. Dermed kan vi identifisere den nøyaktige versjonen som fikk GO, og oppdage om koden ble endret etterpå. Hashen må beregnes på en reproduserbar måte av det samme innholdet.
I mitt tilfelle lagrer vi alt dette i Linear, knyttet til den aktuelle oppgaven.
Hvis Antigravity finner feil, går vi tilbake til Codex, ber om rettelser og gjentar revisjonen.
To agenter kan ta feil selv om de er enige. Derfor er revisjonene ekstra kontroller, ikke absolutte garantier. Og derfor kan vi eventuelt legge til en tredje.
Trinn 7. Integrer endringene i GitHub
Når vi har fått GO fra revisjonen, kan vi klargjøre integreringen. Den vanlige prosessen er:
Gren > Commit > Push > Pull Request > Merge.
Vi trenger ikke kjøre disse kommandoene manuelt. Codex kan gjøre det, men vi må forstå hva vi godkjenner.
Med en Pull Request kan vi se hvilke endringer vi vil innlemme i hovedgrenen, med hvilke tester og med hvilke anbefalinger fra revisoren.
Vi bør også kontrollere at versjonen som skal integreres, fortsatt er den som ble revidert. Hvis vi endrer koden etter å ha fått GO, kan vurderingen slutte å gjelde.
Jeg foretrekker uttrykkelig godkjenning av viktige operasjoner. Vi kan samle noen av dem når omfanget er helt tydelig, men vi skal ikke gi ubegrenset frihet til å integrere og publisere.
At revisoren mener utviklingen er korrekt, er én ting. At vi bestemmer oss for å innlemme den, er noe annet.
Her kan en tredje KI komme inn: vi kan legge til en andre spesialisert revisor, for eksempel CodeRabbit.
I motsetning til Antigravity, som vi bruker til lokal gjennomgang av planen og koden, kan CodeRabbit automatisk analysere Pull Requests på GitHub før de slås sammen.
Det er en interessant ekstra kontroll for viktige prosjekter, selv om den ikke er nødvendig og koster penger, om enn lite sammenlignet med nytten. Foreløpig foretrekker jeg å beholde de to manuelle revisjonene og vurdere en tredje når dette blir større.
Trinn 8. Rull ut og kontroller funksjonen i produksjon
Dette trinnet avhenger mye av hvor prosjektet er driftet.
I den første delen brukte vi Railway. Vi kunne også publisert med GitHub Actions, verktøy hos webhotellet vårt eller et annet utrullingssystem.
Særegenhetene ved WordPress, LocalWP og Webempresa skal vi se på i en annen artikkel.
Her er det én generell regel som gjelder: en vellykket utrulling betyr ikke at funksjonen fungerer som den skal.
Når endringen er publisert, må vi kontrollere den faktiske applikasjonen.
I vårt eksempel betyr det å besøke de offentlige sidene, sjekke de fremhevede artiklene, navigere gjennom listen og forsikre oss om at vi ikke har endret andre funksjoner.
Vi må også bekrefte at den nye versjonen faktisk vises. Noen ganger publiseres koden riktig, men en cache viser fortsatt gammelt innhold, slik jeg opplevde med WP Rocket.
Ved viktige utviklingsprosjekter må vi ha en plan for å gjenopprette den stabile versjonen dersom noe går galt.
Først etter disse kontrollene kan vi si at funksjonen er ferdig.
Trinn 9. Lukk oppgaven og forbered neste utviklingsrunde
Når resultatet er verifisert, ber vi Codex oppdatere Linear og prosjektdokumentasjonen.
Den skal registrere hva som er utviklet, hvilken versjon som er publisert, hvilke tester vi har gjennomført, og om det gjenstår problemer.
Oppgaven markeres som fullført etter verifisering i produksjon, ikke når Codex er ferdig med å programmere, eller når Antigravity gir GO.
Denne dokumentasjonen har også en annen fordel: vi kan avslutte økten og starte en ny uten å miste sammenhengen.
Jeg anbefaler faktisk å gjøre dette når vi begynner med en annen funksjon. Agentene kan hente regler, krav og beslutninger fra prosjektdokumentene i stedet for å være avhengige av endeløse samtaler.
Etter hvert kan vi automatisere deler av samordningen mellom Codex og Antigravity, men foreløpig foretrekker jeg å gjøre det manuelt, kontrollere at prosessen virker og bygge opp tillit før jeg fjerner tilsynstrinn.
Er det verdt å jobbe slik med all utvikling?
Nei.
For en rask prøve eller tjue minutters eksperimentering er dokumentasjon, to revisjoner og en publiseringsprosess overdrevent.
Men når vi utvikler et ekte nettsted, en applikasjon for en kunde eller et prosjekt som skal vedlikeholdes i månedsvis, gir det ekstra arbeidet full mening.
Fordelen med denne prosessen er ikke at den fjerner feil eller erstatter programmeringskunnskaper, men at vi kan jobbe mer strukturert, ta vare på beslutningene og oppdage problemer før de når brukerne. Vi minimerer feilene som preger den første fasen med vibe coding.
Og fordi agentene utfører mesteparten av det operative arbeidet, kan vi konsentrere oss om det viktige: bestemme hva vi vil ha, godkjenne hvordan det skal gjøres og kontrollere at resultatet virker.
Konklusjon
I den første artikkelen klargjorde vi datamaskinen. I denne har vi klargjort arbeidsmåten vår.
Nå vet vi hvordan vi kan:
- Gjøre et behov om til krav.
- Be Codex utarbeide en plan.
- Revidere den med Antigravity.
- Utvikle en funksjon.
- Gjennomgå koden.
- Publisere med versjonskontroll.
- Dokumentere alt.
Det handler ikke bare om å programmere raskere med kunstig intelligens, men om å kunne vedlikeholde det vi utvikler, forstå hva som er endret og ha en prosess for å rette problemer når de dukker opp.
I neste del skal vi bruke denne arbeidsmåten med WordPress: lokal utvikling, tester, versjonerte filer og utrulling på et ekte webhotell.
Ofte stilte spørsmål
Må jeg kunne programmere for å bruke denne prosessen?
Du trenger ikke nødvendigvis skrive kode, men du må forstå grunnleggende utviklingsbegreper og lære å tolke tester og risikoer. KI fjerner ikke ansvaret vårt for resultatet.
Må jeg bruke Codex og Antigravity?
Nei. Du kan erstatte dem med andre agenter for programmering og gjennomgang. Det viktige er å skille rollene og unngå at utvikleren er den eneste som vurderer sitt eget arbeid.
Trenger jeg Notion og Linear?
Linear er oppgaveverktøyet vi bruker i denne veiledningen. Notion er valgfritt i enkle prosjekter, men jeg anbefaler det når krav, beslutninger og dokumentasjon hoper seg opp. Et alternativ er å lagre informasjonen i Markdown.
Hva gjør jeg når Antigravity gir NO-GO?
Send rapporten til Codex, be den rette problemene og gjenta revisjonen. Ikke gå automatisk videre til neste fase.
Hvorfor revidere to ganger?
Fordi den første revisjonen finner problemer i planleggingen, mens den andre kontrollerer implementeringen. Hvis vi bare gjennomgår koden, kan vi overse designfeil som ville vært enklere å rette tidligere.
Kan jeg bruke denne arbeidsmåten med WordPress eller andre teknologier?
Ja. Prosessen er uavhengig av språk og plattform. Det som varierer, er testene, miljøene og publiseringsmetodene.
Når er en oppgave egentlig ferdig?
Når den godkjente versjonen er publisert, det er kontrollert at den fungerer i produksjon, og dokumentasjonen for tester og beslutninger er registrert.

Legg igjen en kommentar