Pi Coding Agent: Vibe Coding I 13 Trin [2026]

Vibe coding har på under to år gået fra Andrej Karpathys spøgefulde udtryk til en reel arbejdsmetode i danske udviklerteams. Men de fleste guider til vibe coding bygger på tunge IDE-integrationer som Cursor eller Cline, hvor AI-agenten sidder skjult bag et brugerinterface, du ikke fuldt kontrollerer. Pi Coding Agent går den modsatte vej: et minimalt, hackbart kommandolinjeværktøj, hvor du selv bestemmer, hvor meget agenten må røre ved din kode. Denne guide viser, hvordan du installerer, konfigurerer og udvider Pi Coding Agent version 0.84.2 fra bunden, med et komplet eksempelprojekt du kan følge trin for trin.

Ifølge Simon Willison, uafhængig udvikler og skribent, handler vibe coding om at “building software with an LLM without reviewing the code it writes” (simonwillison.net). Det er præcis den holdning, Pi Coding Agent udfordrer: værktøjet er bygget til udviklere, der vil have AI-hjælp, men stadig insisterer på at se hver linje kode, før den bliver committed.

Denne artikel er skrevet som en praktisk gennemgang, ikke en teoretisk introduktion. Du får de præcise kommandoer, der skal køres i terminalen, den kode, agenten typisk foreslår, og de tests, du bør kræve, før noget rammer din hovedbranch. Undervejs bygger vi et lille, men realistisk TypeScript-projekt, der validerer danske telefonnumre og CVR-numre, netop det slags afgrænsede, veldefinerede opgaver, hvor en agent som Pi gør størst nytte uden at kompromittere kodekvaliteten.

Guiden er bygget op i 13 konkrete trin, som du kan følge i rækkefølge eller springe imellem, hvis du allerede har noget af grundopsætningen klar. Overblikket ser sådan ud.

Bekræft Node.js- og Git-version
Installer Pi Coding Agent globalt via npm
Verificer installationen med pi --version
Opret et isoleret testprojekt
Initialiser Git og en dedikeret arbejdsbranch
Start Pi i projektmappen
Giv agenten kontekst uden at ændre filer
Bed om en implementeringsplan
Godkend planen eksplicit
Implementer én afgrænset ændring
Generer og kør tests med Vitest
Gennemgå git diff, og godkend commit manuelt
Byg din egen TypeScript-udvidelse til Pi

Hvad er Pi Coding Agent, og hvorfor er den anderledes?

Pi Coding Agent er en terminalbaseret AI-kodeagent, der distribueres som npm-pakken @earendil-works/pi-coding-agent. Den nyeste version, 0.84.2, blev udgivet 14. august 2026, og adskiller sig fra de fleste konkurrenter ved at være bevidst minimal: der er ingen grafisk brugerflade, ingen browserplugin og ingen skjult telemetri-dashboard. Alt sker i din terminal, og alt kan læses, ændres og udvides, fordi kildekoden er tilgængelig på GitHub under organisationen earendil-works.

Navngivningen @earendil-works/pi-coding-agent følger den samme scoped-package-konvention, som mange virksomheder bruger til intern software: navnet på organisationen sikrer, at ingen andre kan udgive en pakke med samme navn under et andet formål, og det gør det lettere for sikkerhedsansvarlige at godkende afhængigheden i en intern liste over tilladte pakker. For teams med krav om revisionsspor er det en praktisk detalje, fordi hele værktøjets adfærd kan gennemgås linje for linje, i modsætning til lukkede IDE-plugins, hvor den faktiske model-kommunikation ofte er skjult bag en kompileret klient.

Minimalismen betyder også, at Pi ikke bundler en fast model. Ligesom flere andre terminal-agenter er værktøjet bygget til at pege på en ekstern model-API, du selv konfigurerer, i stedet for at låse dig til en enkelt udbyder. Det giver dig frihed til at vælge model efter opgave, budget eller interne krav til databehandling, men det betyder også, at du selv har ansvaret for at sætte adgangsnøgler og rettigheder korrekt op, før du går videre til de næste trin.

