# Softwarefabrik i praksis

Af Kristian Primdal
Kilde: https://kristianprimdal.dk/guides/softwarefabrikken/
Dato: 2026-11-15
Opdateret: 2026-11-15

Hvad er en softwarefabrik, og hvordan bygger man en? Sådan bygger jeg min: miljø, specs, bevis, review, merge og målinger.


De fleste udviklere bruger i dag Claude Code, Codex eller Cursor som en chat. Du skriver en opgave, læser svaret og retter. En softwarefabrik er næste skridt. Her kommer opgaverne ind af sig selv. Agenter skriver koden, andre agenter tjekker den, og et menneske træder til, hvor det giver mening.

Ordet bruges om meget forskelligt lige nu. Derfor starter jeg ikke med en definition. Jeg starter med, hvordan jeg selv bygger den.

Guiden er til dig, der er udvikler eller tech lead i en dansk virksomhed med fra én til omkring 30 udviklere. Du bruger allerede en kodeagent og vil videre. Til sidst er der et kort afsnit til lederen, der skal sige ja.

Guiden følger fabrikken fra opgave til færdig PR, lag for lag. Hvor der ikke er ét rigtigt svar, skriver jeg, hvad jeg har valgt, og hvornår jeg ville vælge anderledes. Meget af det har jeg lært af andre, der bygger fabrikker. Dem finder du nederst under [Hvem jeg henter inspiration fra](#hvem-jeg-henter-inspiration-fra).

<figure class="hi-editorial-break">
  <img src="/assets/softwarefabrikken/loekken.webp" width="1536" height="1024" loading="lazy" decoding="async" alt="En kvinde og en ældre mand står ved en whiteboard i et kontor i et gammelt pakhus. Hun peger på en af fire kasser, der er forbundet med pile i en ring. Han holder en kaffekop.">
  <figcaption>En fabrik er en løkke, ikke en kæmpe agent. Det første skridt er at tegne den.<span class="hi-illustration-credit">AI-genereret illustration. Ikke en gengivelse af konkrete personer eller virksomheder.</span></figcaption>
</figure>

---

## Hvad er en softwarefabrik

Når du bruger en kodeagent som chat, er du selv båndet i fabrikken. Du giver opgaven, venter, læser, retter og giver den næste. Du er mennesket som mellemled.

En fabrik flytter den rolle ud i et system. Et signal kommer ind: en sag, en Slack-besked, en alarm fra drift eller en planlagt kørsel. Ud kommer et resultat: en PR, en rettelse eller et svar. Agenter driver løkken imellem, og et menneske træder kun ind, hvor der skal træffes en beslutning.

Jeg tænker på det som løkker, ikke som én stor agent. Arbejdsenheden er ikke længere en prompt. Det er løkken. En spec går ind, og ud kommer en ændring, der er bygget, tjekket og bevist. Inde i den store løkke er der små: review og rettelse, test og rettelse.

Hver løkke har fem dele:

- Noget, der starter den.
- En arbejdsenhed.
- Et tjek af, om arbejdet er gjort.
- En betingelse for at stoppe, fx at tjekket består, et loft over tokens eller en tidsgrænse.
- Et sted at gemme tilstand mellem kørslerne, fx en sag på GitHub eller en Slack-kanal.

Det hjælper at tegne fabrikken som et flowdiagram. Kasserne er ting, der bliver lavet: en sag, en spec, en PR. Pilene er agenter, der laver det ene om til det næste. Kontrollerne sidder på pilene: test, godkendelse og sortering. Så ser du hurtigt, hvilke pile du stadig går med i hånden.

To ting skiller en fabrik fra mange terminaler med agenter side om side. Den kan starte arbejde selv, fx når der kommer en fejl i drift. Og den kan måles, så du kan se, om den bliver bedre.

Min løkke har otte trin. Ikke alle opgaver bruger dem alle, og review og test kan bytte plads. Den rigtige rækkefølge afhænger af, hvilket trin der er dyrest. Pilen fra review tilbage til byg er den mindste løkke: review, ret, review igen, indtil der ikke er mere at rette.

<figure style="margin:3rem 0">
  <div style="overflow-x:auto">
  <svg viewBox="0 0 760 300" role="img" aria-label="Fabrikkens løkke i otte trin. Øverste række fra venstre: opgave kommer ind, spec, byg, bevis. Nederste række fra højre: review, merge, release, lær. En pil fra lær går tilbage til opgave og viser, at fabrikken bruger erfaringen til næste opgave. En stiplet pil fra review går tilbage til byg og viser den lille løkke, hvor fund fra review bliver rettet. Trinene spec, review og merge er markeret som steder, hvor et menneske tit træffer en beslutning." style="display:block;width:100%;min-width:640px;height:auto;font-family:inherit">
    <defs><marker id="sf-a1" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" fill="#444444"></path></marker></defs>
    <g fill="#fafafa" stroke="#999999"><rect x="20" y="40" width="150" height="70" rx="8"></rect><rect x="210" y="40" width="150" height="70" rx="8"></rect><rect x="400" y="40" width="150" height="70" rx="8"></rect><rect x="590" y="40" width="150" height="70" rx="8"></rect><rect x="590" y="180" width="150" height="70" rx="8"></rect><rect x="400" y="180" width="150" height="70" rx="8"></rect><rect x="210" y="180" width="150" height="70" rx="8"></rect><rect x="20" y="180" width="150" height="70" rx="8"></rect></g>
    <g fill="#e5e5e5" stroke="#111111" stroke-width="1.5"><rect x="210" y="40" width="150" height="70" rx="8"></rect><rect x="590" y="180" width="150" height="70" rx="8"></rect><rect x="400" y="180" width="150" height="70" rx="8"></rect></g>
    <g font-size="15" font-weight="700" fill="#111111" text-anchor="middle"><text x="95" y="70">1. Opgave ind</text><text x="285" y="70">2. Spec</text><text x="475" y="70">3. Byg</text><text x="665" y="70">4. Bevis</text><text x="665" y="210">5. Review</text><text x="475" y="210">6. Merge</text><text x="285" y="210">7. Release</text><text x="95" y="210">8. Lær</text></g>
    <g font-size="12" fill="#444444" text-anchor="middle"><text x="95" y="92">Slack, tracker, alarm</text><text x="285" y="92">mål, rammer, bevis</text><text x="475" y="92">agent i et miljø</text><text x="665" y="92">tests, facitliste, video</text><text x="665" y="232">frisk agent, så risiko</text><text x="475" y="232">menneske eller regel</text><text x="285" y="232">flag, udrulning</text><text x="95" y="232">postmortem, måling</text></g>
    <g stroke="#444444" marker-end="url(#sf-a1)"><line x1="172" y1="75" x2="206" y2="75"></line><line x1="362" y1="75" x2="396" y2="75"></line><line x1="552" y1="75" x2="586" y2="75"></line><line x1="665" y1="112" x2="665" y2="176"></line><line x1="588" y1="215" x2="554" y2="215"></line><line x1="398" y1="215" x2="364" y2="215"></line><line x1="208" y1="215" x2="174" y2="215"></line><line x1="95" y1="178" x2="95" y2="114"></line></g>
    <path d="M600 178 L548 114" fill="none" stroke="#444444" stroke-dasharray="5 4" marker-end="url(#sf-a1)"></path>
    <text x="582" y="140" font-size="12" fill="#666666">ret</text>
    <g font-size="12" fill="#666666"><rect x="20" y="268" width="14" height="14" rx="3" fill="#e5e5e5" stroke="#111111" stroke-width="1.5"></rect><text x="42" y="280">Tit et menneske, der beslutter</text></g>
  </svg>
  </div>
  <figcaption class="mt-3 text-sm leading-6 text-mist-600">Fabrikkens løkke. Trin 8 sender erfaringen tilbage til trin 1. Den stiplede pil er den lille løkke mellem review og byg. De mørke kanter viser, hvor et menneske tit beslutter.</figcaption>
</figure>

---

## Fabrikkens fire lag

Vi kan dele fabrikken op i fire lag.

1. **Compute.** Maskinen, agenten kører på. En sandbox i skyen, en virtuel maskin eller en fysisk computer.
2. **Udviklingsmiljøet.** Det, der kører på maskinen: kode, afhængigheder, databaser, testdata og adgang til de tjenester, appen skal bruge.
3. **Harness.** Selve kodeagenten og det, der omgiver den. Her kan vi også skelne mellem den indre harness, fx Claude Code eller Codex, og den ydre: jeres egne arbejdsgange, skills og regler.
4. **Orkestrering.** Det, der modtager opgaver, starter agenter, holder styr på status og gemmer en log.

Pointen er, at lagene skal kunne skiftes ud hver for sig. Man skal ikke købe eller bygge hele stakken på én gang. Man kan fx starte på en VPS med værktøjerne installeret. Claude Code og Codex startes fra kommandolinjen, hver session gemmes som en log, og orkestreringen kan være et par scripts, du selv skriver. Jeg bruger både scripts og bb. Senere kan du skifte VPS'en ud med sandboxes i skyen uden at røre resten.

<figure style="margin:3rem 0">
  <div style="overflow-x:auto">
  <svg viewBox="0 0 760 330" role="img" aria-label="Fire lag stablet oven på hinanden. Øverst orkestrering, der modtager opgaver og starter agenter. Under den harness, altså kodeagenten og jeres regler og skills. Under den udviklingsmiljøet med kode, afhængigheder, testdata og login. Nederst compute, altså maskinen. Til højre står, at orkestrering er den lette del, udviklingsmiljøet kan være den svære del." style="display:block;width:100%;min-width:640px;height:auto;font-family:inherit">
    <g fill="#fafafa" stroke="#999999"><rect x="20" y="20" width="440" height="62" rx="8"></rect><rect x="20" y="92" width="440" height="62" rx="8"></rect><rect x="20" y="236" width="440" height="62" rx="8"></rect></g>
    <rect x="20" y="164" width="440" height="62" rx="8" fill="#e5e5e5" stroke="#111111" stroke-width="1.5"></rect>
    <g font-size="15" font-weight="700" fill="#111111"><text x="40" y="47">4. Orkestrering</text><text x="40" y="119">3. Harness</text><text x="40" y="191">2. Udviklingsmiljø</text><text x="40" y="263">1. Compute</text></g>
    <g font-size="12.5" fill="#444444"><text x="40" y="68">opgaver ind, agenter startes, status og log</text><text x="40" y="140">kodeagenten plus jeres skills, regler og arbejdsgange</text><text x="40" y="212">kode, afhængigheder, testdata, login, stubs</text><text x="40" y="284">sandbox, virtuel maskine eller fysisk computer</text></g>
    <line x1="490" y1="0" x2="490" y2="320" stroke="#e5e5e5"></line>
    <g font-size="13" fill="#111111"><text x="510" y="56">Den lette del.</text><text x="510" y="74">Standardklodser.</text><text x="510" y="190">Kan være den svære del.</text></g>
    <g font-size="12.5" fill="#444444"><text x="510" y="128">Commodity.</text><text x="510" y="270">Også commodity.</text></g>
  </svg>
  </div>
  <figcaption class="mt-3 text-sm leading-6 text-mist-600">Fabrikkens fire lag. De fleste dele kan købes færdige. Udviklingsmiljøet kan være det, der tager tid.</figcaption>
</figure>

### Alene er det let, sammen er det svært

At starte en agent er den lette del. Det svære er alt det, der ligger rundt om harnessen. Hvor bliver sessionerne gemt? Hvor bliver ændringerne lavet? Og hvordan bliver en ny kopi af koden sat op, så agenten kan køre appen og teste sit eget arbejde?

Når jeg arbejder alene, har jeg det hele på min egen maskine. Jeg kan finde alle mine sessioner. Jeg ved, hvilke ændringer der ligger hvor. Og jeg venter ikke på nogen.

Når I bliver flere, holder det ikke længere. Sessionerne ligger på hver sin computer. Den ene ved ikke, hvad den andens agent har lavet, eller hvorfor. Hver udvikler sætter sin kopi af koden op på sin egen måde. Og nogle gange venter I på hinanden, fx på en database eller en testserver.

Derfor skal det løftes op i en fabrik. Her deler I de samme sessioner og det samme miljø. Med det samme mener jeg den samme måde at lave en kopi af koden på. Hver agent får sin egen kopi med alt, hvad den skal bruge, og ingen venter på hinanden. Så kan et menneske også gå ind i en session, som en kollega startede, og tage over, hvor agenten gik i stå. Det er der, et værktøj som [HumanLayer](https://www.humanlayer.dev/) giver mening. Det samler holdets sessioner med agenter, planer og ændringer i koden ét sted, så alle kan se og arbejde i dem.

Et dårligt miljø giver en dårlig fabrik, og udviklerne holder stille og roligt op med at bruge den. Start derfor med miljøet. Bagefter kommer forbindelsen til virksomhedens viden, fx logs og databaser fra drift. Til sidst kommer det, der sker, når produktfolk og support også begynder at lave ændringer.

<figure class="hi-editorial-break">
  <img src="/assets/softwarefabrikken/miljoeet.webp" width="1536" height="1024" loading="lazy" decoding="async" alt="En udvikler læner sig tilbage i en kontorstol med armene over kors og ser lange lister af testresultater på to skærme. På bordet ligger en åben notesbog med en tjekliste og en lille computer.">
  <figcaption>Det svære er ikke at starte agenten. Det er et miljø, hvor den kan teste sit eget arbejde.<span class="hi-illustration-credit">AI-genereret illustration. Ikke en gengivelse af konkrete personer eller virksomheder.</span></figcaption>
</figure>

### Tjekliste for miljøet

Miljøet skal gøre det muligt for agenten at tjekke sit eget arbejde. Fire ting står tit i vejen:

- Man kan kun logge ind gennem en rigtig udbyder som Google, fx via OAuth.
- Der er ingen stubs eller testservere for de eksterne tjenester, appen bruger.
- Opsætningen til staging eller udviklingsservere ligger ikke i repoet.
- Adgangskontrollen er svag eller mangler på nogle tjenester.

Login er den hyppigste blokering. En agent kan ikke logge ind med Google. Byg en indgang, som kun agenten og testmiljøet bruger, fx en side, hvor appen kører med falske brugere i forskellige roller og uden OAuth. Det samme gælder eksterne tjenester. Mangler I nøgler til en tjeneste, kan I bygge en falsk udgave af den, så både udvikleren og agenten kan køre appen.

Erstatningerne har niveauer. Det går fra en simpel falsk Stripe over en emulator, der husker tilstand, til en rigtig konto, man smider væk. Tommelfingerreglen er, at erstatningen skal huske lige så meget som den fejl, du leder efter.

Tænk på agenten som en evig nyansat. Den starter fra bunden hver gang og ved kun det, der er skrevet ned. Er miljøet let for en ny udvikler, er det også let for en agent. Og det skal køre ens lokalt og i skyen.

**Maskiner.** Sandboxes, der laves til hver session og smides væk bagefter, giver det samme rene udgangspunkt hver gang. Så kan mange agenter køre side om side. Har I en mobilapp, kan I få brug for rigtige Macs, fordi agenterne skal kunne bruge iOS-simulatorer.

**Hemmeligheder.** Agenten skal ikke kunne se nøglerne. Lad dem blive i orkestreringen. Agenten bruger dem gennem værktøjer eller en proxy, der sætter nøglen på, efter kaldet har forladt sandboxen. En liste over tilladte miljøvariabler er en enkel start. En agent, der mangler en nøgle, kan finde på at lede efter en på maskinen.

**Adgange.** Sletter en agent databasen i drift, er det en fejl i adgangskontrollen. Det ville det også være, hvis en nyansat gjorde det. Det skal være værktøjet, der forbyder farlige handlinger, ikke en model, der vurderer fra gang til gang. Giv hver agent sine egne afgrænsede forbindelser, så én tilbagekaldelse lukker den ude fra det hele.

---

## Ind i fabrikken: opgaver og specs

### Hvor opgaverne kommer fra

En fabrik har brug for et sted, hvor arbejdet kommer ind. Der er tre slags.

**Det, kunder og kolleger siger.** Mange opgaver kommer fra mennesker: et møde med en kunde, en fejlrapport, en tråd i Slack eller en sag i Jira. Saml dem ét sted, fx i en chat med en agent, der fordeler arbejdet. Også når du selv skriver en prompt, skal den gennem den samme løkke. Så bliver arbejdet synligt og kan måles, før noget bliver automatiseret. En sag, der er klar, går direkte til en agent. En sag, der er uklar eller stor, får en spec først.

**Det, systemerne siger.** Fejl og logs fra drift. En alarm fra fx Sentry eller en fejl i loggen starter en agent, der samler viden om fejlen og måske retter den. Det er tit det første, man sætter op.

**Planlagt arbejde.** Kørsler, der starter på faste tidspunkter, fx hver nat. De kan angribe jeres egne apps for at finde fejl, opdatere afhængigheder eller rydde op i koden.

### Specs i den rette størrelse

En spec skal passe til opgaven. Spørg, hvor ondt det gør, hvis det bliver forkert. Gang sandsynligheden for, at noget skal laves om, med prisen for at lave det om. En knaps farve kræver ingen plan. En ny databasetabel gør.

Prisen for at lave om har fire trin:

1. Smid grenen ud og kør igen.
2. Pil det ud, fordi anden kode nu afhænger af det.
3. Migrér, fordi data har den forkerte form.
4. Det kan ikke gøres om, fx et offentligt API, en sendt e-mail eller en pris, kunderne har set.

Agenter har gjort trin 1 og 2 billige. Der kan du bare køre igen. Trin 3 og 4 er lige så dyre som før, og der betaler en spec sig. Tit er 20 til 30 minutters planlægning nok til at fjerne det meste af risikoen.

Til mellemstore opgaver starter jeg med et interview. En skill stiller spørgsmål til mål og afvejninger, indtil de er afklaret. Mere om det i [guiden om grill-me](/guides/grill-me/).

Agenten kan godt skrive specen. Den finder selv fakta i koden. Mennesket beslutter politik, tilladelser, bagudkompatibilitet og alt, der sletter noget.

En god spec siger hvad, hvorfor og hvordan det bevises. Den siger ikke, hvordan det bygges. Den har:

- et udgangspunkt, altså hvordan det ser ud i dag
- mål og ikke-mål, hvor ikke-målene er ting, agenten ellers ville have gjort
- rammer
- en beskrivelse af beviset

Hver påstand i specen skal have en kilde: en fil og linje, en kommando og dens output eller en logbesked, og hvornår den blev tjekket. Fakta fra en gammel hukommelse er en almindelig kilde til fejl. Til sidst læser en frisk agent kun specen og leder efter modsigelser og huller. Det er billigere at rette en sætning end en færdig build.

### Specen er midlertidig, koden er sandheden

Når featuren er færdig og udgivet, skal specen væk. Koden er sandheden. Det koster meget at holde specs i takt med koden, og en gammel spec, der ikke passer længere, vildleder den næste agent. Lad agenten læse koden i stedet. Specen kan leve i sagen eller i PR'en, mens arbejdet står på, og lukkes sammen med den.

Men der skal være et tyndt lag af beslutninger. Hvorfor valgte vi den løsning? Hvad prøvede vi, som ikke virkede? Det står ikke i koden. Korte beslutningsnotater, ADR'er, og en ordliste med jeres fagudtryk er nok. Det er det tyndeste lag dokumentation, der fanger det, koden ikke kan vise.

Beslutningerne hører ikke hjemme i CLAUDE.md. Den fil skal kun rumme det, agenten ikke kan finde andre steder, og pege videre til resten. En god test er at fjerne filen et stykke tid og kun lægge det tilbage, der viser sig at mangle.

Hukommelsen skal også holdes tynd. Lad agenterne foreslå, hvad der skal huskes, men lad et menneske godkende det. De fleste sessioner skal ikke gemme noget. Lad jævnligt en kørsel gå hukommelsen igennem, fx hver nat. Den læser sessionerne, finder fejl, der går igen på tværs af agenter, og rydder op i dubletter. Anthropic kalder det [dreaming](https://www.youtube.com/watch?v=IGo225tfF2I).

### Planer, der beder om beslutninger

Mine planer er HTML-sider, ikke lange markdown-filer. En plan har et diagram over forløbet, et par muligheder for hver del og en anbefaling. Nederst står det, agenten har brug for fra mig. Planen er skrevet, så jeg kan tage beslutningerne hurtigt.

Jeg læser planen i browseren, markerer tekst og skriver kommentarer direkte på siden. Kommentarerne går tilbage til agenten, som retter planen. Det er hurtigere end at kommentere en markdown-fil linje for linje.

Skel mellem to slags dokumenter. Markdown er til agentens næste kontekst. HTML er til mennesker, der skal forstå og beslutte.

Før arbejdet går i gang, kan en agent angribe planen. Skal opgaven overhovedet løses? Giver den mening for koden og for forretningen?

### Giv agenten et mål

Bed ikke om en cache. Bed om, at siden svarer på under 200 millisekunder i 95 procent af tilfældene. Så kan agenten selv finde den reelle flaskehals. Beder du om din egen løsning, sætter du loftet der. Mennesket beholder rammer, tilladelser og bevis.

Målet skal kunne måles, fx svartid, en test eller en konvertering, og ændringen skal være let at rulle tilbage. Undtagelsen er ændringer, der giver en form, der bliver hængende: en datamodel, et offentligt API, data, der gemmes, eller et modul, meget andet bygger på. Agenter kan skrive kode, der følger specen og alligevel er dårligt bygget. Så aftal typer, funktionssignaturer, dataflow og kaldstruktur, før koden skrives. Trappen for omarbejde afgør det. På trin 1 og 2 giver jeg et mål. På trin 3 og 4 aftaler jeg strukturen først.

Jeg prøver heller ikke at gætte de næste krav. Et produkthold kender dem tit ikke. Det er små udgivelser, der lærer holdet, hvad det skal bygge, og en bedre spec kan ikke skabe viden, holdet ikke har. Kun ved en migrering eller en ny udgave af et system, jeg kender, giver jeg agenten alle krav med fra start.

---

## Byg

### Én bygger pr. feature

Én agent bygger hele featuren og retter selv sine fejl. Fund fra review går tilbage til den samme agent. Den husker beslutningerne og kan rette årsagen. Tag en invitation i en app. Både frontend og backend skal kende reglerne for token, udløb og e-mailadresser. Deler du arbejdet mellem flere agenter, går beslutningerne tabt i overleveringen.

Reviewere og testere skal derimod være friske. De skal ikke se byggerens argumenter. Del efter kontekst, ikke efter type af problem. Det er samme regel som i [guiden om subagenter](/guides/subagenter/).

Små fejlrettelser er undtagelsen. Kan hver fejl genskabes for sig, kan en frisk agent tage hver sag.

### Hvad der kører samtidig

Der er to slags samtidighed, og de er let at blande sammen.

**Flere opgaver på én gang.** Hver opgave kører i sin egen sandbox eller worktree med sin egen bygger. Her er reglen at begrænse det igangværende arbejde. Alt igangværende arbejde er gæld. Start kun de opgaver, der ikke venter på noget. Flaskehalsen er ikke længere maskinerne, men din opmærksomhed. At spørge en agent, hvad du skal se på, virker i starten. Det holder ikke, når mange forløb kører på én gang.

**Subagenter inden for én opgave.** Byggeren kan sende subagenter ud, mens den arbejder. De er gode til research, til at prøve flere løsninger af, til at jage fejl og til tests med hver sin database. De er ikke gode som et hold med roller som frontend, backend og sikkerhed. Det giver mest koordinering og sjældent bedre kvalitet. Selve featuren bygger én agent.

Når fabrikken virker, fylder de løkker, der finder sager, køen hurtigere, end de løkker, der løser dem, kan følge med. Så er der tre muligheder. Flere løkker, der løser. Strengere krav til, hvad der bliver til en sag. Eller at acceptere, at de mindst vigtige sager aldrig bliver løst.

### Skær i instruktionerne, byg flere kontroller

Når modellerne bliver bedre, skal instruktionerne skæres ned. Instruktioner, agenten følger alligevel, skal væk. Nye modeller bruger skills og subagenter for meget, når gamle prompts opfordrer til det. Test det. Giv en frisk session kun målet med en skill, og lad den ikke bruge selve skillen. Gør den det lige så godt, kan skillen gøres mindre eller slettes.

Kontrollerne går den anden vej. Klogere modeller kræver mere kontrol, ikke mindre, fordi de oftere snyder for at nå målet. Uden kontrol kommer agenten tilbage efter tre timer med noget, du smider ud.

Kør jævnligt gamle opgaver igen med et enklere forløb. Sammenlign så PR'erne blindt. Kan du ikke se forskel, kan trinnet fjernes. Mål hver ændring for sig.

---

## Bevis: grønne tests er ikke nok

Her er der ikke noget valg. At agenten siger, den er færdig, beviser intet. At testene er grønne, beviser heller ikke nok. Det er især tilfældet, når agenten selv har skrevet testene. Spørgsmålet er kun, hvilke lag af bevis der skal til. Kontrollerne er der, hvor en fabrik lykkes eller fejler lige nu.

### En kontrol, agenten ikke kan argumentere imod

En god kontrol har tre dele. En overflade, hvor brugeren møder funktionen: browseren, API'et, kommandolinjen. En facitliste, som den kode, der skal tjekkes, ikke selv har skrevet. Og en sammenligning, som byggeren ikke kan bortforklare.

Facitlister kan sættes i rækkefølge. Bedst er et system, der allerede virker. Så et gemt udtræk af, hvad systemet gav, da det virkede. Så tests, som ikke er skrevet af den samme agent. Så en spec for adfærd, skrevet før koden. Nederst er ingen facit. Så vælger agenten selv, hvad der er rigtigt. Flytter du et system, er det gamle dit facit. Bygger du noget nyt, så skriv ned, hvad brugeren gør, og hvad der skal ske.

Test også selve kontrollen. Plant realistiske fejl, og bed en frisk agent finde dem uden at fortælle, hvad der er ændret. En kontrol, der ikke kan fejle, er ingen kontrol.

Den fejl, jeg oftest ser, er at agenten vælger det letteste tjek. Fx en unit test med falske afhængigheder i stedet for et tjek, der beviser noget. Findes der ikke et testmiljø for den rigtige overflade, så byg det, før specen køres. Ellers falder agenten stille tilbage til det falske.

Del et godkendt resultat i lag. Blev opgaven gennemført? Ser det rigtigt ud? Er data rigtige? Alle tre skal bestå. Fejl ved siden af, fx i konsollen, bliver til nye sager.

Kontroller findes i tre slags. Faste kontroller som compiler, typer og lint er hurtige, men fanger ikke hensigten. Scorer som Lighthouse tager sekunder eller minutter. Data fra virkeligheden, fx konvertering, tager dage eller uger, men er tættest på sandheden. I stedet for at lade agenter skrive Playwright-tests kan du sende billige agenter igennem brugerens forløb med et mål. De melder tilbage, hvad der gik i stykker.

### Linters og slop-detektorer

Instruktioner er håb. Regler i CLAUDE.md bliver glemt dybt inde i en lang kontekst. Rettelser, du giver igen og igen, skal derfor laves om til lint-regler, der kører før hvert commit. Skriv fejlbeskeden som en prompt til agenten, så den ved, hvad den skal gøre i stedet.

Advarsler bliver læst af mennesker. Fejl, der stopper et commit, bliver læst af agenten. En regel, der fejler, så snart der står rå SQL i koden, får agenten til at rette det, før et menneske ser det.

Slop-detektorer går et skridt videre. Det er regler, der fanger de mønstre, AI-kode tit har. Den samme lille hjælpefunktion 50 steder i koden. Data, der sendes gennem syv lag uden grund. Funktioner, der er for komplekse. Læg dem oven i de klassiske målinger som kompleksitet og kopierede linjer. Mange fund betyder ikke altid dårlig kode, men tallet viser, hvilken vej det går.

Agenter bruger kodebasen som hukommelse og kopierer det, de ser i nærheden. Et hack bliver hurtigt til et mønster. Lav lint-reglen først, så det ikke spreder sig, og ryd så op. Og når agenten siger, den er færdig, så kør alle kontroller igen selv. Stol ikke på agentens egen påstand.

### Test adfærd, ikke koden

Tests, der bare gentager koden, giver ingen tryghed. Test gennem stabile grænseflader, så testene overlever, når koden indenfor ændres. Lav ikke nye små grænseflader kun for at teste den aktuelle ændring.

Testdrevet udvikling er et middel, ikke et ritual. Nogle gange er det nok at få bevis for, at testen fejler uden rettelsen. Et godt spørgsmål til agenten er: Hvordan gør vi den her ændring fuldt ud til at tjekke?

### Kan koden udvides?

Kode kan følge specen og stadig være dårligt bygget. Utætte abstraktioner, data, der sendes gennem mange lag, og overlæssede grænseflader. Det fanger en grøn test ikke.

Den rigtige test er, om koden holder, når der kommer nye krav. Virker de gamle krav stadig, når de nye er bygget? Kan en mindre model udvide koden, som en stor model har skrevet?

Fejlen starter tit i datastrukturen. Agenter laver nogle gange en ekstra liste ved siden af den, der findes. Nu står de samme data to steder, og de kan komme ud af takt. Testene er grønne hele vejen, for agenten har selv skrevet dem. Det hober sig op for hver feature. Læser du ikke koden, så læs i det mindste datastrukturerne.

### Video, billeder, artifacts og eksperimenter

Hver PR hos mig får en artifact-side. Det er en side i browseren med skærmbilleder, før og efter, og video, når brugerfladen ændrer sig. Så kan jeg se, at ændringen er testet fra ende til anden, uden selv at klikke den igennem. Små ændringer i brugerfladen kan nogle gange godkendes alene på videoen. Arkitekturen vil jeg stadig se på.

Agenter er stærke, når de kan kompilere, køre og tjekke et resultat. Billeder er de svagere til. AI-syn er ikke godt nok til at ramme et design på pixlen. Her skal et menneske stadig kigge.

Bevis for, at koden følger specen, er ikke det samme som bevis for, at den hjalp brugerne. Det sidste kræver et eksperiment i drift, fx en A/B-test.

<figure style="margin:3rem 0">
  <div style="overflow-x:auto">
  <svg viewBox="0 0 760 450" role="img" aria-label="En trappe med otte trin for bevis, fra svagest nederst til stærkest øverst. Trin 1: agenten siger, den er færdig. Trin 2: grønne tests skrevet af agenten selv. Trin 3: linters og slop-detektorer. Trin 4: tests af adfærd gennem stabile grænseflader. Trin 5: en uafhængig facitliste på den rigtige overflade, fx browser, API, video eller en artifact-side. Trin 6: kontrollen er selv testet med plantede fejl. Trin 7: koden kan udvides, og gamle krav virker stadig. Trin 8: et eksperiment i drift viser, at det virkede for brugerne." style="display:block;width:100%;min-width:640px;height:auto;font-family:inherit">
    <g fill="#fafafa" stroke="#999999"><rect x="20" y="390" width="300" height="44" rx="6"></rect><rect x="50" y="340" width="300" height="44" rx="6"></rect><rect x="80" y="290" width="300" height="44" rx="6"></rect><rect x="110" y="240" width="300" height="44" rx="6"></rect><rect x="140" y="190" width="300" height="44" rx="6"></rect><rect x="170" y="140" width="300" height="44" rx="6"></rect><rect x="200" y="90" width="300" height="44" rx="6"></rect><rect x="230" y="40" width="300" height="44" rx="6"></rect></g>
    <g font-size="13.5" fill="#111111"><text x="34" y="417">1. Agenten siger, den er færdig</text><text x="64" y="367">2. Grønne tests, skrevet af agenten</text><text x="94" y="317">3. Linters og slop-detektorer</text><text x="124" y="267">4. Adfærdstest ved stabile sømme</text><text x="154" y="217">5. Uafhængig facitliste, rigtig overflade</text><text x="184" y="167">6. Kontrollen testet med plantede fejl</text><text x="214" y="117">7. Kan udvides, gamle krav virker stadig</text><text x="244" y="67">8. Eksperiment i drift: virkede det?</text></g>
    <g font-size="12" fill="#444444"><text x="550" y="417">Bevis for intet</text><text x="550" y="367">Agenten tjekker sig selv</text><text x="550" y="317">Fanger mønstre, ikke hensigt</text><text x="550" y="267">Overlever, når koden ændres</text><text x="550" y="217">Browser, API, video, artifact</text><text x="550" y="167">En kontrol, der kan fejle</text><text x="550" y="117">Holder koden til næste krav?</text><text x="550" y="67">Hjalp det brugerne?</text></g>
    <g font-size="12" font-weight="600" fill="#666666" letter-spacing=".06em"><text x="20" y="22">STÆRKERE BEVIS OPAD</text></g>
  </svg>
  </div>
  <figcaption class="mt-3 text-sm leading-6 text-mist-600">Trappen er min egen sammenstilling. Højere trin erstatter ikke de lavere. De svarer på andre spørgsmål.</figcaption>
</figure>


---

## Review

### En frisk agent først

Lad aldrig byggeren se sit eget arbejde igennem. Revieweren får specen og ændringerne, men ikke byggerens forklaringer. Brug gerne en anden model til review end til at bygge, fx Claude som bygger og Codex som reviewer. Du kan også køre flere reviewere samtidig og samle fundene.

Lad to reviewere give hver sin dom. Den ene tjekker specen, den anden tjekker jeres standarder. En ændring, der følger alle konventioner, kan stadig bygge det forkerte. Fund fra en reviewer er spor at undersøge, ikke fakta. Faste regler skal være automatiske kontroller. Kun standarder, der kræver skøn, hører til i reviewerens instruktioner.

Review skal have et loft. En agent, der bliver bedt om at finde en fejl, finder altid en. Uden loft ender du med at rette meget sjældne fejl og tilføje kode, der skal vedligeholdes. Stop efter tre runder, eller når der ikke er flere fund af mellem eller høj alvor. Mange kommentarer er i sig selv et tegn. Er der 70, er der noget galt med PR'en.

Kig der, hvor agenten afveg fra planen. Afvigelsen viser, om du skal starte forfra, prøve igen eller acceptere følgen. Og giv review-agenten adgang til kun at læse PR'en. Den skriver sine fund i en fil, og et script laver dem om til kommentarer. Det begrænser skaden, hvis nogen gemmer instruktioner i en PR.

### Review efter risiko

Review er blevet risikostyring. Del ændringer i tre niveauer efter, hvad de kan ødelægge, ikke efter hvor store de er. Lav risiko ser et menneske ikke på. Mellem risiko får én godkender. Ændringer i databasen, brugerdata eller sikkerhedsroller ses altid af et menneske.

Skriv niveauerne ned som regler på filniveau. En regel kan være et simpelt søgeord eller et spørgsmål til en model, fx om ændringen tilføjer en ny afhængighed. Når en regel slår ud, venter filen, indtil en navngivet person har godkendt. Rører en ændring login, databaseskema, penge, opsætning i drift eller sletning af data, ryger den op. Et niveau må kun sænkes med data fra postmortems.

Lad systemet vise, hvad der skal læses. Af 30 ændrede filer er det måske tre eller fire, der bærer ændringen. Et kort over dem, i den rækkefølge de skal læses, sparer mere tid end endnu en AI-reviewer.

<figure style="margin:3rem 0">
  <div style="overflow-x:auto">
  <svg viewBox="0 0 760 330" role="img" aria-label="Tre niveauer af risiko. Lav risiko: tekst, dokumentation og små ændringer uden for kernen. Her kører automatiske kontroller og en AI-reviewer, og et menneske ser måske kun en video. Mellem risiko: almindelige features og fejlrettelser. Her godkender ét menneske, gerne med et kort over, hvilke filer der skal læses. Høj risiko: login, databaseskema og migreringer, penge, brugerdata, sikkerhedsroller, opsætning i drift og sletning. Her læser et navngivet menneske altid ændringen. Under niveauerne står, at en regel kan løfte en ændring op, men kun data fra postmortems må sænke den." style="display:block;width:100%;min-width:640px;height:auto;font-family:inherit">
    <g font-size="12" font-weight="600" fill="#666666" letter-spacing=".06em"><text x="20" y="20">HVAD ÆNDRINGEN KAN ØDELÆGGE</text><text x="400" y="20">HVEM SER PÅ DEN</text></g>
    <rect x="20" y="36" width="350" height="70" rx="8" fill="#fafafa" stroke="#999999"></rect>
    <rect x="20" y="118" width="350" height="70" rx="8" fill="#e5e5e5" stroke="#999999"></rect>
    <rect x="20" y="200" width="350" height="86" rx="8" fill="#111111"></rect>
    <g font-size="15" font-weight="700"><text x="36" y="62" fill="#111111">Lav</text><text x="36" y="144" fill="#111111">Mellem</text><text x="36" y="226" fill="#ffffff">Høj</text></g>
    <g font-size="12.5"><text x="36" y="84" fill="#444444">tekst, dokumentation, små ændringer uden for kernen</text><text x="36" y="166" fill="#444444">almindelige features og fejlrettelser</text><text x="36" y="248" fill="#e5e5e5">login, skema og migreringer, penge, brugerdata,</text><text x="36" y="266" fill="#e5e5e5">sikkerhedsroller, opsætning i drift, sletning</text></g>
    <g fill="#ffffff" stroke="#999999"><rect x="400" y="36" width="340" height="70" rx="8"></rect><rect x="400" y="118" width="340" height="70" rx="8"></rect></g>
    <rect x="400" y="200" width="340" height="86" rx="8" fill="#ffffff" stroke="#111111" stroke-width="2"></rect>
    <g font-size="13" fill="#111111"><text x="416" y="62">Kontroller og AI-reviewer.</text><text x="416" y="80">Måske kun en video.</text><text x="416" y="144">Ét menneske godkender,</text><text x="416" y="162">med kort over vigtige filer.</text><text x="416" y="226">Et navngivet menneske</text><text x="416" y="244">læser altid ændringen.</text></g>
    <g font-size="12" fill="#444444"><text x="20" y="312">En regel kan løfte en ændring op. Kun data fra postmortems må sænke den.</text></g>
  </svg>
  </div>
  <figcaption class="mt-3 text-sm leading-6 text-mist-600">Tre niveauer af risiko. Hvor grænserne går, er jeres egen beslutning.</figcaption>
</figure>

<figure class="hi-editorial-break">
  <img src="/assets/softwarefabrikken/review.webp" width="1536" height="1024" loading="lazy" decoding="async" alt="To kolleger ved et hævebord. Kvinden peger på et bestemt sted på en bærbar skærm, mens manden lytter med hånden under hagen. Tre bunker papir ligger sorteret foran dem.">
  <figcaption>Review efter risiko: Find de få steder, der skal læses, og læs dem ordentligt.<span class="hi-illustration-credit">AI-genereret illustration. Ikke en gengivelse af konkrete personer eller virksomheder.</span></figcaption>
</figure>

### Hvor meget kode jeg læser

Et review af planen kan ikke erstatte et review af koden. Det kan kun gøre det hurtigere. Kodebaser, som agenter ejer alene, falder fra hinanden over nogle måneder, hvis ingen læser med. Men at læse hver linje holder ikke, når agenterne skriver mere, end du kan nå.

Jeg læser det, der bærer: datamodellen, API'erne, invarianterne, de nederste lag og filerne på listen over risiko. Resten tjekker jeg gennem beviset og sporene fra kørslerne. Læs noget i hvert lag hver gang. Modellerne glider, og det ser du kun, hvis du kigger.

Læsbarhed betyder mindre, end den gjorde. Det vigtige er, at agenten kan køre og tjekke koden. Men navnene skal stadig følge jeres fagsprog, og den vigtige kode skal et menneske kunne gå ind i.

**Mit valg.** Jeg læser hele ændringen, når den ligger i højrisikozonen, når den bygger noget, mange andre ting kommer til at hvile på, eller når kontrollerne ikke er stærke nok endnu. Ellers læser jeg datamodellen, API'et og de vigtigste filer.

---

## Merge og release

### Agenter må merge udvalgte ændringer

Reglen for merge er en politik, ikke en person. Skriv den i en fil ved siden af koden, fx merge-gate.md. Agenten læser den før hver merge og må ikke ændre den uden at spørge.

En ændring må kun merges automatisk, hvis tre ting holder:

- Den kan beskrives i en kort sætning.
- Der er kontroller, der tjekker netop den slags ændring, ud over grønne tests.
- En forkert merge er billig. Den kan rulles tilbage, og ingen mister penge, adgang eller data.

Ændringer i login, nøgler, rettigheder, betaling, priser, juridisk tekst, migreringer og skema venter altid på et menneske. Kosmetiske ændringer kræver én runde review og et billede før og efter. Ændringer i logik kræver to runder review og en kørsel af hvert nyt eller ændret forløb i en rigtig browser eller på en rigtig enhed. Ved mellem eller høj risiko skal agenten også skrive, hvilken logning der ville afsløre en fejl efter udrulning.

Det er fint at starte med et menneske på merge og åbne reglen, når kontrollerne har vist, at de holder. Målet er det samme. Når en PR når et menneske, har agenten allerede bygget ændringen, kørt review, tjekket den, samlet bevis og fået testene grønne.

### Del merge, release og udrulning op

Agenten må gerne merge til drift. Den må ikke tænde for noget i drift. Sæt nye funktioner bag et feature flag, der er slukket som standard. Så kan et menneske eller en målt udrulning tænde. En agent kan godt styre en udrulning, der starter ved 0,01 procent af brugerne og vokser. Men ryd op i flagene bagefter. Glemte flag ved 1 procent koster mange timer senere.

En rettelse er ikke leveret, når den er merget. Den er leveret, når den er med i en udgivelse, brugerne kører.

Lad agenten skrive en plan i PR'en for, hvad der skal holdes øje med efter udrulning, hvad der er normalt, og hvor længe. Jo større skade en fejl kan gøre, jo længere tid. Går det galt, slukkes et feature flag, hvis der er et. Ellers laves en hurtig rettelse gennem samme regel for merge, og ellers rulles der tilbage. Agenten skal spørge, før den ruller tilbage. Og husk, at et feature flag ikke redder en migrering.

---

## Fabrikken lærer

### Hver gang et menneske griber ind, er det en fejl i systemet

Skriv en kort postmortem, hver gang et menneske har måttet styre en agent. Gennemgå dem en gang om ugen, og forbedr harnessen ud fra dem. En postmortem foreslår ændringer, men laver dem aldrig selv. En løkke samler forslagene fra en periode, fjerner dubletter og viser dem for et menneske i én tabel. Først efter et ja bliver de skrevet ind.

Pas på med råd fra én enkelt session. De kan passe for godt til netop den.

### Fabrikken som kode

Hele fabrikken skal ligge som filer i et repo: agenter, skills, MCP-servere, modeller, triggere og målinger. Så får du historik, mulighed for at rulle tilbage, grene til forsøg og godkendelse af ændringer. Agenter kan foreslå ændringer som en diff. Regn med, at mange forslag bliver afvist. Den typiske fejl er et forslag, der er for tilpasset til én bemærkning fra én bruger.

### Mål på jeres egne kørsler

Saml tidligere opgaver til en privat benchmark. Når en ny model eller skill kommer, kører du opgaverne igen og sammenligner. Gem model, miljø og den commit, du startede fra. Skjul alt, der afslører svaret: senere commits, den færdige PR og status i sagssystemet. Ellers snyder agenten.

Det er ikke billigt. Der er billigere udgaver. Tag en commit fra før en rettelse, og kør den samme prompt med og uden en ny skill. Eller giv en frisk session kun målet, som beskrevet under [Skær i instruktionerne](#skær-i-instruktionerne-byg-flere-kontroller).

### Hvad man skal måle

Mål på fire ting. Ingen af dem er antal PR'er eller antal agenter.

- **Menneskelige indgreb pr. PR.** Det er ikke enten-eller, men et tal, du skal have ned.
- **Pris pr. merget PR.** Og tiden fra samtalen starter, til PR'en er merget. Ikke antal linjer eller tokens.
- **Udbytte.** Hvad er værd at producere for jer? Trappen går fra PR'er over features til værdi for forretningen. Jo højere oppe, jo sværere at måle.
- **Spildte skridt.** En agent, der prøver seks kommandoer, før den finder ud af, hvordan testene køres, er et skridt, der bør blive til en skill. Mål også, hvor længe agenten venter på et menneske.

Gem hver session, og gå dem igennem hver uge. Hvor går pengene hen? Tit går det meste til at læse. Agenter læser filer med Bash, faste instrukser er for lange, og nogle tråde starter alt for mange subagenter. Ret det med hooks, der stopper Bash som læser, kortere output og billigere modeller til faste kørsler. Lad også en agent holde øje med prisen på jeres tjenester hver dag. En regning, der stiger, opdager ingen ellers.

---

## Hvad mennesker beholder

Nogle ting bliver hos mennesker. Hvor grænsen går, varierer fra fabrik til fabrik.

| Hvad mennesket beholder | Hvad det betyder i praksis |
|---|---|
| Mål, rammer og hvad der er værd at bygge | Kvaliteten af produktet kan ikke overlades til agenter |
| Risiko, tilladelser og ændringer, der sletter noget | Login, nøgler, betaling, jura, privatliv og sikkerhed |
| Datamodel, API'er og navne | Navne og lag, der skal laves om, selv når testene er grønne |
| Merge eller i hvert fald aktivering | Et menneske tænder for feature flaget |
| Varige ændringer i harness og skills | Forslag fra postmortems bliver godkendt, før de skrives ind |
| Hvor meget der er i gang ad gangen | Din opmærksomhed er flaskehalsen |
| Svære designproblemer | Store omlægninger og arkitektur forlader løkken |

### Hvor kommer dømmekraften fra?

Agenterne har overtaget den taktiske del af at programmere. Min bekymring er, at juniorer så ikke får den træning, der fører til dømmekraft. Skriver du ikke selv koden, holder du måske op med at mærke, når arkitekturen er dårlig. Før måtte man stoppe og rydde op, når den blev uholdbar. Nu kæmper agenterne sig bare igennem.

Jeg har ikke svaret. Men en junior vokser stadig, når vedkommende får en proces og små opgaver at starte med. Fabrikken kan bygge noget af læringen ind i systemet. Og nogle gange er det rigtige at tale med et menneske i stedet for en agent.

---

## Mine valg på én side

| Område | Mit valg | Undtagelsen |
|---|---|---|
| **Mål eller struktur** | Giv agenten et målbart mål. | Aftal strukturen først ved en datamodel, et offentligt API eller data, der gemmes. |
| **Krav** | Udgiv småt og lær af det. | Giv alle krav med ved en migrering eller et system, jeg kender. |
| **Bygger** | Én agent bygger hele featuren. | En frisk agent pr. sag ved små fejlrettelser. |
| **Harness** | Skær i instruktionerne, byg flere kontroller. | Ingen. Mål hver ændring for sig. |
| **Læse kode** | Datamodel, API og filer med risiko. | Hele ændringen i højrisikozonen eller ved svage kontroller. |
| **Merge** | Agenter merger udvalgte ændringer efter en skrevet regel. | Login, betaling, priser, jura, migreringer og skema. |

Valgene kan godt være forskellige for forskellige dele af kodebasen. Én proces for små fejl og en anden for designarbejde er helt normalt.

---

## Kom i gang: en plan for den første måned

Sådan starter jeg med et hold på et par udviklere, der allerede bruger en kodeagent.

**Uge 1: miljøet.** Gå de fire punkter fra tjeklisten igennem: login uden rigtig udbyder, stubs for eksterne tjenester, opsætning i repoet og adgangskontrol. Lav én kommando, der kører testene og giver et kort svar. Agenten skal ikke prøve seks kommandoer for at finde den. Skriv udskriften fra udviklingsserveren til en fil, og peg på den i AGENTS.md. Så kan agenten læse fejlene uden at styre serveren.

**Uge 2: én løkke.** Vælg en type opgave, der kommer igen og kan genskabes. Kig efter tre tegn. I kopierer ting mellem værktøjer, fx kommentarer fra et review i Codex over i Claude. I har et fast ritual, når noget er færdigt, fx changelog og en besked i Slack. Eller I tjekker noget hver morgen, fx Sentry. Gør opgaven i hånden et par gange først, så I ved, hvordan godt ser ud. Det kan også være opdatering af afhængigheder. Vælg en opgave med lav risiko og en klar ejer. Byg løkken sådan: Opgaven kommer ind, agenten genskaber fejlen, skriver en sag med bevis, et menneske godkender, en agent laver en PR, testene og en AI-reviewer kører, højst tre runder, og et menneske merger.

**Uge 3: bevis og risiko.** Lad hver PR vise, hvad der er tjekket, og hvordan. Kræv video ved ændringer i brugerfladen. Skriv en liste over filer og mapper, der altid kræver et menneske: login, migreringer, betaling, opsætning i drift og sletning.

**Uge 4: læring og måling.** Skriv en kort postmortem, hver gang et menneske måtte styre agenten. Gennemgå dem om fredagen og vælg én ændring. Begynd at måle menneskelige indgreb pr. PR og pris pr. merget PR.

**Det skal I ikke starte med.** Mange agenter på én gang, for alt igangværende arbejde er gæld. Et hold af agenter, hvor én tager frontend, én tager backend og én tager sikkerhed, og hvor de skal koordinere med hinanden for at bygge samme feature. Det giver mest koordinering og sjældent bedre kode. Lad én agent bygge hele featuren. Automatisk merge, før kontrollerne har vist, at de holder. Og en løkke, der løser hele jeres backlog. De PR'er bliver aldrig set igennem, og så vender udviklerne sig mod hele idéen.

Du behøver ikke bygge hele fabrikken på én gang. Lad gerne en af jeres bedste udviklere bruge en måned på at prøve, også selvom det går galt.

---

## Til lederen

Du skal godkende noget, der lyder som et stort projekt. Det behøver det ikke at være.

**Tid.** Regn med et par uger til udviklingsmiljøet, før fabrikken leverer noget. Byg ikke i tre måneder uden at levere værdi undervejs. Start med én løkke, og lad den betale for den næste.

**Penge.** Maskinerne er den lille post. Tokens fylder langt mere. Mere produktivitet koster flere tokens, så mål pris pr. merget PR fra første dag.

**Spørg holdet om tre ting.** Hvor mange gange pr. PR et menneske må gribe ind. Hvad en merget PR koster i tokens og maskiner. Og hvilke ændringer der altid kræver et menneske, og hvem det er.

**Risikoen ligger i adgangene.** En agent skal ikke kunne mere end en ny medarbejder. Nøgler og koder skal blive uden for dens maskine. Har I data om personer, eller er I under tilsyn, så spørg, hvordan de data holdes ude af modellen.

En softwarefabrik er én proces for ét hold. Hvis I vil have hjælp til at bygge den første løkke, er det det, [Agent in a Box](https://primux.dk/agent-in-a-box/) på primux.dk handler om.

---

## Hvem jeg henter inspiration fra

Guiden er min, men meget af den har jeg lært af andre. Mest af Ray Amjad og Dex Horthy, en del af Vaibhav Gupta og lidt fra de andre. De kører en softwarefabrik, bygger værktøjer til det eller underviser i det.

- **Ray Amjad** laver YouTube-videoer om at kode med agenter og driver [agenticcoding.school](https://www.agenticcoding.school/cohort). Her sælger han blandt andet kurset The Software Factory Engineer. Han bygger sine egne produkter med agenter, der styres fra Slack.
- **Matt Pocock** underviser i TypeScript og AI-udvikling gennem Total TypeScript og AI Hero. Han udgiver et åbent sæt skills til Claude Code og Codex.
- **Dex Horthy** er medstifter af HumanLayer, der 4. november 2026 meldte, at de går sammen med Factory. Han er vært på AI That Works.
- **Vaibhav Gupta** er medstifter af Boundary, der laver programmeringssproget BAML. Han er den anden vært på AI That Works.
- **Zach Lloyd** er stifter og CEO af Warp. Warp sælger en platform til softwarefabrikker, Warp Factories.

Flere af dem tjener penge på emnet. Ray og Matt sælger kurser. Zach sælger Warp Factories. Boundary sælger BAML. Husk det, når de fortæller om deres egne resultater.

Rays betalte kursus, The Software Factory Engineer, går længere end hans videoer. Holdet, guiden bygger på, startede 9. november 2026. Kurset er gengivet med mine egne ord.

---

## Om eksemplerne

Planen for den første måned, trappen for bevis og niveauerne for risiko har jeg sat sammen selv. Eksemplerne i guiden, fx invitationen og cachen, er lavet til at vise en pointe. De handler ikke om en bestemt virksomhed.



## Ofte stillede spørgsmål

### Hvad er en softwarefabrik?

Et system, hvor kodeagenter tager en opgave fra den kommer ind til en færdig PR. Opgaven kan komme fra en sag, en Slack-besked, en alarm eller en planlagt kørsel. Agenter skriver koden, andre agenter tjekker den, og et menneske træder til ved de beslutninger, der kræver det.

### Hvad er forskellen på en kodeagent og en softwarefabrik?

En kodeagent som Claude Code eller Codex er ét værktøj, du selv sidder og styrer. En fabrik er løkken rundt om: noget, der starter arbejdet, et miljø, agenten kan teste i, kontroller, review, regler for merge og målinger. Mange terminaler med agenter side om side er ikke en fabrik.

### Hvad er det sværeste ved at bygge en softwarefabrik?

Udviklingsmiljøet og de delte sessioner, når I er flere. Agenten skal kunne logge ind, køre appen og teste sit eget arbejde. Typiske huller er login, der kun virker med Google, manglende stubs for eksterne tjenester, opsætning uden for repoet og svag adgangskontrol.

### Er grønne tests nok til at stole på agentens kode?

Nej. Tests, agenten selv har skrevet, kan være grønne, mens datastrukturen er forkert. Brug en facitliste, agenten ikke selv har lavet, test på den rigtige overflade som browser eller API, og video ved ændringer i brugerfladen.

### Skal mennesker stadig læse den kode, agenter skriver?

Ja, men ikke alt. Jeg læser datamodellen, API&#39;erne og de filer, der bærer risiko, og stoler ellers på bevis fra kørslerne. Ændringer i login, betaling, migreringer og sletning ses altid af et menneske.

### Må AI-agenter selv merge kode?

Ja, for udvalgte ændringer efter en skrevet regel: Ændringen er lille, beviset er stærkt, og den kan rulles tilbage. Ændringer i login, betaling, priser, jura og skema venter altid på et menneske. En mellemvej er at lade agenten merge, mens et menneske tænder for funktionen med et feature flag.
