Få Codex, Claude Code och Cursor att arbeta som ett CLI-team

Codex, Claude Code och Cursor kan redigera kodarkiv, köra kommandon och följa projektinstruktioner med de funktioner och behörigheter som har konfigurerats för dem. Den här artikeln prövar ett filbaserat driftskontrakt; den hävdar inte att varje team behöver tre agenter eller att kontraktet tar bort verktygsspecifikt beteende.

Den här artikeln visar hur du gör det med filer och CLI-verktyg du redan har:

• Delade projektinstruktioner i AGENTS.md
• Brygga till Claude via CLAUDE.md, som importerar @AGENTS.md
• Cursors basinstruktioner plus valfria .cursor/rules
• Typade överlämningar i Markdown mellan roller
• Icke-interaktiva CLI-körningar för design, granskning och implementering

Här krävs ingen egen projektledningsplattform. Om du senare vill ha en gemensam backlog för agenterna kan du kombinera upplägget med projektledning för flera agenter i Linear. Här sker samordningen via git och Markdown.

Produktdokumentationen kontrollerades på nytt 2026-08-04 mot AGENTS.md, OpenAI:s vägledning för AGENTS.md i Codex, det icke-interaktiva läget i Codex, Claude Codes minnesdokumentation, Claude Code CLI-referens och Cursor CLI-dokumentation. Hela överlämningen mellan de tre klienterna kördes inte från början till slut i den här granskningen. Verifiera kommandon och behörigheter mot låsta klientversioner innan du förlitar dig på arbetsflödet.

Teamformen

En tillförlitlig första rollfördelning:

De här rollerna är konventioner, inte leverantörsbegränsningar. Varje verktyg kan designa, granska eller implementera. Specialisering hjälper eftersom den skapar en tydlig gräns mellan arbetsresultaten: en agent skriver en plan, en annan ifrågasätter den och en tredje implementerar bara det som klarade granskningen.

Delade instruktioner: en sanningskälla

Använd AGENTS.md som portabel bas

AGENTS.md är ett gemensamt instruktionsformat för olika verktyg under Agentic AI Foundation. Codex läser det direkt. Cursor stöder en AGENTS.md i roten som gemensam projektvägledning vid sidan av .cursor/rules. Håll den kort och operativ:

# AGENTS.md

## Kommandon
- Installera: `pnpm install`
- Testa: `pnpm test`
- Typkontrollera: `pnpm typecheck`
- Linta: `pnpm lint`

## Patchregler
- En beteendeförändring per branch
- Föredra befintliga hjälpfunktioner framför nya beroenden
- Redigera inte hemligheter eller `.env*`-filer
- Sammanfoga inte till main

## Protokoll för flera agenter
- Läs `docs/handoffs/` innan du börjar
- Skriv tillbaka status i den aktiva överlämningsfilen
- Designer, granskare och implementatör måste vara olika körningar
- Stanna vid autentisering, betalningar, produktionsinfrastruktur eller dataradering

OpenAI:s Codex-dokumentation beskriver hur filer identifieras från projektroten ner till arbetskatalogen, där närmare filer har företräde, samt valfri AGENTS.override.md och en standardgräns för den sammanlagda storleken (32 KiB om den inte höjs). Håll rotfilen kort; lägg paketspecifika regler i underordnade AGENTS.md-filer.

Brygga Claude Code med CLAUDE.md

Claude Code läser CLAUDE.md, inte AGENTS.md. Officiell vägledning är att importera den delade filen:

@AGENTS.md

## Claude Code
- Föredra planläge före redigeringar i `src/billing/` och autentiseringskod
- Implementera inte i granskningsjobb om överlämningsstatusen inte är `implement` eller `fixes`

En symlink (ln -s AGENTS.md CLAUDE.md) fungerar också när du inte behöver Claude-specifika tillägg. På Windows: föredra importen @AGENTS.md.

Bekräfta laddning med Claudes /context och kontrollera Memory files.

Håll Cursor-specifika regler smala