Filosofien bag Pi ligger tæt på det, Simon Wardley, forsker og strateg, har advaret om ved dårligt anvendt vibe coding: “Just remember, when you are vibe coding, if you don’t look at the code then you’re not software engineering” (LinkedIn). Pi er designet til at tvinge dig til netop det: agenten præsenterer en plan, venter på godkendelse, og viser en git diff, før noget rører din kodebase. Det gør værktøjet velegnet til teams, der vil have fart uden at give agenten frie tøjler.

Andrej Karpathy, tidligere medstifter af OpenAI og AI-direktør hos Tesla, har beskrevet den brede udvikling med ordene “Programming is becoming unrecognizable” (Business Insider). Pi Coding Agent er et konkret eksempel på den udvikling: en agent, der kan læse et helt repository, formulere en ændringsplan og implementere en afgrænset feature, uden at du selv skriver boilerplate-koden.

2026 har generelt budt på en bølge af terminalbaserede kodeagenter, hvor både store og små udbydere har skiftet fokus fra rene chatvinduer til agenter, der selv kan læse filer, køre kommandoer og foreslå ændringer direkte i din projektmappe. Det, der adskiller de enkelte værktøjer fra hinanden, er sjældent den grundlæggende idé, men snarere hvor meget kontrol du som udvikler bevarer over, hvad agenten rent faktisk må gøre uden at spørge først. Pi Coding Agent placerer sig tydeligt i den kontrollerede ende af det spektrum, hvilket er den vinkel, resten af denne guide bygger videre på.

Forudsætninger: software og versioner du skal have klar

Før du starter, skal du have et par grundværktøjer installeret. Pi Coding Agent kører oven på Node.js, og selve installationen sker via npm. Tabellen nedenfor viser, hvad du skal bruge, og hvordan du tjekker, at det er på plads.

Værktøj	Minimumsversion	Tjek installeret version	Formål
Node.js	20.x LTS	`node --version`	Kører npm-pakken og TypeScript-kompileringen
npm	10.x	`npm --version`	Installerer Pi Coding Agent globalt
Git	2.40+	`git --version`	Sikker branch-baseret arbejdsgang og diff-gennemgang
TypeScript	5.x (lokal devDependency)	`npx tsc --version`	Typet kodebase til eksempelprojektet
Vitest	Nyeste 2.x-serie	`npx vitest --version`	Automatiske tests, agenten kan generere og køre
Terminal/shell	Bash, zsh eller WSL2 på Windows	–	Miljø, Pi kører i

Du behøver ikke en bestemt editor eller IDE. Pi Coding Agent er editor-uafhængig, så du kan bruge VS Code, Neovim eller noget helt tredje til at læse koden, mens agenten arbejder i terminalen. Afsæt cirka 50 minutter til at følge alle trin i denne guide, inklusive installation, det første agentforløb og opbygning af en simpel udvidelse.

Node.js 20 LTS er valgt som minimum, fordi det er den version, de fleste moderne CLI-værktøjer i npm-økosystemet tester imod, og fordi den understøttes med sikkerhedsopdateringer længere frem end ældre versioner. Git 2.40 eller nyere sikrer, at kommandoer som git switch og forbedret konflikthåndtering fungerer som forventet, hvilket bliver relevant, hvis du senere vil eksperimentere med at lade agenten arbejde på flere brancher samtidig. TypeScript er ikke et krav fra Pi Coding Agent selv, men fra eksempelprojektet i denne guide, som er valgt netop fordi typet kode gør det lettere for både dig og agenten at fange fejl tidligt, før de rammer en testkørsel. Du kan læse mere om selve testrammen i den officielle Vitest-dokumentation, hvis du vil dykke dybere ned i konfigurationsmulighederne, end denne guide dækker.

Trin 1-3: Installer Node.js, Git og Pi Coding Agent

Start med at bekræfte, at Node.js og Git allerede findes på maskinen. Hvis ikke, hent Node.js 20 LTS fra det officielle projekt, og installer Git via din pakkehåndtering (apt, brew eller winget). Når begge er på plads, installerer du selve agenten globalt med npm.

node --version
git --version

npm install -g --ignore-scripts @earendil-works/pi-coding-agent

pi --version

Flaget --ignore-scripts er der med vilje: det forhindrer, at pakken kører vilkårlige post-install-scripts på din maskine, hvilket er god praksis, når du installerer et nyt CLI-værktøj globalt. Når kommandoen er færdig, bør pi --version vise noget i stil med følgende output.

pi coding agent v0.84.2
node v20.18.1
platform: linux-x64

