I den första artikeln i den här serien förklarade vi hur man förbereder en dator för vibe coding. Vi installerade Linux, konfigurerade Codex och Antigravity, kopplade GitHub och publicerade vår första applikation med Railway.
Vi lyckades utveckla en liten applikation med artificiell intelligens utan att själva skriva koden.
Men det var ett test. Vi bad Codex programmera, kontrollerade att det fungerade och använde sedan Antigravity för att granska resultatet. Det duger som start, men vill vi arbeta med riktiga projekt behöver vi bättre organisation.
Vad händer när vi har flera funktioner kvar att bygga? Hur hindrar vi AI:n från att ändra filer den inte borde röra? Vem kontrollerar att lösningen är genomtänkt innan den programmeras? Och hur vet vi att det som publicerats är exakt det vi granskat?
För att besvara de frågorna har jag stegvis byggt upp min egen arbetsmetod. Jag har inte uppfunnit något revolutionerande: jag har anpassat vanliga metoder inom professionell mjukvaruutveckling till en miljö där AI-agenter gör en stor del av arbetet.
Jag förklarar hur du organiserar och använder den steg för steg. Kanske hjälper det dig att göra likadant.
Så organiserar jag arbetet med AI-agenter
Idén är enkel: en AI utvecklar och en annan granskar dess arbete, medan vi behåller kontrollen över de viktiga besluten.
Själv använder jag fem grundverktyg:
| Verktyg | Funktion |
| Codex | Analyserar, planerar, programmerar, testar och dokumenterar. |
| Antigravity | Granskar planen och koden oberoende. |
| GitHub | Lagrar koden, versionerna och Pull Requests. |
| Linear | Organiserar uppgifter, tester, granskningar och statusar. |
| Notion | Sparar krav, beslut och projekthistorik. |
Utöver dessa använder jag ett par till: Local WP för utveckling med WordPress och Convex eller Supabase om det är en webbapplikation som behöver en databas.
Notion är valfritt, men jag rekommenderar det för medelstora projekt. Vi ska snart se varför.
Vi är inte heller tvungna att använda just dessa applikationer. Vi kan exempelvis ersätta Codex med Claude Code eller låta en annan agent granska. Det viktiga är att hålla ansvarsområdena åtskilda.
Hela processen är:
- Krav.
- Teknisk plan.
- Första granskningen.
- Utveckling och tester.
- Andra granskningen.
- GitHub.
- Driftsättning.
- Verifiering.
Steg 2 (Codex) och 3 (Antigravity) kan upprepas flera gånger: hittar Antigravity ett problem rättar Codex det och vi granskar igen. Tanken är att arbeta i cykler av utveckling och kontroll, utan att gå vidare så länge viktiga problem är olösta.
I mitt arbetssätt är två granskningar obligatoriska, även om deras omfattning beror på utvecklingens komplexitet. Den första granskar vad vi tänker göra och den andra kontrollerar vad vi faktiskt har gjort.
Och en viktig sak: ett GO från granskaren är inte ett tillstånd att publicera. Det beslutet är fortfarande vårt.
Steg 1. Förbered arbetsmiljön med Codex
Vi utgår från datorn vi konfigurerade i den första guiden. Codex, Antigravity och GitHub fungerar redan, så vi behöver inte installera dem igen.
Vi öppnar en terminal i projektmappen och startar Codex:
cd ~/Proyectos/mi-proyecto
codex
Nu kommer en av de saker jag gillar mest med att arbeta med agenter: vi behöver inte konfigurera hela projektstrukturen manuellt. Vi kan be Codex att göra det.
Prompt 1. Konfigurera arbetsmiljön
Jag vill förbereda det här projektet för att arbeta med en AI-övervakad utvecklingsprocess.
Du ska agera analytiker och utvecklare. Antigravity blir den oberoende granskaren. Vi använder GitHub för koden, Linear för uppgifterna och eventuellt Notion för dokumentationen.
Inspektera projektet och kontrollera tillgängliga anslutningar. Föreslå permanenta instruktioner, minsta nödvändiga dokumentation, behörighetsregler och en process med två obligatoriska granskningar: av den tekniska planen och av koden.
Implementeringar, viktiga Git-operationer och driftsättningar kräver mänskligt godkännande. Uppgifter stängs först efter verifiering i produktion.
Presentera först en konfigurationsplan. Skapa inga filer och ändra inga tjänster förrän du fått godkännande.
Codex bör analysera vad som finns tillgängligt och berätta vad som saknas.
Vanligtvis måste vi utföra vissa moment själva:
- Logga in i Linear eller Notion.
- Godkänna en integration.
- Acceptera behörigheter eller skapa en anslutning som kräver autentisering i webbläsaren.
MYCKET VIKTIGT: vi får inte lämna ut lösenord eller token genom att klistra in dem direkt i chatten.
Vi använder respektive tjänsts autentiseringsmekanismer (Github och Claudflare har sådana) och ger bara de behörigheter som behövs.
När konfigurationen godkänts kan Codex förbereda filerna och organisera verktygen.
Men vi måste förstås kontrollera att det verkligen har gjorts, så vi ber agenten verifiera det. En agent kan inte skapa en anslutning till Linear om dess miljö saknar en kompatibel integration.
Steg 2. Organisera dokumentationen utan att fylla arkivet med filer
För att arbeta med agenter behöver vi något som enbart samtalen inte ger oss: projektets operativa minne.
Tänk dig att vi har utvecklat i flera veckor och startar en ny Codex-session. Vi vill inte förklara hela arkitekturen igen, vilka verktyg vi använder, vilka filer den får ändra och hur driftsättningen fungerar.
För att undvika det använder vi två grundläggande dokument i kodarkivet:
- AGENTS.md: permanenta instruktioner för Codex, begränsningar för dess arbete och utvecklingsregler.
- PROJECT.md: projektbeskrivning, grundläggande arkitektur, miljöer och länkar till dokumentationen.
Codex kan skapa dem utifrån våra krav.
Och varför behöver vi Notion?
I små projekt kan Markdown-filer räcka för att dokumentera ändringar och beslut. Men när funktioner, beslut, krav och arkitekturändringar börjar samlas får vi till slut alldeles för många dokument i arkivet.
Därför rekommenderar jag Notion för medelstora projekt.
Där sparar vi framför allt PRD (Product Requirements Document), tekniska beslut och projektets historik. Linear innehåller uppgifter, deras status, granskningar och tester. GitHub lagrar koden.
Det intressanta är att det främst är agenterna själva som använder Notion och Linear. Codex skriver och uppdaterar dokumentation, läser kraven innan den programmerar och registrerar resultaten. Antigravity behöver läsa samma information för sin granskning.
Vi behöver inte själva skriva sida efter sida med dokumentation. Vårt ansvar är att kontrollera att kraven och de viktiga besluten motsvarar det vi vill uppnå.
Steg 3. Definiera vad vi vill utveckla
Vi tar en verklig utveckling som jag gjort för den här webbplatsen som exempel.
I mitt magasin visade taggsidorna inläggen i kronologisk ordning. Jag ville förbättra dem så att de lyfte fram det mest intressanta innehållet utan att förlora den vanliga listan.
Det är precis den typen av behov vi kan beskriva för Codex med vanligt språk, med vetskap om att en sådan begäran lämnar många frågor öppna.
- Hur många artiklar ska vi lyfta fram?
- Hur avgör vi vilka som är relevanta?
- Vad händer med de övriga?
- Ska det fungera på alla sidor?
- Vilka element vill vi inte ändra?
Innan vi analyserar något behöver vi reda ut frågorna.
Prompt 2. Förbered krav och teknisk plan
Jag vill utveckla den här funktionen: [BESKRIVNING].
Läs projektets instruktioner och dokumentation. Omvandla behovet till verifierbara krav och acceptanskriterier. Skapa eller uppdatera PRD och organisera nödvändiga uppgifter i Linear.
Granska den befintliga koden och föreslå den enklaste lösningen som uppfyller kraven. Identifiera berörda filer, risker, alternativ och tester.
Programmera inte ännu. Fråga mig om funktionsbeslut som inte kan avgöras med tillgänglig information och förbered planen för oberoende granskning.
Det här är en av de viktigaste skillnaderna jämfört med att bara be en AI programmera något.
Codex kan hjälpa oss att förvandla en idé till en specifikation. Vi avgör om specifikationen motsvarar vårt behov.
När det gäller taggarna, till exempel, kunde acceptanskriteriet inte bara vara att utvalda artiklar skulle visas. Vi behövde också behålla navigeringen, undvika oönskade dubbletter och säkerställa att de olika sidorna fungerade korrekt.
När upplägget godkänts registrerar Codex det och förbereder den tekniska planen.
Vi har fortfarande inte skrivit en enda kodrad.
Design av gränssnittet
I det här fallet visste jag exakt vilken design jag ville ha och bad därför inte om visuella förslag. Men i andra fall skulle jag be om dem här, så att agenten kan ta hänsyn till dem innan den föreslår en teknisk lösning.
Vet du redan hur det ska se ut förklarar du det förstås bara. Och om funktionen påverkar backend snarare än frontend behöver du inte heller några mockuper.
Steg 4. Första granskningen: kontrollera planen med Antigravity
Nu kommer vår andra agent in i bilden.
Vi öppnar en annan terminal i samma projektmapp och kör:
agy
I min nuvarande process körs Antigravity manuellt. Vi låter inte Codex anropa den automatiskt och fortsätta utan att vi granskat resultatet.
Vi vill att den fungerar som oberoende granskare, inte som ännu en programmerare som börjar ändra filer.
Prompt 3. Granska den tekniska planen
Agera enbart som oberoende teknisk granskare.
Granska projektinstruktionerna, kraven och planen som Codex föreslagit. Bedöm om lösningen är genomförbar, tillräckligt enkel, säker och kompatibel med befintlig funktionalitet.
Kontrollera risker, möjliga regressioner och om de planerade testerna är lämpliga.
Ge ett motiverat utlåtande: GO, villkorat GO eller NO-GO. Ange uttryckligen om du saknar tillräckliga belägg.
Identifiera konkreta problem och nödvändiga korrigeringar. Ändra inga filer.
Varför granska före utvecklingen?
Därför att en lösning kan vara perfekt programmerad och ändå vara en dålig lösning.
Den kanske inför ett onödigt beroende, duplicerar befintlig information, gör för många databasfrågor eller försvårar framtida underhåll.
För taggarna räckte det till exempel inte att skapa ett system för utvalda artiklar. Vi behövde också fundera på hur deras ordning skulle beräknas utan långsamma operationer vid varje sidbesök.
Om granskaren hittar problem skickar vi rapporten till Codex. Den reviderar planen och vi granskar den igen vid behov.
Vi börjar inte programmera förrän vi har en godkänd plan och mänskligt tillstånd att implementera den.
Steg 5. Codex utvecklar och kör testerna
När planen är godkänd börjar implementeringen.
Codex arbetar i en gren av kodarkivet. Har du läst den första delen känner du redan till Git och GitHub, så vi behöver inte gå igenom dem igen.
Det nya är att vi inte programmerar direkt på projektets stabila version. Vi förbereder ändringarna separat så att de kan granskas innan de slås samman.
Prompt 4. Implementera funktionen
Jag godkänner utveckling enligt den godkända och granskade planen för [LINEAR-UPPGIFT].
Arbeta i en separat gren och begränsa ändringarna till det godkända omfånget.
Implementera lösningen, kör relevanta tester och kontrollera möjliga regressioner. Dokumentera resultaten i Linear.
Förbered hela diffen, identifiera ändrade filer och lämna de belägg som behövs för den andra granskningen.
Gör ingen merge eller driftsättning. Stanna när utvecklingen är redo för granskning.
Codex kan ändra filer, köra tester och rätta fel inom det omfång vi har godkänt.
Men det finns något vi måste hålla ögonen på: att AI:n påstår att en funktion fungerar betyder inte att det har verifierats.
Vi behöver bevis. Beroende på projektet kan det vara automatiserade tester, körresultat, funktionskontroller eller en kombination.
Vi måste också skilja på vad Codex faktiskt testat och vad den ännu inte kan verifiera.
Tillbaka till vårt exempel: det räcker inte att kontrollera att tre utvalda artiklar visas. Vi måste granska vad som händer om färre artiklar finns, om man byter sida eller om något innehåll saknar förväntade data, exempelvis en artikel som inte översatts till ett av språken.
Agenten måste dokumentera de kontrollerna och eventuella begränsningar.
Steg 6. Andra granskningen: granska den faktiska koden
Funktionen är färdigutvecklad, men vi ska ännu inte publicera den.
Vi går tillbaka till Antigravity och ber den granska den ändrade koden, inte bara rapporten som Codex har tagit fram.
Prompt 5. Granska implementeringen
Agera som oberoende teknisk granskare av [LINEAR-UPPGIFT].
Granska hela diffen, den godkända planen, kraven och testbevisen.
Leta efter funktionsfel, säkerhetsproblem, regressioner, onödig komplexitet och ändringar utanför det godkända omfånget.
Ge ett motiverat utlåtande och ange fynden per fil och plats när det är möjligt.
Registrera SHA-256-hashen för den granskade diffen så att exakt vilken version som granskats kan identifieras.
Ändra inga filer och godkänn inga commits, merges eller driftsättningar.
Två detaljer är viktiga.
För det första måste Antigravity kunna läsa samma regler och krav som Codex använde. Annars riskerar den att godkänna en tekniskt korrekt lösning som inte uppfyller våra önskemål.
För det andra måste vi bevara dokumentation om hela den granskade ändringen. Då kan vi identifiera exakt vilken version som fick GO och upptäcka om koden ändrats efteråt. Hashen måste beräknas reproducerbart på samma innehåll.
I mitt fall sparar vi allt detta i Linear, kopplat till rätt uppgift.
Om Antigravity hittar fel återvänder vi till Codex, begär korrigeringar och upprepar granskningen.
Två agenter kan ha fel, även om de gör samma bedömning. Därför är granskningarna extra kontroller, inte absoluta garantier. Och därför kan vi valfritt lägga till en tredje.
Steg 7. Integrera ändringarna i GitHub
När vi har ett GO från granskningen kan vi förbereda integreringen. Den vanliga processen är:
Gren > Commit > Push > Pull Request > Merge.
Vi behöver inte köra dessa kommandon manuellt. Codex kan göra det, men vi måste förstå vad vi ger tillstånd till.
En Pull Request låter oss granska vilka ändringar vi vill föra in i huvudgrenen, med vilka tester och med granskarens rekommendationer.
Vi bör också kontrollera att versionen vi ska integrera fortfarande är den som granskats. Ändrar vi koden efter ett GO kan utlåtandet sluta gälla.
Jag föredrar uttryckliga godkännanden för viktiga operationer. Vissa kan grupperas om omfattningen är helt tydlig, men vi ska inte ge obegränsad frihet att integrera och publicera.
Att granskaren anser att utvecklingen är korrekt är en sak; att vi beslutar att införa den är en annan.
Det är här en tredje AI skulle kunna komma in: vi kan lägga till en andra specialiserad granskare, som CodeRabbit.
Till skillnad från Antigravity, som granskar planen och koden lokalt, kan CodeRabbit automatiskt analysera Pull Requests på GitHub innan de slås samman.
Det är en intressant extra kontroll för viktiga projekt, men inte nödvändig och den kostar pengar, även om priset är lågt i förhållande till nyttan. Själv föredrar jag än så länge två manuella granskningar och överväger en tredje när projekten blir större.
Steg 8. Driftsätt och kontrollera funktionen i produktion
Det här steget beror mycket på var projektet ligger.
I den första delen använde vi Railway. Vi kunde också publicera med GitHub Actions, vårt webbhotells verktyg eller vilket annat driftsättningssystem som helst.
Det särskilda med WordPress, LocalWP och Webempresa tar vi upp i en annan artikel.
Här är den allmänna regeln: en lyckad driftsättning betyder inte att funktionen fungerar korrekt.
När ändringen publicerats måste vi kontrollera den verkliga applikationen.
I vårt exempel innebär det att besöka de publika sidorna, kontrollera de utvalda artiklarna, bläddra i listan och säkerställa att andra funktioner inte har påverkats.
Vi måste också bekräfta att den nya versionen faktiskt visas. Ibland publiceras koden korrekt, men en cache fortsätter att visa gammalt innehåll, vilket hände mig med WP Rocket.
Vid viktigare utveckling måste vi ha en plan för hur den stabila versionen ska återställas om något går fel.
Först efter dessa kontroller kan vi säga att funktionen är färdig.
Steg 9. Stäng uppgiften och förbered nästa utveckling
När resultatet är verifierat ber vi Codex uppdatera Linear och projektdokumentationen.
Den ska registrera vad som utvecklats, vilken version som är publicerad, vilka tester vi utfört och om några problem återstår.
Uppgiften markeras som slutförd efter verifieringen i produktion, inte när Codex programmerat färdigt eller när Antigravity ger sitt GO.
Dokumentationen har ytterligare en fördel: vi kan avsluta sessionen och börja en ny utan att förlora sammanhanget.
Jag rekommenderar faktiskt att göra det när vi börjar med en annan funktion. Agenterna kan hämta regler, krav och beslut från projektdokumenten i stället för att förlita sig på oändliga samtal.
Med tiden kan vi automatisera en del av samordningen mellan Codex och Antigravity, men just nu föredrar jag att göra det manuellt, kontrollera att processen fungerar och bygga förtroende innan jag tar bort övervakningssteg.
Är det värt att arbeta så här med all utveckling?
Nej.
För ett snabbt test eller tjugo minuters experimenterande är dokumentation, två granskningar och en publiceringsprocess överdrivet.
Men när vi utvecklar en riktig webbplats, en applikation åt en kund eller ett projekt som ska underhållas i månader är det extra arbetet fullt rimligt.
Fördelen med processen är inte att den tar bort fel eller ersätter programmeringskunskap, utan att vi kan arbeta mer organiserat, bevara besluten och upptäcka problem innan de når användarna. Vi minimerar de misstag som kännetecknar den första tidens vibe coding.
Och eftersom agenterna gör merparten av det operativa arbetet kan vi koncentrera oss på det viktiga: bestämma vad vi vill ha, godkänna hur det ska göras och kontrollera att resultatet fungerar.
Slutsats
I den första artikeln förberedde vi datorn. I den här har vi förberett vårt arbetssätt.
Nu vet vi hur vi ska:
- Omvandla ett behov till krav.
- Be Codex ta fram en plan.
- Granska den med Antigravity.
- Utveckla en funktion.
- Granska koden.
- Publicera med versionskontroll.
- Dokumentera allt.
Det handlar inte bara om att programmera snabbare med AI, utan om att kunna underhålla det vi utvecklar, förstå vad som har ändrats och ha en process för att rätta problem när de dyker upp.
I nästa del tillämpar vi det här arbetssättet på WordPress: lokal utveckling, tester, versionshanterade filer och driftsättning på ett riktigt webbhotell.
Vanliga frågor
Måste jag kunna programmera för att använda den här processen?
Det är inte nödvändigt att skriva kod, men du behöver förstå grunderna i utveckling och lära dig tolka tester och risker. AI:n tar inte bort vårt ansvar för resultatet.
Måste jag använda Codex och Antigravity?
Nej. Du kan ersätta dem med andra agenter för programmering och granskning. Det viktiga är att hålla rollerna åtskilda och undvika att utvecklaren ensam bedömer sitt eget arbete.
Behöver jag Notion och Linear?
Linear är uppgiftsverktyget vi använder i den här guiden. Notion är valfritt för enkla projekt, men jag rekommenderar det när krav, beslut och dokumentation växer. Ett alternativ är att spara informationen i Markdown.
Vad gör jag när Antigravity ger ett NO-GO?
Skicka rapporten till Codex, be den rätta problemen och gör om granskningen. Gå inte automatiskt vidare till nästa fas.
Varför granska två gånger?
Därför att den första granskningen hittar problem i planeringen och den andra kontrollerar implementeringen. Att bara granska koden kan missa designfel som hade varit enklare att rätta i förväg.
Kan jag använda arbetssättet med WordPress eller andra tekniker?
Ja. Processen är oberoende av språk och plattform. Det som varierar är testerna, miljöerna och publiceringsmetoderna.
När är en uppgift verkligen klar?
När den godkända versionen har publicerats, dess funktion har verifierats i produktion och belägg och beslut har dokumenterats.

Lämna ett svar