Cursor kan använda rot-AGENTS.md för delade konventioner. Använd .cursor/rules/*.mdc bara för Cursor-behov, till exempel regler som avgränsas med globmönster. Underhåll inte tre divergerande encyklopedier.

Överlämningsfilen är samtalet mellan teammedlemmar

Skapa en katalog:

mkdir -p docs/handoffs

Använd en fil per arbetsenhet:

docs/handoffs/2026-07-29-pricing-section.md

# Överlämning: prissektion

- ID: pricing-section
- Status: design
- Owner now: codex
- Next owner: claude
- Branch: codex/design-pricing-section
- Worktree: ../app-pricing-section

## Goal
Implementera marknadsföringens prissektion med de befintliga mönstren Section/PlanCard.

## Non-goals
Fakturering, kuponger och beräkningar av antal användarplatser.

## Design
(Codex fyller i detta)

## Review
(Claude fyller i detta)

## Implementation notes
(Cursor fyller i detta)

## Verification
- Command: `pnpm test:e2e --grep "pricing"`
- Last result:

## Decision log
- 2026-07-29 Codex: tog fram ett första utkast till komponentgränser

Statusvärden som fungerar bra, med cykler i stället för en enkel väg framåt:

1. design
2. design-review — blockerande fynd återgår till design; ren granskning går vidare till implement
3. implement
4. impl-review — blockerande fynd går till fixes; ren granskning sätter done
5. fixes — implementatören löser fynd, återgår sedan till impl-review
6. done
7. blocked-human

Alla uppgifter behöver inte gå via fixes. En ren impl-review kan gå direkt till done.

Varje CLI-körning börjar med att läsa filen och slutar med att uppdatera status, ägare och beslutslogg. Det är hela orkestreringslagret.

Exempel: efter en cykel design → granskning

Ett illustrativt överlämningsutdrag efter att Codex designat och Claude granskat:

- Status: implement
- Owner now: cursor
- Next owner: claude

## Design
Filer: `PricingSection.tsx` (ny), återanvänd `PlanCard.tsx`
CTA:n måste spåra klick med `trackEvent()` + `getCtaClickProps()` från `src/lib/analytics.ts`
Mobil: staplade kort under `md`, tre kolumner från och med `md`
Plan-ID:n: `starter`, `pro`, `business`
Test: `pnpm test:e2e --grep "pricing"`

## Review
Blocking: inga återstående (brytpunkten + plan-ID:n löstes i Design ovan)
Non-blocking:
- Bryt ut plankonstanterna senare om ett CMS införs.

## Decision log
- 2026-07-29 Codex: inledande komponentgränser
- 2026-07-29 Claude: begärde brytpunkt + uttryckliga plan-ID:n
- 2026-07-29 Codex: uppdaterade Design; Claude godkände de blockerande punkterna → implement

Det arbetsresultatet är vad Cursor ska följa. Chatthistoriken är valfri. Filen är obligatorisk.

Installera och anropa varje CLI

Exakta installationsvägar ändras; använd varje leverantörs aktuella installationsdokumentation. Det som spelar roll är det icke-interaktiva anropsmönstret.

Codex: designpass

Det icke-interaktiva läget i Codex är codex exec. Som standard kör det i en skrivskyddad sandlåda. Ett designjobb som uppdaterar överlämningsfilen behöver skrivbehörighet till arbetsytan:

cd ../app-pricing-section
codex exec --sandbox workspace-write "$(cat <<'EOF'
Read AGENTS.md and docs/handoffs/2026-07-29-pricing-section.md.
Status is design. Produce the Design section only:
- proposed files
- component/API boundaries
- test plan
- risks
- open questions
Do not implement application code.
Set status to design-review and next owner to claude.
Append a Decision log entry.
EOF
)"

Använd interaktiv codex bara när du vill styra designen live. För skript och sekvenserade körningar: föredra codex exec.

Claude Code: granskningspass

Claude Codes icke-interaktiva läge kan granska och uppdatera överlämningsfilen, men bara om dina behörighetsinställningar tillåter skrivning i den aktuella worktreen. Håll omfattningen snäv:

cd ../app-pricing-section
claude -p --permission-mode acceptEdits --max-turns 30 --max-budget-usd 5 --output-format text "$(cat <<'EOF'
Read AGENTS.md / CLAUDE.md and docs/handoffs/2026-07-29-pricing-section.md.
You are the reviewer. Do not implement application code.
Challenge the Design section for missing edge cases, local-architecture mismatches, weak tests, and security issues.
Write findings into the Review section as Blocking vs Non-blocking.
If blocking findings exist, set status to design and next owner to codex.
Otherwise set status to implement and next owner to cursor.
Append a Decision log entry.
EOF
)"

Om ditt behörighetsläge i Claude inte kan skriva filer icke-interaktivt kör du granskningen skrivskyddat och låter en människa eller ett skript klistra in Review-sektionen i överlämningsfilen. Föredra --permission-mode acceptEdits (eller en tillåtelselista i inställningarna) för uppdateringar av överlämningsfilen i en tillfällig worktree. Använd inte --dangerously-skip-permissions i en riktig arbetskatalog.

Användbara Claude Code-kontroller för skriptade körningar (se CLI-referens):

• -p / --print för icke-interaktiv slutföring
• --max-turns för att begränsa cykler
• --max-budget-usd för att begränsa kostnad
• --output-format json|text|stream-json för automation
• --permission-mode acceptEdits när granskningen måste skriva överlämningsfilen i en avgränsad worktree

Använd inte lättvindigt --dangerously-skip-permissions i arbetskataloger för produktion.

Cursor: implementeringspass

Cursor CLI (agent). Föredra samma dedikerade worktree som överlämningsfilen registrerar. Implementera inte från den huvudsakliga arbetskatalogen:

cd ../app-pricing-section
agent -p --trust --sandbox enabled --output-format text "$(cat <<'EOF'
Read AGENTS.md and docs/handoffs/2026-07-29-pricing-section.md.
Status must be implement or fixes.
Implement only the approved Design, respecting Review blocking resolutions.
Keep the patch small. Add or update tests from the Verification section.
Run the verification command and record the result in the handoff file.
Set status to impl-review and next owner to claude.
Do not merge.
EOF
)"

Viktiga Cursor CLI-flaggor:

• -p / --print — icke-interaktivt; har redan åtkomst till skriv- och shellverktyg
• --force / --yolo — godkänner shellkommandon automatiskt om de inte nekas; använd bara i tillfälliga sandlådor, inte som standard när du skriver kod
• --sandbox enabled|disabled — sandlådeläge för körningen; föredra enabled när du implementerar med --trust
• --trust — lita på arbetsytan i automation
• -w / --worktree [name] — isolerad arbetskatalog under ~/.cursor/worktrees/<repo>/ (en annan sökväg än med manuell git worktree add; om du använder den uppdaterar du fälten Branch och Worktree i överlämningen så att de stämmer)
• --mode plan eller --mode ask — planering eller skrivskyddat
• --output-format text|json|stream-json

För Cursor-körningar som enbart ska granska bör du välja läget ask eller plan, eller ge en uttrycklig instruktion om att inte redigera. Föredra manuell git worktree add så att sökvägen i överlämningen stämmer med implementatörens arbetskatalog.

Se också Cursors vägledning för headless CLI för skriptade arbetsflöden.

Karta över instruktionsfiler (undvik dubbel sanning)

Om en regel gäller för varje agent behåller du en kanonisk, portabel version och använder bara de bryggor som respektive verktyg kräver. Verktygsspecifika regler stannar lokalt. Duplicerad policy skapar flera uppdateringspunkter och ökar risken för avvikelser. Ett test bör verifiera att varje verktyg laddar den avsedda regeluppsättningen.

Fullständigt exempel på en arbetskedja

Anta ett rent kodarkiv och en ny funktion utan implementation.

1. Skapa en isolerad worktree

git fetch origin main
git worktree add -b feat/pricing-section ../app-pricing-section origin/main
cd ../app-pricing-section
mkdir -p docs/handoffs

Förbered överlämningsfilen med Goal, Non-goals och Verification. Versionshantera stommen om teamet vill att kontraktet ska synas i PR:er.

2. Codex designar

Codex skriver Design-sektionen: filer, gränssnitt, tester, risker. Status blir design-review.

Det faktiska designresultatet bör ha den här formen:

## Design
Filer:
- `src/components/marketing/PricingSection.tsx` (ny)
- `src/components/marketing/PlanCard.tsx` (återanvänd)
- `tests/e2e/marketing-pricing.spec.ts` (ny)

Gränser:
- PricingSection äger layouten och listan över planer
- PlanCard förblir en presentationskomponent
- CTA-länkar använder de befintliga hjälpfunktionerna `trackEvent()` + `getCtaClickProps()`

Testplan:
- tre planer är synliga
- CTA-länkarnas href-värden fungerar
- analyshjälpfunktionen anropas en gång per klick

Risker:
- hårdkodade plan-ID:n kommer ur synk med CMS:et

3. Claude granskar designen

Granskningsprompten kräver fynd i Blocking/Non-blocking, så ofullständiga designförslag kommer tillbaka blockerade. Exempel:

Blocking:
1. Inget layoutbeslut för mobil för staplade plankort.
2. Designen anger inte verifieringskommandot (lägg till det under Design och Verification).
Non-blocking:
- Överväg att extrahera plandata till en konstant.

Statusen återgår till design eller går vidare till implement först när de blockerande punkterna har arbetats in i designen.

4. Cursor implementerar

Cursor implementerar bara den godkända designen. Den kör:

pnpm test:e2e --grep "pricing"

Den registrerar resultatet, öppnar eller förbereder en PR och sätter impl-review.

5. Claude granskar implementeringen

En andra Claude-körning granskar diffen mot överlämningen, inte mot ett nyss påhittat ideal. Blockerande fynd skickar statusen till fixes med ägaren cursor. En ren granskning sätter done inför en människas sammanfogning.

6. Människan sammanfogar

Skyddade grenar förblir människors ansvar. Agenter kan vara snabba juniora medarbetare. De ska inte vara releaseansvariga.

Orkestrering via shell utan plattform

En enkel sekvenserare räcker:

#!/usr/bin/env bash
set -euo pipefail
ROOT="${1:?worktree path}"
HANDOFF="${2:?handoff file}"
cd "$ROOT"

status() {
  # Prefer the metadata Status field near the top of the handoff file.
  awk '/^- Status:/{print $3; exit}' "$HANDOFF"
}

case "$(status)" in
  design)
    codex exec --sandbox workspace-write "Read AGENTS.md and $HANDOFF. Fill Design only, then set status=design-review and next owner=claude. Do not implement application code."
    ;;
  design-review|impl-review)
    claude -p --permission-mode acceptEdits --max-turns 30 --max-budget-usd 5 --output-format text "Review $HANDOFF per AGENTS.md. Update Review + status only. Do not implement application code."
    ;;
  implement|fixes)
    agent -p --trust --sandbox enabled --output-format text "Status must be implement or fixes. Implement or fix per $HANDOFF and AGENTS.md. Update handoff. Do not merge."
    ;;
  done|blocked-human)
    echo "No agent action for $(status)"
    ;;
  *)
    echo "Unknown status in $HANDOFF" >&2
    exit 1
    ;;
esac

Det här är medvetet tråkigt. Tråkig orkestrering går att felsöka. Håll sandlådor och behörighetslägen så snäva som steget tillåter. Design och granskning ska inte behöva bred systemåtkomst.

Fellägen

Icke-interaktiva flaggor som automatiskt godkänner redigeringar eller behörigheter är bekvämlighetsverktyg för sandlådor och snävt avgränsade worktrees. De är inte en produktionsmodell för åtkomstkontroll.

Vad du ännu inte ska automatisera

• Sammanfogning till skyddade grenar
• Produktionsdriftsättningar
• Rotation av hemligheter
• Schemamigreringar utan en mänskligt granskad plan
• Alla arbetsflöden där överlämningsfilen själv kommer från en otillförlitlig extern inlämnare utan sanering

Praktiskt startkit

1. Lägg till rot-AGENTS.md med kommandon, patchregler och multiagentprotokoll.
2. Lägg till CLAUDE.md som innehåller @AGENTS.md.
3. Lägg till docs/handoffs/_template.md.
4. Välj en liten funktion.
5. Kör design → granskning → implementering → granskning en gång för hand.
6. Först därefter: kapsla in statusarna i en sekvenserare i shell.

Om samma agenter behöver hämta uppgifter från en gemensam företagsbacklog lägger du till Linear MCP och modellen för reserverings- och granskningsstatus från projektledning för flera agenter i Linear. Överlämningen i Markdown förblir användbar som teknisk anteckningsbok per ärende.

Standarden är kontraktet

Codex, Claude Code och Cursor överlappar redan i kapacitet. De blir ett team när du slutar be dem ”arbeta tillsammans” i abstrakt och i stället tvingar fram ett synligt kontrakt:

• delade instruktioner
• uttrycklig roll per körning
• överlämning i Markdown med status
• isolerade worktrees
• avgränsade CLI-anrop
• mänskligt ansvar för sammanfogning och release

Det räcker för att köra ett seriöst lokalt agentteam med dagens verktyg – och för att snabbt märka när teamet improviserar i stället för att bedriva ingenjörsarbete.