Hvis du i stedet får en fejl om, at kommandoen ikke findes, har npm sandsynligvis installeret pakken uden at tilføje binærfilen til din PATH. Det retter vi i fejlfindingsafsnittet senere i artiklen.

Trin 4-6: Opret et sikkert testprojekt og start agenten

Kør aldrig en ny AI-agent direkte i et produktionsrepository, første gang du tester den. Opret i stedet et isoleret testprojekt, initialiser Git, og opret en dedikeret arbejdsbranch. Det giver dig en fuld historik at rulle tilbage til, hvis agenten laver noget uventet.

mkdir pi-demo && cd pi-demo
git init
git checkout -b agent/telefon-validator

npm init -y
npm install -D typescript tsx vitest @types/node
npx tsc --init

pi

Når du kører pi uden argumenter i projektmappen, starter agenten i en interaktiv session, der scanner mappestrukturen og opretter en let kontekstfil, den bruger til at huske projektets opsætning mellem beskeder. Første gang tager scanningen typisk et par sekunder på et lille projekt som dette.

Trin 7-9: Fra kontekst til implementeringsplan og godkendelse

Den vigtigste vane at lære, når du arbejder med Pi Coding Agent, er at bede om en plan, før du beder om kode. Det er præcis den arbejdsgang, der skiller kontrolleret vibe coding fra det, Karpathy selv har beskrevet som at “just see stuff, say stuff, run stuff, and copy-paste stuff, and it mostly works” (Business Insider). Med en synlig plan og en obligatorisk godkendelse undgår du netop det improviserede forløb.

Analyser projektet uden at ændre filer.
Foreslå en plan for at validere og normalisere danske telefonnumre
(fjern mellemrum, konverter landekode 0045/+45 til et samlet format).
Vent på min godkendelse, før du redigerer noget.

Agenten svarer typisk med en nummereret plan i stil med: opret src/phone.ts, implementer funktionen normalizeDanishPhone, tilføj tests i src/phone.test.ts, og opdater package.json med et testscript. Gennemlæs planen, og godkend den eksplicit, før du går videre. Det er dette godkendelsestrin, der gør Pi til et redskab for disciplineret vibe coding snarere end blind automatisering.

Hvis planen indeholder noget, du er uenig i, for eksempel at agenten foreslår et biblioteksafhængighed, du ikke ønsker i projektet, er dette tidspunktet at sige det. Skriv en kort besked som “brug ikke eksterne biblioteker til dette, kun indbygget regex”, og bed om en revideret plan. Den ekstra runde tager typisk under et minut og forhindrer, at du ender med en unødvendig afhængighed i et lille valideringsprojekt.

Trin 10-12: Implementering, tests og git diff med manuel godkendelse

Når planen er godkendt, kan du bede agenten om at implementere ét skridt ad gangen. Start med selve funktionen, og lad agenten foreslå koden, før den rører filsystemet.

export function normalizeDanishPhone(input: string): string {
  const digitsOnly = input.replace(/\s+/g, "");
  if (digitsOnly.startsWith("0045")) {
    return "+45" + digitsOnly.slice(4);
  }
  if (digitsOnly.startsWith("+45")) {
    return digitsOnly;
  }
  return "+45" + digitsOnly;
}

Bed derefter agenten om at tilføje tests med Vitest, så du har en objektiv måde at bekræfte, at ændringen virker, uden selv at skulle køre koden manuelt gennem en række eksempler.

import { describe, it, expect } from "vitest";
import { normalizeDanishPhone } from "./phone";

describe("normalizeDanishPhone", () => {
  it("konverterer 0045-præfiks til +45", () => {
    expect(normalizeDanishPhone("0045 12 34 56 78")).toBe("+4512345678");
  });

  it("bevarer eksisterende +45-format", () => {
    expect(normalizeDanishPhone("+45 12345678")).toBe("+4512345678");
  });

  it("tilføjer +45 til rå numre", () => {
    expect(normalizeDanishPhone("12 34 56 78")).toBe("+4512345678");
  });
});

Før du lader agenten køre testkommandoen, skal du kigge på diffen. Bed om det direkte, og kræv en eksplicit bekræftelse, før noget commites.

git diff --stat
git diff src/phone.ts

npx vitest run

