Claude Architect · Lektion

Icke-interaktivt läge

Flaggan -p / --print för huvudlös CI-körning.

Lektion 1 av 413 steg

Icke-interaktivt läge är en gratis lektion i Claude Architect på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Claude Architect, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Claude Architect innehåller totalt 4 lektioner.

Varför headless-läge finns

Claude Code använder som standard en interaktiv terminalsession: programmet ställer frågor, väntar på indata och strömmar en konversation. Den modellen fungerar utmärkt vid skrivbordet men inte i en pipeline.

En CI/CD-körning har ingen människa som kan bekräfta en plan, godkänna en redigering eller svara på en följdfråga. Den behöver ett enda kommando som körs, producerar utdata och avslutas med en statuskod.

Det är precis vad -p / --print levererar: icke-interaktiv körning (headless). Det är den grundläggande flaggan för att köra Claude Code i CI.

Flaggan --print

Du aktiverar headless-läge genom att skicka prompten till -p (kortformen av --print). Claude kör den agentiska loopen tills den är klar och skriver ut det slutliga resultatet till stdout, varefter processen avslutas.

Det finns ingen REPL, ingen väntan på indata och inga bekräftelsefrågor. Ett kommando in, ett resultat ut – det kontrakt som ett pipeline-steg behöver.

# Interactive (default) — opens a session, waits for you
claude

# Non-interactive (headless) — runs and exits, prints to stdout
claude -p "Review the staged diff and list any blocking issues"

Ett verkligt CI-steg

I praktiken blir -p ett steg i ett jobb. Körningen checkar ut koden och anropar sedan Claude med en exakt instruktion. Eftersom processen avslutas när loopen når end_turn går pipelinen naturligt vidare.

Håll prompten avgränsad och tydlig – det finns ingen människa som kan klargöra tvetydigheter under körningen, så instruktionen måste stå på egna ben.

# .github/workflows/review.yml (excerpt)
- name: Claude review
  run: |
    claude -p "Review the diff in this PR. Flag only changes that
    introduce a bug, a security issue, or break a public API."
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Tolkbar utdata: --output-format json

Vanlig text fungerar bra för en människa som läser loggar, men en pipeline behöver vanligtvis agera utifrån resultatet – publicera en kommentar, ange status för en kontroll eller blockera en sammanfogning.

Lägg till --output-format json så att Claude genererar ett strukturerat, maskinläsbart resultat i stället för fri text. Nästa steg kan då deterministiskt tolka fälten med jq eller ett skript.

claude -p "List blocking issues in the staged diff" \
  --output-format json | jq '.result'

Tvinga fram ett schema

JSON i sig låter fortfarande modellen välja sin struktur. För tillförlitlig automatisering kombinerar du --output-format json med ett schema så att varje körning returnerar samma fält. Det eliminerar syntaxöverraskningar och låter dig kräva exakt de nycklar som pipelinen använder.

Använd samma principer för strukturerad utdata som i API:t: markera ett fält som obligatoriskt endast om det alltid finns – tvinga aldrig fram ett fält som legitimt kan saknas, eftersom modellen då kommer att fabricera det.

{
  "type": "object",
  "properties": {
    "verdict": { "type": "string", "enum": ["pass", "fail"] },
    "issues": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "file": { "type": "string" },
          "severity": { "type": "string", "enum": ["blocking", "warning"] },
          "detail": { "type": "string" }
        },
        "required": ["file", "severity", "detail"]
      }
    }
  },
  "required": ["verdict", "issues"]
}

Granska i en isolerad session

En subtil men viktig punkt inför provet är att när Claude både genererar kod och sedan granskar den i samma session blir granskningen partisk – upphovet behåller sitt eget resonemang och kommer inte att ifrågasätta sig självt.

Kör granskningen i CI i en ny, isolerad session, separat från all genereringskontext. En oberoende instans har mycket större sannolikhet att upptäcka verkliga fel. Detta återspeglar den allmänna regeln: oberoende granskning är bättre än självgranskning i samma session.

# Generation and review are SEPARATE invocations / sessions
claude -p "Implement the change described in TASK.md"

# Fresh, unbiased reviewer — no generation history
claude -p "Review the resulting diff for correctness and security only" \
  --output-format json

Minimera falska positiva

En CI-granskare som ropar ”vargen kommer” ignoreras. Målet är precision: lyft fram verkliga blockerande problem och var annars tyst.

Det som gör skillnad är prompten, inte vaga vädjanden. Uttryckliga kriterier slår otydliga önskemål: "flagga en kommentar endast när den motsäger koden" fungerar bättre än "var mer exakt". Några riktade few-shot-exempel (2–4) på sanna respektive falska positiva hjälper dessutom till att kalibrera modellen för dina gränsfall.

claude -p "Review the diff. Report an issue ONLY if it (a) causes
incorrect behavior, (b) is a security risk, or (c) breaks a public
contract. Do NOT comment on style, naming, or formatting.