Et typisk testoutput på dette trin ser sådan ud, og det er dit signal til at godkende commit, ikke agentens. Læg mærke til, at kommandoen køres af dig, ikke automatisk af agenten, selv hvis den netop har foreslået den. Den lille friktion, at du selv trykker enter på testkommandoen, er en bevidst del af arbejdsgangen: den tvinger et sekund til refleksion ind, lige før koden anses for godkendt.

 ✓ src/phone.test.ts (3 tests) 4ms
   ✓ normalizeDanishPhone > konverterer 0045-præfiks til +45
   ✓ normalizeDanishPhone > bevarer eksisterende +45-format
   ✓ normalizeDanishPhone > tilføjer +45 til rå numre

 Test Files  1 passed (1)
      Tests  3 passed (3)

Trin 13: Byg din egen TypeScript-udvidelse til Pi

Det, der reelt gør Pi Coding Agent interessant for erfarne udviklere, er at værktøjet er hackbart. Fordi kildekoden er åben på GitHub under earendil-works, kan du læse, hvordan kommandoer og workflows er bygget op, og selv skrive små TypeScript-baserede udvidelser, der tilføjer projektspecifikke kommandoer, for eksempel en genvej, der altid kører lint og tests, inden agenten får lov at foreslå en commit-besked.

// .pi/workflows/pre-commit-check.ts
export async function preCommitCheck(ctx: { run: (cmd: string) => Promise }) {
  const lintCode = await ctx.run("npx eslint . --max-warnings=0");
  const testCode = await ctx.run("npx vitest run");

  if (lintCode !== 0 || testCode !== 0) {
    throw new Error("Lint eller tests fejlede, commit blokeret");
  }
}

Denne type workflow-fil kan du registrere, så Pi automatisk kalder den, hver gang agenten er ved at foreslå en commit. På den måde flytter du kvalitetskontrollen fra “noget jeg husker at gøre manuelt” til “noget værktøjet ikke kan springe over”, hvilket er en markant anden tilgang end de fleste chatbaserede assistenter.

Udvid eksemplet: valider danske CVR-numre med samme arbejdsgang

Den bedste måde at se, om arbejdsgangen faktisk skalerer, er at gentage den på en ny, afgrænset opgave i samme projekt. Bed agenten om at udvide validatoren, så den også kan tjekke, om et dansk CVR-nummer har det korrekte format: otte cifre uden mellemrum eller bindestreger. Brug samme mønster som før, plan først, implementering bagefter.

Analyser den eksisterende kode i src/phone.ts uden at ændre den.
Foreslå en plan for at tilføje en funktion isValidCvr, der returnerer
true, hvis input er præcis 8 cifre, og false i alle andre tilfælde.
Tilføj funktionen i en ny fil src/cvr.ts, og skriv tilhørende tests.
Vent på min godkendelse, før du skriver noget.

Når agenten har fået godkendelse, foreslår den typisk en implementering som denne, der bevidst holder logikken simpel, fordi opgaven kun handler om formatvalidering, ikke om at slå op i en officiel virksomhedsdatabase.

export function isValidCvr(input: string): boolean {
  const trimmed = input.replace(/[\s-]/g, "");
  return /^\d{8}$/.test(trimmed);
}

Testene, agenten genererer til den nye funktion, følger samme struktur som telefonnummer-eksemplet, hvilket er en fordel i sig selv: når arbejdsgangen er ensartet, bliver det lettere for et menneskeligt review at genkende mønstret og fokusere på det, der faktisk er nyt i ændringen.

import { describe, it, expect } from "vitest";
import { isValidCvr } from "./cvr";

describe("isValidCvr", () => {
  it("accepterer 8 cifre uden formatering", () => {
    expect(isValidCvr("12345678")).toBe(true);
  });

  it("accepterer 8 cifre med bindestreg", () => {
    expect(isValidCvr("1234-5678")).toBe(true);
  });

  it("afviser numre med forkert længde", () => {
    expect(isValidCvr("123456")).toBe(false);
  });

  it("afviser input med bogstaver", () => {
    expect(isValidCvr("1234ABCD")).toBe(false);
  });
});

Gennemgå igen git diff, kør npx vitest run, og godkend commit manuelt. Denne anden runde tager typisk kortere tid end den første, fordi du allerede kender agentens svarmønster og ikke behøver at genforklare projektets konventioner. Det er her, den reelle tidsbesparelse ved en kontrolleret arbejdsgang bliver synlig: du bruger ikke mindre tid på at læse kode, men du bruger markant mindre tid på at skrive den boilerplate, tests og typedefinitioner, som ellers fylder en stor del af en almindelig arbejdsdag.

Sammenligning: chat, agent-tilstand og kontrolleret workflow

Når du vælger, hvordan du vil bruge et værktøj som Pi Coding Agent, er der i praksis tre arbejdsformer at vælge mellem. De adskiller sig markant i, hvor meget kontrol du bevarer, og hvor hurtigt du kommer i mål.

Arbejdsform	Hastighed	Din kontrol	Risiko for uset kode	Bedst til
Ren chat (copy-paste)	Høj	Lav (du copy-paster uden struktur)	Høj	Hurtige eksperimenter, engangsscripts
Agentstyret filredigering (auto-godkend)	Meget høj	Meget lav (agenten redigerer frit)	Meget høj	Prototyper i wegwerp-projekter
Kontrolleret workflow (plan, godkend, diff, test)	Middel	Høj (du godkender hvert trin)	Lav	Produktionskode, teamarbejde, regulerede brancher

Pi Coding Agent understøtter alle tre tilstande, men er designet til at gøre den kontrollerede workflow til standarden snarere end undtagelsen. Det er en modsat prioritering af mange konkurrerende værktøjer, hvor auto-godkendelse ofte er den hurtigste vej og derfor den, folk falder tilbage på under tidspres.

I praksis oplever de fleste teams, at de bevæger sig mellem alle tre tilstande afhængigt af opgaven. En ren chat-session er fin til at forstå en fejlmeddelelse eller diskutere en arkitekturbeslutning, hvor der ikke skal skrives kode med det samme. Agentstyret filredigering med auto-godkendelse kan give mening i et wegwerp-prototype, du kaster væk om en uge. Men så snart koden skal leve videre i et produktionsrepository, er den kontrollerede workflow den eneste af de tre, der giver dig et reelt revisionsspor: hvem godkendte hvad, hvornår, og på baggrund af hvilken plan. Det spor bliver særligt værdifuldt, hvis en fejl senere skal spores tilbage til en bestemt ændring.

Sikkerhed: sådan begrænser du agentens adgang til din kode

Fordi Pi kører som et almindeligt terminalprogram med adgang til dit filsystem, bør du behandle det med samme forsigtighed som et andet CLI-værktøj, du ikke selv har skrevet. To grupper af regler reducerer risikoen markant: dem, der begrænser filsystem-adgang, og dem, der begrænser hvilke kommandoer agenten må udføre.

Begræns filsystem-adgang

Kør altid på en dedikeret Git-branch, aldrig direkte på main eller en delt release-branch. Undgå at give agenten adgang til mapper med hemmeligheder, som .env-filer eller SSH-nøgler, ved at holde dem uden for projektmappen eller ekskludere dem via en ignorefil, hvis din version understøtter det. Hvis projektet i forvejen har en .gitignore, er det et godt udgangspunkt, men bemærk, at en gitignore-regel kun forhindrer filer i at blive committed, den forhindrer ikke nødvendigvis agenten i at læse dem under en session, så flyt følsomme filer fysisk væk fra projektroden, hvis det er en bekymring.

Begræns kommandoer, der rører netværk og system

Kræv manuel godkendelse ved enhver kommando, der rører netværket, sletter filer eller skriver til systemstier uden for projektet. Kør desuden agenten under en bruger med begrænsede rettigheder på delte udviklingsmaskiner, så en fejlagtig kommando ikke kan påvirke andre projekter eller andre brugeres data. På CI-servere bør agenten aldrig køre med de samme rettigheder som deployment-jobbet, netop for at undgå, at en enkelt fejlfortolket instruktion kan nå produktionsmiljøet.

Disse regler er ikke unikke for Pi, men bliver særligt vigtige, fordi værktøjets styrke, at være hackbart og fleksibelt, også betyder, at det er lettere at konfigurere forkert end et lukket, sandboxed IDE-plugin, hvor producenten allerede har lagt begrænsningerne ind for dig.

5 almindelige faldgruber ved vibe coding med AI-agenter