Example (flag):   off-by-one in loop bound -> array overrun
Example (ignore): a variable could be renamed for clarity" \
  --output-format json

Begränsa verktyg enligt principen om minsta behörighet

En headless-körning utförs utan mänskligt godkännande, så obegränsad åtkomst till verktyg är riskabel. Ge endast körningen det som jobbet behöver.

För en skrivskyddad granskning vill du vanligtvis ha Read, Grep och Glob – inte Write, Edit eller godtycklig Bash. Detta är samma princip om minsta behörighet som du tillämpar på agentens verktygsuppsättningar: begränsa verktygen efter rollen och håll uppsättningen liten för tillförlitligt val.

claude -p "Review the diff and report blocking issues" \
  --output-format json \
  --allowedTools "Read,Grep,Glob"

Stoppa vid loopen, inte vid en statusrad

Även i headless-läge är den agentiska loopen oförändrad: begäran -> kontrollera stop_reason -> om tool_use, kör verktygen och fortsätt -> upprepa tills end_turn. Processen avslutas när modellen når end_turn.

Omslut inte Claude med ett skript som söker efter ord som ”done” eller ”finished” i utdatan för att avgöra om körningen är klar. Avslutningen styrs av stopporsaken. En eventuell iterationsgräns är ett säkerhetsnät, aldrig den primära stoppmekanismen.

Nya körningar: rapportera endast det nya

CI körs om hela tiden – varje push startar jobbet på nytt. Om granskaren rapporterar samma fem problem varje gång drunknar signalen i brus.

Vid en ny körning skickar du tillbaka de tidigare resultaten och instruerar Claude att endast rapportera nya eller fortfarande olösta problem. Då förblir varje kommentar åtgärdbar och du tar hänsyn till att utvecklarna redan har sett de tidigare resultaten.

claude -p "Here are the issues from the previous run:
$(cat prev_review.json)

Review the current diff. Report ONLY issues that are new or remain
unfixed. Omit anything already resolved." \
  --output-format json > review.json

Headless jämfört med Batch API

Blanda inte ihop icke-interaktiv CLI-körning med Message Batches API. De löser olika problem.

  • -p / --print: synkront, blockerande, returnerar direkt – rätt för en pre-merge-kontroll där pipelinen väntar på resultatet.
  • Batch API: 50 % billigare, upp till 24 timmars tidsfönster, ingen latens-SLA och inget stöd för flerturnsverktygsanrop – rätt för icke-blockerande granskningar över natten, aldrig för en tidskänslig blockerande kontroll.

En granskning före merge måste blockera, så använd -p; använd Batch endast för offlinejobb som inte är brådskande.

Snabbkontroll: Koppla in en CI-granskare

Du lägger till Claude Code som ett pre-merge-granskningssteg i din pipeline. Jobbet måste köras utan att någon människa är närvarande, returnera ett resultat som nästa steg kan tolka för att ange kontrollens status och undvika partisk självgranskning av genererad kod. Vilket tillvägagångssätt är korrekt?

Sammanfattning: Headless Claude Code

Viktiga slutsatser för icke-interaktivt läge:

  • -p / --print är den flagga som krävs för headless-körning i CI – kör loopen till slutet, skriver ut till stdout och avslutas.
  • --output-format json (helst tillsammans med ett schema) gör resultaten möjliga att tolka, så att pipelinen kan agera utifrån dem; kräv endast fält som alltid finns.
  • Kör granskningen i en isolerad, ny session – en oberoende granskning är bättre än en partisk självgranskning i samma session.
  • Öka precisionen med tydliga kriterier och few-shot-exempel för att minimera falska positiva resultat.
  • Använd verktyg med minsta nödvändiga behörighet vid obemannade körningar; vid omkörningar ska du endast rapportera nya eller ännu inte åtgärdade problem.
  • Avslut styrs av stop reason, aldrig av textanalys; iterationsgränser är endast ett säkerhetsnät.
  • Använd -p för blockerande pre-merge-kontroller; reservera Batch API för icke-blockerande jobb som inte är brådskande.
Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
26
Lektioner
104

Vanliga frågor

Är lektionen ”Icke-interaktivt läge” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Claude Architect, inklusive ”Icke-interaktivt läge”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Claude Architect innehåller totalt 4 lektioner.

Vad lär jag mig i ”Icke-interaktivt läge”?

Flaggan -p / --print för huvudlös CI-körning. Ni övar på Claude Architect med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Claude Architect?

Du behöver inga förkunskaper. Utbildningen i Claude Architect på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Icke-interaktivt läge”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Claude Architect-lektionen?

Ja. Varje Claude Architect-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Icke-interaktivt läge
  2. Strukturerad utdata
  3. Sessionsisolering för granskningar
  4. Testgenerering och standarder
← Tillbaka till Claude Architect