Den første faldgrube er at godkende planer uden at læse dem ordentligt. Når en agent foreslår ti trin i streg, er det fristende at klikke godkend på autopilot, men netop her sniger fejlantagelser sig ind, for eksempel forkert fortolkning af eksisterende kodekonventioner.

Den anden faldgrube er at lade agenten køre destruktive kommandoer, som rm -rf eller databasemigrationer, uden eksplicit at bekræfte hver enkelt. Selv med en godkendelsesmekanisme er det let at skimme henover en kommando, du ikke selv ville skrevet manuelt.

Den tredje faldgrube er at springe testtrinnet over, fordi koden “ser rigtig ud”. Vitest-eksemplet tidligere i artiklen tager under fem minutter at sætte op og fanger regressionsfejl, som et hurtigt blik på koden ikke gør.

Den fjerde faldgrube er at bruge agenten på et repository med hemmeligheder i klartekst. Hvis en .env-fil med API-nøgler ligger i projektroden, kan agenten i teorien læse og inkludere den i sin kontekst, selv uden ond vilje fra værktøjets side.

Den femte faldgrube er at forvente, at agenten forstår forretningslogik, den ikke har set før. Pi Coding Agent er stærk til afgrænsede, veldefinerede opgaver som validering, refaktorering og testgenerering, men klarer sig dårligere på beslutninger, der kræver domænekendskab, du ikke har skrevet ned nogen steder i repositoriet. Løsningen er ikke at undgå agenten på den type opgaver, men at skrive den nødvendige kontekst ned i en kort kravspecifikation, du deler med agenten, før du beder om en plan, præcis som du ville gøre med en ny kollega, der lige er startet i teamet.

Fælles for alle fem faldgruber er, at de sjældent skyldes en fejl i selve AI-modellen. De opstår, fordi den kontrollerede arbejdsgang, planlægning, godkendelse, test og diff-gennemgang, bliver forkortet under tidspres. Den disciplin er lettere at holde fast i, når den er indbygget i selve værktøjet, hvilket er en af de klareste fordele ved Pi Coding Agents design.

Fejlfinding: 8 problemer og løsninger

De problemer, nybegyndere oftest rammer ind i, handler mere om npm og Node.js-miljøet end om agenten selv. Gennemgå listen nedenfor, før du antager, at fejlen ligger i Pi Coding Agent, da langt de fleste symptomer kan spores tilbage til en af de otte klassiske årsager herunder.

Kommandoen pi findes ikke efter installation: kør npm config get prefix, og bekræft, at den viste mappes bin-undermappe er i din PATH. Tilføj den til din shell-konfiguration, hvis den mangler.

Installationen fejler med rettighedsfejl på Linux eller macOS: undgå sudo npm install -g, og konfigurer i stedet en npm-mappe i din brugerprofil med npm config set prefix ~/.npm-global, så globale pakker ikke kræver root.

Agenten svarer meget langsomt eller timer ud: kontroller din internetforbindelse, og bekræft, at du ikke har ramt en rate-limit på den underliggende model-API, som Pi Coding Agent kalder i baggrunden. Store kontekstfiler, for eksempel hvis du peger agenten på et repository med tusinder af filer i én omgang, kan også forlænge svartiden markant, så afgræns konteksten til den mappe, opgaven faktisk vedrører.

Git diff viser uventede ændringer i filer, du ikke bad om at redigere: stop sessionen, kør git checkout -- . for at rulle ukommittede ændringer tilbage, og genstart med en mere afgrænset instruktion.

TypeScript-kompileringen fejler efter agentens ændringer: kør npx tsc --noEmit for at se alle typefejl samlet, og bed agenten rette dem én ad gangen i stedet for at acceptere en stor blok ændringer på én gang.

Vitest finder ingen tests: bekræft, at testfilerne følger navngivningen *.test.ts, og at testkonfigurationen eller standardopsætningen inkluderer din src-mappe.

Agenten glemmer tidligere kontekst midt i en session: start en ny session i stedet for at fortsætte en meget lang chathistorik, da lange sessioner kan miste præcision, når kontekstvinduet fyldes op med tidligere frem-og-tilbage.

Din egen TypeScript-udvidelse loader ikke: bekræft filstien i workflow-mappen, og kør pi --debug, hvis din version understøtter et debug-flag, for at se, om workflow-filen overhovedet bliver fundet og parset korrekt.

De fleste af disse otte problemer deler en fælles rettelse: kør altid den underliggende kommando direkte (npm, git, tsc eller vitest) uden om agenten, så du kan se den rå fejlmeddelelse. Agenter kan nogle gange formulere fejl om til en mere brugervenlig, men mindre præcis tekst, og den rå terminal-output er som regel den hurtigste vej til root cause.

Avancerede tips til erfarne brugere

Når du har kørt de 13 trin i denne guide igennem én gang, kender du allerede det grundmønster, de fleste avancerede brugere bygger videre på: plan, godkendelse, implementering, test, diff. De følgende tips handler om, hvordan du gør det mønster hurtigere at gennemføre, uden at fjerne de kontroltrin, der gør arbejdsgangen sikker.

Når du er komfortabel med grundforløbet, kan du begynde at kæde flere kontrollerede workflows sammen, for eksempel en pipeline, der først kører lint, dernæst tests, og til sidst genererer en commit-besked baseret på den faktiske diff i stedet for en generisk tekst. Det sparer tid uden at gå på kompromis med godkendelsestrinnet.

En anden avanceret teknik er at bruge agenten til kodegennemgang af egne pull requests, før du sender dem til et menneskeligt review. Bed agenten om specifikt at lede efter uafprøvede edge cases, ikke om at omskrive koden, så du bevarer ejerskabet over løsningen, men får et ekstra sæt øjne på potentielle fejl.

Endelig kan du, fordi Pi er open source på GitHub under earendil-works-organisationen, bidrage direkte til projektet eller forke det til interne behov, hvis dit team har specifikke krav til logning, godkendelsesflows eller integration med interne CI/CD-systemer, som den offentlige version ikke dækker ud af boksen.

Hvis du arbejder i et team, er det også værd at aftale en fælles konvention for, hvornår en agent-assisteret commit skal markeres som sådan, for eksempel med en fast præfiks i commit-beskeden. Det giver jer et søgbart spor, hvis I senere vil evaluere, hvor stor en andel af koden i et repository der er blevet til med agent-hjælp, og om den andel korrelerer med flere eller færre fejl rapporteret efter deployment.

Det komplette eksempelprojekt: dansk telefonnummer-validator

Sætter du alle trin i denne guide sammen, ender du med et lille, men komplet TypeScript-projekt: en funktion, der normaliserer danske telefonnumre, en tilhørende Vitest-testsuite, en Git-historik med tydelige, agent-assisterede commits, og en tilpasset workflow-fil, der tvinger lint og tests igennem, før noget commites. Mappestrukturen ser sådan ud, når du er færdig.

pi-demo/
├── .pi/
│   └── workflows/
│       └── pre-commit-check.ts
├── src/
│   ├── phone.ts
│   └── phone.test.ts
├── package.json
├── tsconfig.json
└── .git/

Fil eller mappe	Formål
`.pi/workflows/pre-commit-check.ts`	Din egen udvidelse, der tvinger lint og tests igennem før commit
`src/phone.ts`	Funktion til at normalisere danske telefonnumre
`src/phone.test.ts`	Vitest-tests for telefonnummer-funktionen
`src/cvr.ts`	Funktion til at validere CVR-numre, tilføjet i det udvidede eksempel
`src/cvr.test.ts`	Vitest-tests for CVR-validatoren
`package.json`	Projektets afhængigheder og scripts, inklusive test-kommandoen
`tsconfig.json`	TypeScript-kompilerens indstillinger for projektet

Dette lille projekt er med vilje simpelt, men mønstret skalerer: samme arbejdsgang med plan, godkendelse, implementering, tests og diff-gennemgang kan du bruge på et REST-API, en dataparser eller en intern CLI, blot med flere trin og flere filer involveret. Det, der ikke ændrer sig, er disciplinen omkring godkendelse, som er selve pointen med at vælge Pi Coding Agent over en mere automatiseret løsning.

Sammenligner du de to runder i denne guide, telefonnummer-funktionen og CVR-validatoren, er selve kodemængden lille i begge tilfælde. Værdien af arbejdsgangen ligger et andet sted: i den tid, du sparer på at skrive tests, holde styr på typedefinitioner og formulere en commit-besked, der faktisk beskriver ændringen. Den tid regner de fleste udviklere ikke med, når de vurderer, om et AI-værktøj er værd at investere i, men den udgør ofte en større andel af en almindelig arbejdsdag end selve den kreative problemløsning.

Vil du gå videre med andre kommandolinje-baserede AI-agenter, kan du sammenligne erfaringerne herfra med vores guide til GitHub Copilot CLI, eller se hvordan et lignende, men IDE-forankret værktøj fungerer i vores gennemgang af vibe coding med Cline. Hvis dit team allerede bruger flere agenter parallelt, er AGENTS.md-opsætningen en oplagt måde at give dem alle samme kontekstfil, mens en MCP-server kan give Pi adgang til flere eksterne datakilder på en struktureret måde. For teams, der foretrækker en anden agentarkitektur bygget på Sourcegraphs teknologi, er Amp-opsætningen også værd at kigge på.

For flere guider til AI-drevne udviklerværktøjer, se vores samlede dækning i kategorien software og udviklerværktøjer.

Tag med dig fra denne guide, at værdien af Pi Coding Agent ikke ligger i, hvor meget kode den kan skrive uden opsyn, men i hvor let den gør det at holde fast i en plan-godkend-test-diff-cyklus, som ellers let bliver skåret ned under et deadline-pres. De 13 trin, du har gennemgået, det udvidede CVR-eksempel og de otte fejlfindingspunkter giver dig et grundlag, du kan genbruge på næste opgave, uanset om det er en ny valideringsfunktion, en refaktorering eller en helt ny feature.

Ofte stillede spørgsmål om Pi Coding Agent og vibe coding

Er Pi Coding Agent gratis at bruge?
Selve npm-pakken er open source og gratis at installere. Den underliggende AI-model, agenten kalder for at generere svar, kan dog have egne omkostninger afhængigt af, hvilken model-API du konfigurerer den til at bruge, så det reelle regnestykke afhænger af din model-leverandør, ikke af Pi Coding Agent selv.

Kan jeg bruge Pi Coding Agent på Windows?
Ja, via WSL2, hvor du kører Node.js og npm som på Linux. Direkte native Windows-support uden WSL er ikke lige så udbredt testet, så WSL2 er den mest stabile vej.

Er Pi Coding Agent bedre end andre agent-værktøjer?
Det afhænger af arbejdsgangen. Pi er terminal-først og hackbar, mens mange andre agenter er tættere integreret i editoren med grafiske diff-visninger. Vælg efter, om du foretrækker terminal-workflow eller IDE-integration, og om dit team værdsætter, at hele værktøjets adfærd kan læses og ændres i åben kildekode.

Skal jeg altid oprette en ny Git-branch, før jeg bruger agenten?
Det anbefales kraftigt. En dedikeret branch gør det trivielt at forkaste alle agentens ændringer med et enkelt git checkout, hvis noget går anderledes end forventet.

Kan Pi Coding Agent skrive tests automatisk?
Ja, agenten kan generere Vitest-tests baseret på den kode, den selv har skrevet, som vist i eksemplet i denne guide. Du bør stadig gennemgå testene for at sikre, at de faktisk dækker relevante edge cases.

Hvordan forhindrer jeg agenten i at læse mine hemmeligheder?
Hold filer som .env uden for det projekt, agenten arbejder i, eller brug en ignorefil, hvis din version af Pi understøtter det. Opbevar aldrig API-nøgler direkte i kildekoden.

Er vibe coding med en agent som Pi sikkert til produktionskode?
Det kan være det, hvis du følger den kontrollerede arbejdsgang med plan, godkendelse, tests og diff-gennemgang beskrevet i denne artikel. Direkte auto-godkendt agentkørsel i produktion er derimod betydeligt mere risikabelt, fordi ingen læser koden, før den rammer dine brugere. Det gælder også, når du bruger værktøjet på større, eksisterende kodebaser: start med afgrænsede opgaver i et enkelt modul, ligesom telefonnummer- og CVR-eksemplerne i denne guide, i stedet for at bede agenten om at forstå hele arkitekturen på én gang.

Hvor finder jeg kildekoden til Pi Coding Agent?
Projektet er tilgængeligt på GitHub under organisationen earendil-works, hvor du også kan se, hvordan de interne workflows og kommandoer er bygget op, hvis du vil skrive dine egne udvidelser.

Pi Coding Agent: Vibe Coding I 13 Trin, 50 Min [2026]