Anwendungsfall für Codex
Vom Issue zum getesteten pull request
Übertrage Codex die Umsetzung einer kleinen Funktion mit klaren Akzeptanzkriterien. Prüfe anschließend die Nachweise.
Gib Codex ein klar abgegrenztes Issue, eine vorbereitete Cloud-Umgebung und konkrete Prüfschritte. Du erhältst die Implementierung samt Tests und Dokumentation. Beim Review kannst du für jedes Akzeptanzkriterium nachvollziehen, wie es überprüft wurde.
Besonders geeignet für
- Wer in einem Start-up ein klar abgegrenztes API-Issue umsetzt.
- Alle, die beim Review sowohl die Implementierung als auch die zugehörigen Prüfnachweise brauchen.
- Teams mit Akzeptanzkriterien und einer funktionierenden Testumgebung.
Inhalt
Vom Issue zum getesteten pull request
Übertrage Codex die Umsetzung einer kleinen Funktion mit klaren Akzeptanzkriterien. Prüfe anschließend die Nachweise.
Gib Codex ein klar abgegrenztes Issue, eine vorbereitete Cloud-Umgebung und konkrete Prüfschritte. Du erhältst die Implementierung samt Tests und Dokumentation. Beim Review kannst du für jedes Akzeptanzkriterium nachvollziehen, wie es überprüft wurde.
Gib Codex ein klar abgegrenztes Issue, eine vorbereitete Cloud-Umgebung und konkrete Prüfschritte. Du erhältst die Implementierung samt Tests und Dokumentation. Beim Review kannst du für jedes Akzeptanzkriterium nachvollziehen, wie es überprüft wurde.
Weiterführende Links
Besonders geeignet für
- Wer in einem Start-up ein klar abgegrenztes API-Issue umsetzt.
- Alle, die beim Review sowohl die Implementierung als auch die zugehörigen Prüfnachweise brauchen.
- Teams mit Akzeptanzkriterien und einer funktionierenden Testumgebung.
Prompt für den Einstieg
Gib Codex ein kleines, klar umrissenes Issue. Bitte um eine Änderung, die jemand aus deinem Team prüfen kann. Dazu gehören die Implementierung, Tests, Dokumentation und Nachweise dafür, dass das gewünschte Verhalten funktioniert. Führe die gesamte Aufgabe in einer vorbereiteten Cloud-Umgebung aus, damit für die Implementierung und die Prüfung dasselbe Repository-Setup gilt.
-
Wähle in der Web- oder Desktop-App Arbeiten in > Cloud und dann eine veröffentlichte Umgebung aus.
-
Um eine Umgebung zu erstellen, wähle Umgebung erstellen, wähle die GitHub-Repositorys aus und bitte Codex, die Laufzeitumgebung, die Abhängigkeiten und die isolierten Testdienste vorzubereiten.
-
Prüfe den Setup-Bericht und behebe die Ursachen fehlgeschlagener Prüfungen. Wähle Veröffentlichen, bevor du eine neue Aufgabe startest.
- Folge der aktuellen Anleitung für Cloud-Umgebungen.
- Halte die Anweisungen für das Repository in AGENTS.md fest.
Wenn sich die Abhängigkeiten oder die Konfiguration eines Dienstes ändern, bearbeite und teste die wiederverwendbare Umgebung. Wähle Erneut veröffentlichen und überprüfe die Änderungen in einer neuen Aufgabe.
Beim Aktualisieren des Repositorys werden die Installations- und Startbefehle nicht erneut ausgeführt. Bestehende Aufgaben behalten ihren eigenen Zustand.
Konfiguriere die benötigten Netzwerkziele und die Zugangsdaten für Tests getrennt. Die Freigabe eines Netzwerkziels gewährt noch keinen Zugriff auf den Dienst.
Wenn erforderliche Prüfungen nicht ausgeführt werden können, schließe das Setup ab, bevor du diesen Workflow verwendest.
Wann sich der Workflow eignet
Wähle eine Funktion, deren Verhalten schriftlich festgelegt ist und bei der klar ist, wann die Arbeit abgeschlossen ist. Das kann ein neuer API-Endpunkt, eine Validierungsregel oder eine kleine Erweiterung eines bestehenden Dienstes sein. Das Issue sollte in einen einzigen Pull Request passen und Prüfungen vorsehen, die ohne Zugriff auf das Produktivsystem laufen.
Im Beispiel erhält der Aktivitätsfeed eines Projekts eine Paginierung. Das ausführbare TypeScript-Beispiel enthält eine Authentifizierung, Zugriffskontrollen für Projekte, signierte Cursor und eine bestehende Route für Projektdetails. Es verwendet feste Testdaten im Arbeitsspeicher. So kannst du das vereinbarte Verhalten der Paginierung ohne Datenbank oder externen Dienst prüfen.
Das Beispiel ausführen
Lade das Beispiel herunter, entpacke es und öffne den Ordner issue-to-tested-pr. Verwende Node ab Version 22.6. Das Beispiel nutzt die Standardbibliothek. Du musst keine Pakete installieren und brauchst keinen API-Schlüssel.
node --version
node --experimental-strip-types api.ts
node --experimental-strip-types test.ts --seeded
node --experimental-strip-types test.ts
node --experimental-strip-types reproduce.ts ./evidence
node --experimental-strip-types api.ts startet einen lokalen HTTP-Server, ruft die erste Seite ab, gibt die öffentlichen IDs der Ereignisse aus und beendet den Server.
Der Testlauf mit --seeded endet absichtlich mit einem Exit-Code ungleich null. Beim Abruf der nächsten Seite berücksichtigt diese Variante nur den Zeitstempel. Dadurch überspringt sie zwei Ereignisse, die denselben Zeitstempel wie das letzte Ereignis der ersten Seite haben. Dieselben Tests bestehen, wenn die korrigierte Variante die Paginierung anhand des Tupels aus Zeitstempel und ID fortsetzt.
Der Befehl zur Reproduktion ist nur erfolgreich, wenn die Tests mit dem eingebauten Fehler fehlschlagen und mit der Korrektur bestehen.
Mit der Korrektur liefert der Durchlauf bei limit=2 in drei Anfragen folgende Seiten:
[evt_105, evt_104]
[evt_103, evt_102]
[evt_101]
Die ersten beiden Seiten enthalten einen Cursor für die nächste Seite. Auf der letzten Seite steht next_cursor: null.
Die Variante mit dem eingebauten Fehler liefert [evt_105, evt_104] und danach [evt_101]. Dabei fehlen evt_103 und evt_102.
Bei einem erfolgreichen Durchlauf besteht die korrigierte Variante alle 36 Tests. Bei der Variante mit dem eingebauten Fehler schlagen drei Assertions fehl und machen den Paginierungsfehler sichtbar.
Um deine Umgebung zu überprüfen, lege die Dateien im ausgewählten Repository ab. Bereite eine Umgebung mit einer unterstützten Node-Version vor und veröffentliche sie. Führe die Befehle anschließend in einer neuen Cloud-Aufgabe aus und halte die Ergebnisse fest.
reproduce.ts speichert red.log, green.log, observed-http.json und run-manifest.json im angegebenen Verzeichnis für Nachweise. Das Manifest enthält Angaben zur Laufzeitumgebung, zu den Befehlen und Exit-Codes, zum eingebauten Fehler und seiner Korrektur sowie die SHA-256-Hashwerte der Quelldateien.
Sitzungstoken und Signaturschlüssel werden nicht protokolliert. In README.md und openapi.json findest du das Setup des Beispiels und die Spezifikation seiner öffentlichen Schnittstelle.
Den Beispielcode ansehen
Die folgenden Ausschnitte stammen aus den Dateien im Download. Entpacke das ZIP-Archiv und führe die vollständigen Dateien aus.
Implementierung von Cursor und Sortierung
import { createFixtures } from "./fixtures.ts";
type Fixtures = ReturnType<typeof createFixtures>;
type EventKey = { created_at: string; id: string };
export function createApi({
sessions,
projects,
events,
signingKey,
seededBug = false,
}: Fixtures & { seededBug?: boolean }) {
return createServer((request, response) => {
const send = (status: number, body: unknown) => {
response.writeHead(status, { "content-type": "application/json" });
response.end(JSON.stringify(body));
};
const fail = (code: string) => {
const [status, message] = errors[code];
send(status, { error: { code, message } });
};
// Authenticate, then authorize. Malformed parameters must not change these results.
const authorization = request.headers.authorization ?? "";
const bearer = /^Bearer ([A-Za-z0-9_-]+)$/.exec(authorization);
const tenantId = bearer ? sessions.get(bearer[1]) : undefined;
if (!tenantId) return fail("unauthenticated");
const url = new URL(request.url ?? "/", "http://127.0.0.1");
const route = /^\/v1\/projects\/([^/]+)(\/events)?$/.exec(url.pathname);
let projectId;
try {
projectId = route ? decodeURIComponent(route[1]) : undefined;
} catch {
return fail("not_found");
}
const project = projectId ? projects.get(projectId) : undefined;
if (
request.method !== "GET" ||
!route ||
!project ||
project.tenant_id !== tenantId
) {
return fail("not_found");
}
// Existing project-detail behavior remains independent of pagination parameters.
if (!route[2]) return send(200, { id: projectId, name: project.name });
const rawLimit = url.searchParams.get("limit");
const limit = rawLimit === null ? 25 : Number(rawLimit);
if (
url.searchParams.getAll("limit").length > 1 ||
(rawLimit !== null && !/^\d+$/.test(rawLimit)) ||
!Number.isInteger(limit) ||
limit < 1 ||
limit > 100
) {
return fail("invalid_limit");
}
let cursor: EventKey | undefined;
if (url.searchParams.has("cursor")) {
try {
if (url.searchParams.getAll("cursor").length !== 1)
throw new Error("Invalid cursor");
cursor = decodeCursor(
url.searchParams.get("cursor"),
tenantId,
projectId,
signingKey
);
} catch {
return fail("invalid_cursor");
}
}
const matching = events
.filter(
(event) =>
event.tenant_id === tenantId && event.project_id === projectId
)
.sort(compareEvents)
.filter((event) => {
if (!cursor) return true;
// Deliberate baseline defect: timestamp-only continuation loses tied rows.
if (seededBug)
return (
timestampValue(event.created_at) < timestampValue(cursor.created_at)
);
return compareEvents(event, cursor) > 0;
});
const selected = matching.slice(0, limit);
const items = selected.map(({ id, created_at, type, summary }) => ({
id,
created_at,
type,
summary,
}));
const nextCursor =
matching.length > limit
? encodeCursor(
selected[selected.length - 1],
tenantId,
projectId,
signingKey
)
: null;
return send(200, { items, next_cursor: nextCursor });
});
}
export async function startApi(
fixtures: Fixtures,
options: { seededBug?: boolean } = {}
) {
const server = createApi({ ...fixtures, ...options });
await new Promise((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", () => resolve(undefined));
});
const address = server.address();
if (!address || typeof address === "string")
throw new Error("No listening address");
return {
baseUrl: `http://127.0.0.1:${address.port}`,
close: () =>
new Promise((resolve, reject) =>
server.close((error) => (error ? reject(error) : resolve(undefined)))
),
};
}Vordefinierte Datensätze und Test-Fixtures für den Projektzugriff
export function createFixtures() {
const tokenA = randomBytes(24).toString("base64url");
const tokenB = randomBytes(24).toString("base64url");
const sessions = new Map([
[tokenA, "tenant_a"],
[tokenB, "tenant_b"],
]);
const projects = new Map([
["feed", { tenant_id: "tenant_a", name: "Activity feed" }],
["empty", { tenant_id: "tenant_a", name: "Empty feed" }],
["exact", { tenant_id: "tenant_a", name: "Four events" }],
["large", { tenant_id: "tenant_a", name: "Large feed" }],
["precision", { tenant_id: "tenant_a", name: "Precise timestamps" }],
["other", { tenant_id: "tenant_a", name: "Another project" }],
["private", { tenant_id: "tenant_b", name: "Private project" }],
]);
const event = (
id: string,
created_at: string,
project_id: string,
tenant_id = "tenant_a"
) => ({
id,
created_at,
project_id,
tenant_id,
type: "deployment",
summary: `Synthetic event ${id}`,
internal_note: "This field must never enter the HTTP response.",
raw_payload: { synthetic: true },
});
const feed = [
event("evt_105", "2026-01-15T12:00:03.123456Z", "feed"),
event("evt_104", "2026-01-15T12:00:02.123456Z", "feed"),
event("evt_103", "2026-01-15T12:00:02.123456Z", "feed"),
event("evt_102", "2026-01-15T12:00:02.123456Z", "feed"),
event("evt_101", "2026-01-15T12:00:01.123456Z", "feed"),
];
const events = [
...feed,
...feed.slice(0, 4).map((item) => ({ ...item, project_id: "exact" })),
...Array.from({ length: 105 }, (_, index) =>
event(
`large_${String(index).padStart(3, "0")}`,
new Date(Date.UTC(2026, 0, 15, 12, 0, index))
.toISOString()
.replace(".000Z", ".123456Z"),
"large"
)
),
// Reverse ID order makes timestamp precision observable in the tests.
event("precise_a", "2026-01-15T12:00:00.123999Z", "precision"),
event("precise_z", "2026-01-15T12:00:00.123001Z", "precision"),
event("other_1", "2026-01-15T12:00:00.123456Z", "other"),
event("other_2", "2026-01-15T11:59:59.123456Z", "other"),
event("private_1", "2026-01-15T12:00:00.123456Z", "private", "tenant_b"),
event("private_2", "2026-01-15T11:59:59.123456Z", "private", "tenant_b"),
];
return {
sessions,
projects,
events,
signingKey: randomBytes(32),
tokenA,
tokenB,
};
}HTTP-Spezifikation und Regressionstests
test("five-event traversal crosses a timestamp tie and replays the same continuation", async () => {
const expected = ["evt_105", "evt_104", "evt_103", "evt_102", "evt_101"];
const pages = await traverse("feed", 2, expected);
assert.deepEqual(pages.map(ids), [
["evt_105", "evt_104"],
["evt_103", "evt_102"],
["evt_101"],
]);
assert.equal(pages.length, 3);
assert.ok(pages[0].next_cursor);
assert.ok(pages[1].next_cursor);
assert.equal(pages[2].next_cursor, null);
const replay = await request("feed", {
limit: "2",
cursor: pages[0].next_cursor,
});
assert.deepEqual(replay.body.items, pages[1].items);
const next = await request("feed", {
limit: "2",
cursor: replay.body.next_cursor,
});
assert.deepEqual(next.body.items, pages[2].items);
assert.equal(next.body.next_cursor, null);
console.log(
JSON.stringify({
fixture: "five-event-tie",
pages: pages.map(ids),
requests: pages.length,
replay: ids(replay.body),
})
);
});
test("the same tie group traverses correctly with limit three", async () => {
const pages = await traverse("feed", 3, [
"evt_105",
"evt_104",
"evt_103",
"evt_102",
"evt_101",
]);
assert.deepEqual(pages.map(ids), [
["evt_105", "evt_104", "evt_103"],
["evt_102", "evt_101"],
]);
});
test("timestamp ordering and continuation preserve submillisecond precision", async () => {
const pages = await traverse("precision", 1, ["precise_a", "precise_z"]);
assert.equal(pages[0].items[0].created_at, "2026-01-15T12:00:00.123999Z");
assert.equal(pages[1].items[0].created_at, "2026-01-15T12:00:00.123001Z");
});
test("omitted, minimum, and maximum limits return 25, 1, and 100 of 105 events", async () => {
for (const [parameters, expected] of [
[{}, 25],
[{ limit: "1" }, 1],
[{ limit: "100" }, 100],
] as [Record<string, string>, number][]) {
const result = await request("large", parameters);
assert.equal(result.status, 200);
assert.equal(result.body.items.length, expected);
assert.ok(result.body.next_cursor);
}
const pages = await traverse(
"large",
100,
Array.from(
{ length: 105 },
(_, index) => `large_${String(104 - index).padStart(3, "0")}`
)
);
assert.deepEqual(
pages.map((page) => page.items.length),
[100, 5]
);
});
test("invalid and repeated limits return the documented generic error", async (context) => {
for (const limit of [
"0",
"101",
"-1",
"1.5",
"many",
"",
"1e2",
"Infinity",
]) {
await context.test(`limit ${JSON.stringify(limit)}`, async () => {
const result = await request("feed", { limit });
assert.equal(result.status, 400);
assert.deepEqual(
result.body,
expectedError(
"invalid_limit",
"Limit must be an integer from 1 through 100."
)
);
});
}
const repeated = await request("feed", [
["limit", "1"],
["limit", "2"],
]);
assert.equal(repeated.status, 400);
});
test("empty, partial, and exactly full final pages have no continuation", async () => {
assert.deepEqual((await request("empty")).body, {
items: [],
next_cursor: null,
});
const partial = await traverse("feed", 2, [
"evt_105",
"evt_104",
"evt_103",
"evt_102",
"evt_101",
]);
assert.equal(partial.at(-1).items.length, 1);
const exact = await traverse("exact", 2, [
"evt_105",
"evt_104",
"evt_103",
"evt_102",
]);
assert.deepEqual(
exact.map((page) => page.items.length),
[2, 2]
);
assert.equal(exact[1].next_cursor, null);
});
test("authentication precedes malformed and wrong-scope cursor or limit validation", async () => {
const privateCursor = (
await request("private", { limit: "1" }, fixtures.tokenB)
).body.next_cursor;
for (const token of [null, "invalid_session"]) {
for (const parameters of [
{ cursor: "broken" },
{ cursor: privateCursor },
{ limit: "0", cursor: "broken" },
] as Record<string, string>[]) {
const result = await request("feed", parameters, token);
assert.equal(result.status, 401);
assert.deepEqual(result.body, unauthenticated);
}
}
});
test("inaccessible and nonexistent projects return identical 404 before cursor validation", async () => {
const ownCursor = (await request("feed", { limit: "1" })).body.next_cursor;
for (const project of ["private", "missing"]) {
for (const parameters of [
{},
{ cursor: "broken" },
{ cursor: ownCursor },
{ limit: "0", cursor: "broken" },
] as Record<string, string>[]) {
const result = await request(project, parameters);
assert.equal(result.status, 404);
assert.deepEqual(result.body, notFound);
}
}
});
test("a valid cursor from another project in the same tenant is invalid on an authorized feed", async () => {
const cursor = (await request("other", { limit: "1" })).body.next_cursor;
assert.ok(cursor);
const result = await request("feed", { cursor });
assert.equal(result.status, 400);
assert.deepEqual(result.body, invalidCursor);
});
test("a valid cursor from another tenant is invalid on an authorized feed", async () => {
const cursor = (await request("private", { limit: "1" }, fixtures.tokenB))
.body.next_cursor;
assert.ok(cursor);
const result = await request("feed", { cursor });
assert.equal(result.status, 400);
assert.deepEqual(result.body, invalidCursor);
});
test("undecodable, empty, tampered, and repeated cursor tokens return the same closed error", async () => {
const cursor = (await request("feed", { limit: "1" })).body.next_cursor;
const [payload, signature] = cursor.split(".");
const tampered = `${payload}.${signature[0] === "A" ? "B" : "A"}${signature.slice(1)}`;
for (const token of [
"broken",
"",
"%%%.___",
"a.b.c",
"x".repeat(2049),
tampered,
]) {
const result = await request("feed", { cursor: token });
assert.equal(result.status, 400);
assert.deepEqual(result.body, invalidCursor);
}
const result = await request("feed", [
["cursor", cursor],
["cursor", cursor],
]);
assert.equal(result.status, 400);
assert.deepEqual(result.body, invalidCursor);
});
test("signed structurally invalid payloads and unsupported versions are rejected", async (context) => {
const valid = {
version: 1,
tenant_id: "tenant_a",
project_id: "feed",
created_at: "2026-01-15T12:00:02.123456Z",
id: "evt_104",
};
const missing: Partial<typeof valid> = { ...valid };
delete missing.id;
const cases: [string, unknown][] = [
["missing ID", missing],
["number ID", { ...valid, id: 104 }],
["empty ID", { ...valid, id: "" }],
["number timestamp", { ...valid, created_at: 0 }],
["invalid date", { ...valid, created_at: "2026-02-30T12:00:00Z" }],
["unsupported version", { ...valid, version: 2 }],
["extra field", { ...valid, extra: true }],
["wrong tenant type", { ...valid, tenant_id: 1 }],
["wrong project type", { ...valid, project_id: null }],
["null payload", null],
["array payload", []],
["invalid JSON", "not-json"],
];
for (const [name, payload] of cases) {
await context.test(name, async () => {
const result = await request("feed", { cursor: signFixture(payload) });
assert.equal(result.status, 400);
assert.deepEqual(result.body, invalidCursor);
});
}
});
test("every serialized event omits stored tenant, project, and raw payload fields", async () => {
const result = await request("feed", { limit: "100" });
assert.equal(result.status, 200);
for (const item of result.body.items) {
assert.deepEqual(Object.keys(item).sort(), [
"created_at",
"id",
"summary",
"type",
]);
}
assert.ok(
fixtures.events.some((event) => event.internal_note && event.raw_payload)
);
});
test("the schema oracle rejects extra, missing, incorrectly typed, and malformed public fields", () => {
const schema = specification.components.schemas.EventPage;
const page = {
items: [
{
id: "evt_1",
created_at: "2026-01-15T12:00:00.123456Z",
type: "deployment",
summary: "Synthetic",
},
],
next_cursor: null,
};
assert.ok(conforms(page, schema));
assert.equal(conforms({ ...page, tenant_id: "tenant_a" }, schema), false);
assert.equal(
conforms(
{ ...page, items: [{ ...page.items[0], raw_payload: {} }] },
schema
),
false
);
assert.equal(conforms({ items: page.items }, schema), false);
assert.equal(conforms({ ...page, next_cursor: "" }, schema), false);
assert.equal(
conforms({ ...page, items: [{ ...page.items[0], id: 1 }] }, schema),
false
);
assert.equal(
conforms(
{ ...page, items: [{ ...page.items[0], created_at: "yesterday" }] },
schema
),
false
);
const errorSchema = specification.components.schemas.InvalidCursor;
assert.equal(
conforms(
{ error: { ...invalidCursor.error, stack: "internal" } },
errorSchema
),
false
);
assert.equal(
conforms(
{ error: { ...invalidCursor.error, message: "tenant_a" } },
errorSchema
),
false
);
});
test("the existing project-detail route preserves access and ignores pagination parameters", async () => {
const own = await request(
"feed",
{ cursor: "broken", limit: "0" },
fixtures.tokenA,
true
);
assert.equal(own.status, 200);
assert.deepEqual(own.body, { id: "feed", name: "Activity feed" });
const inaccessible = await request("private", {}, fixtures.tokenA, true);
assert.equal(inaccessible.status, 404);
assert.deepEqual(inaccessible.body, notFound);
const unauthenticatedResult = await request("feed", {}, null, true);
assert.equal(unauthenticatedResult.status, 401);
assert.deepEqual(unauthenticatedResult.body, unauthenticated);
});
test("OpenAPI declares operation, limit boundaries, signed cursor, and response statuses", () => {
assert.equal(specification.openapi, "3.1.0");
const operation = specification.paths["/v1/projects/{project_id}/events"].get;
assert.equal(operation.operationId, "listProjectEvents");
const limit = operation.parameters.find(
(parameter: { name: string }) => parameter.name === "limit"
).schema;
assert.deepEqual(limit, {
type: "integer",
minimum: 1,
maximum: 100,
default: 25,
});
assert.deepEqual(Object.keys(operation.responses).sort(), [
"200",
"400",
"401",
"404",
]);
assert.equal(
specification.components.securitySchemes.session.scheme,
"bearer"
);
});Testnachweise erfassen
mkdirSync(output, { recursive: true });
const states = [];
for (const [name, arguments_] of [
["red", ["--seeded"]],
["green", []],
]) {
const result = spawnSync(
process.execPath,
[
"--experimental-strip-types",
resolve(directory, "test.ts"),
...arguments_,
],
{
cwd: directory,
encoding: "utf8",
timeout: 30_000,
}
);
writeFileSync(
resolve(output, `${name}.log`),
`${result.stdout ?? ""}${result.stderr ?? ""}`
);
states.push({
name,
command: `node --experimental-strip-types test.ts${arguments_.length ? " --seeded" : ""}`,
exit_code: result.status,
signal: result.signal,
error: result.error?.message ?? null,
});
}
const sources = Object.fromEntries(
readdirSync(directory, { withFileTypes: true })
.filter((entry) => entry.isFile())
.map((entry) => [
entry.name,
createHash("sha256")
.update(readFileSync(resolve(directory, entry.name)))
.digest("hex"),
])
);
const observed = { red: await observe(true), green: await observe(false) };
writeJson("observed-http.json", observed);
writeJson("run-manifest.json", {
execution: "Synthetic loopback HTTP fixture; no external service",
recorded_at: new Date().toISOString(),
node: process.version,
minimum_node: "22.6.0",
dependencies: "Node standard library only; no install step",
baseline:
"Deliberately seeded timestamp-only continuation; not a historical customer defect",
correction:
"Descending timestamp-and-ID tuple continuation using full fractional precision",
source_sha256: sources,
states,
});
if (
states[0].exit_code === null ||
states[0].exit_code === 0 ||
states[1].exit_code !== 0
) {
throw new Error(
"Expected the unchanged tests to fail on the seeded baseline and pass on the corrected implementation. Inspect red.log and green.log."
);
}
console.log(
JSON.stringify(
{
execution: "synthetic-loopback-http",
red_exit: states[0].exit_code,
green_exit: states[1].exit_code,
green_pages: observed.green.pages.map((page) =>
page.body.items.map((item: { id: string }) => item.id)
),
evidence_directory: output,
},
null,
2
)
);Angaben für die Aufgabe zusammenstellen
Ein Link zum Issue hilft nur, wenn Codex es lesen kann. Ist die Quelle nicht zugänglich, füge die relevanten Inhalte direkt ein oder hänge sie an. Gib im ersten Prompt die folgenden Informationen mit.
| Angabe | Beispiel-Issue |
|---|---|
| Issue und Ziel | API-142: Ergänze GET /v1/projects/{project_id}/events, damit die Kundschaft den Aktivitätsfeed seitenweise abrufen kann. |
| Repository und Ausgangsstand | Lege den Beispielordner im gewünschten Repository ab. Halte anschließend den Branch und den genauen Commit fest, den du für die Aufgabe ausgewählt hast. |
| Relevanter Code | Die Beispieldateien api.ts, fixtures.ts, test.ts und openapi.json sowie die AGENTS.md deines Repositorys. |
| Bestehende Konventionen | Prüfe weiterhin zuerst die Authentifizierung und die Berechtigung für das Projekt und erst danach die Paginierungsparameter. Verwende signierte Cursor und das dokumentierte öffentliche Antwortformat für Fehler. Wenn du das Issue anpasst, orientiere dich an den vorhandenen Hilfsfunktionen im Repository. |
| Test-Setup | Feste Testprojekte im Arbeitsspeicher für zwei Mandanten, sechs Projekte für Mandant A, Ereignisse mit identischem Zeitstempel auf beiden Seiten einer Seitengrenze, Zeitstempel mit Sekundenbruchteilen, leere und exakt volle letzte Seiten sowie 105 Ereignisse zum Prüfen der Größenbegrenzung. |
| Validierung | node --experimental-strip-types test.ts --seeded (erwarteter Fehlschlag), node --experimental-strip-types test.ts (korrigierter Stand) und node --experimental-strip-types reproduce.ts ./evidence. Ergänze für deinen eigenen Dienst die dort verwendeten Befehle für Typprüfung, Linting, Regressionstests und CI. |
| Umfang | Der Endpunkt, gezielte Tests dafür und die zugehörige OpenAPI-Dokumentation. Keine neuen Abhängigkeiten, Datenbankmigration, Frontend-Arbeit, Bereitstellung oder Neugestaltung der Authentifizierung und Autorisierung. |
| Übergabe | Ein PR-Entwurf, wenn die verfügbare Repository-Integration das unterstützt und du die Erstellung genehmigt hast. Andernfalls ein Diff und ein Entwurf der PR-Beschreibung. |
Stelle für das Beispiel Node ab Version 22.6 bereit. Die Tests erstellen eigene Testsitzungen und einen Schlüssel zum Signieren der Cursor. Außerdem binden sie einen temporären HTTP-Server an die Loopback-Schnittstelle. Bereite für deinen eigenen Dienst auch die Abhängigkeiten, die Testkonfiguration und die isolierten Dienste vor. Prüfe vor der Vergabe des Issues, ob die vorhandene Hilfsfunktion einen Cursor an den authentifizierten Mandanten und das angeforderte Projekt binden kann.
Die API-Spezifikation festlegen
Prüfe vor der Implementierung, ob die folgende Spezifikation des Beispiels zu deinem Repository passt. Eine erfolgreiche Antwort hat den HTTP-Status 200 und enthält genau { items, next_cursor }.
Jeder Eintrag enthält genau vier öffentliche Pflichtfelder: id (nicht leere Zeichenkette), created_at (Zeichenkette mit einem UTC-Zeitstempel gemäß RFC 3339), type (nicht leere Zeichenkette) und summary (Zeichenkette). items ist ein Array dieser Objekte. next_cursor ist eine für den Client undurchsichtige, nicht leere Zeichenkette oder null.
Interne Mandanten- und Projektschlüssel, Datenbankmetadaten, unverarbeitete Ereignisdaten und Zugangsdaten gehören nicht in die Antwort. Beschreibe in OpenAPI die Feldtypen der Antwort, welche Felder erforderlich sind und welche null zulassen. Lege für jedes Objekt fest, dass keine zusätzlichen Felder erlaubt sind. Prüfe die serialisierten HTTP-Antwortkörper anhand dieses Schemas.
Die Ereignisse werden nach created_at DESC, id DESC sortiert. Dabei bleibt die Genauigkeit der Sekundenbruchteile erhalten. Bei gleichem Zeitstempel entscheidet die absteigende lexikografische Reihenfolge der IDs. Der Cursor setzt den Abruf in dieser Reihenfolge strikt nach dem zuletzt zurückgegebenen Tupel fort.
Die Standardseitengröße beträgt 25. Gültige Grenzwerte sind dezimale Ganzzahlen von 1 bis einschließlich 100. Mehrfach angegebene Limit- oder Cursor-Parameter sind ungültig. Gib nur dann einen Cursor ungleich null zurück, wenn es ein weiteres passendes Ereignis gibt.
Sowohl eine teilweise gefüllte als auch eine exakt volle letzte Seite liefert next_cursor: null. Ein leeres Projekt, für das eine Zugriffsberechtigung besteht, liefert items: [] und next_cursor: null.
Das Beispiel signiert jeden Cursor und bindet ihn an den authentifizierten Mandanten und das angeforderte Projekt. Prüfe zuerst die Identität und die Zugriffsberechtigung für das angeforderte Projekt. Validiere erst danach das Limit oder den Cursor, damit Parameterfehler nicht verraten, ob ein Projekt eines anderen Mandanten existiert.
Bei fehlender oder ungültiger Sitzung lautet der Statuscode 401. Für ein unzugängliches Projekt wird dieselbe allgemeine 404-Antwort zurückgegeben wie für ein nicht vorhandenes Projekt. Sobald der Zugriff bestätigt ist, prüfe zuerst das Limit und dann den Cursor.
Ist der Cursor fehlerhaft formatiert, manipuliert, strukturell ungültig oder gehört er zu einem anderen Mandanten oder Projekt, lautet die Antwort HTTP 400 mit dem Code invalid_cursor. Auch ein gültiger Cursor für ein anderes Projekt desselben Mandanten oder für einen anderen Mandanten ist ungültig, wenn er beim Abruf eines zugänglichen Projekts mitgegeben wird.
Bei einem unzugänglichen Projekt darf ein mitgegebener Cursor das Ergebnis der Berechtigungsprüfung nicht ändern. Cursor der Version 1 laufen im Beispiel nicht ab. Nicht unterstützte Versionen sind ungültig.
Im Beispiel hat jeder Fehlerantwortkörper genau die Form { error: { code, message } }. Beide Felder sind Pflichtfelder vom Typ Zeichenkette. Zusätzliche Felder sind nicht erlaubt.
Verwende diese allgemeinen Fehlerantworten:
- 400
invalid_cursor/Invalid cursor. - 400
invalid_limit/Limit must be an integer from 1 through 100. - 401
unauthenticated/Authentication required. - 404
not_found/Project not found.
Kein Fehlerantwortkörper darf decodierte Cursor-Inhalte, Mandanten- oder Projektkennungen, unverarbeitete Fehlermeldungen oder Stacktraces enthalten. Falls dein Repository ein anderes Antwortformat oder andere Fehlercodes vorgibt, verwende die dort freigegebenen Vorgaben. Kläre diese Abweichung in der Spezifikation, bevor du gemeinsam genutzte Hilfsfunktionen änderst.
Die Tests für den vollständigen und den wiederholten Abruf verwenden feste Testdaten ohne parallele Schreibzugriffe. Folgst du den Cursorn, muss jedes Ereignis genau einmal in der vereinbarten Reihenfolge erscheinen. Für einen nicht leeren Feed muss der Durchlauf nach höchstens ceil(event_count / limit) Anfragen enden, für einen leeren Feed nach einer Anfrage.
Solange die Testdaten unverändert bleiben, liefert ein erneuter Abruf mit einem gültigen Cursor und denselben Anfrageparametern dieselben Einträge und dieselbe Position für die Fortsetzung. Die signierten Token müssen dabei nicht bytegenau übereinstimmen.
Die Spezifikation garantiert weder nur einmal verwendbare Cursor noch die Paginierung auf Basis eines Snapshots oder identische Ergebnisse nach Änderungen am Feed. Dokumentiere die bestehenden Konsistenzregeln des Repositorys für den Feed. Gibt es keine solchen Regeln und verlangt das Issue einen Snapshot, warte eine Produktentscheidung ab.
So gehst du vor
-
Wähle das Issue aus und bereite die Umgebung vor. Vergewissere dich, dass die obige Spezifikation zum tatsächlichen Repository passt. Wähle die vorbereitete Cloud-Umgebung und den vorgesehenen Basis-Commit aus. Gib die zusammengestellten Angaben zum Issue direkt in der Aufgabe mit. Du kannst diesen Workflow ohne automatischen Auslöser im Issue-Tracker starten.
-
Führe den ersten Prompt aus. Ersetze die Angaben in eckigen Klammern durch dein Repository, die Angaben zum Issue, den vereinbarten Umfang und die Prüfungen. Entscheide, ob Codex ein Diff zurückgeben oder mit deiner Genehmigung einen PR-Entwurf erstellen soll. Der erste Prompt auf dieser Seite enthält alle Anweisungen für die Übergabe.
-
Prüfe den Ausgangsstand. Codex soll die Anweisungen im Repository lesen und die genehmigten Prüfungen für den Ausgangsstand ausführen, bevor es den Code bearbeitet.
Führe für das Beispiel
node --experimental-strip-types test.tsaus. Mit--seededlässt sich der absichtlich eingebaute Fehler in einem separaten Lauf demonstrieren.Führe für deinen eigenen Dienst die vorhandenen Regressionstests, Typprüfungen und Lint-Prüfungen aus. Möglicherweise gibt es für einen neuen Endpunkt noch keine eigene Testdatei. Halte dann fest, dass dieser Test noch erstellt werden muss. Behebe Fehler in bestehenden Prüfungen und stelle nicht verfügbare Testdienste wieder bereit, bevor du spätere Ergebnisse der neuen Funktion zuschreibst.
-
Implementiere und prüfe das vereinbarte Verhalten. Bitte Codex, die vorhandenen Hilfsfunktionen für Zugriff und Cursor zu verwenden, den Endpunkt zu implementieren, die unten aufgeführten Akzeptanztests hinzuzufügen und die API-Dokumentation des Endpunkts zu aktualisieren. Soweit praktikabel, sollten die neuen Tests mit dem ursprünglichen Code fehlschlagen und nach der Änderung bestehen. Nimm beide Ergebnisse in die abschließende Prüfdokumentation auf. Im Beispiel zum Herunterladen aktiviert
--seededfür diesen Vergleich einen absichtlich eingebauten Fehler. Ein Fehlschlag bei den Prüfungen des Ausgangsstands in deinem Repository ist davon getrennt zu behandeln. -
Prüfe die Änderung und die Nachweise. Betrachte das Diff, die Akzeptanzprüfungen, ihre Ausgaben und die verbleibenden Risiken zusammen. Erstellt Codex mit deiner Genehmigung einen PR-Entwurf, prüfe, ob Basis und Head stimmen. Stehen keine PR-Werkzeuge zur Verfügung, bereite den PR mit dem zurückgegebenen Diff und der Beschreibung nach eurem üblichen Verfahren vor. Liste offene Prüfungen im PR-Entwurf auf und gib ihn noch nicht zum Merge frei.
-
Arbeite das Review-Feedback ein und führe den Merge nach eurem üblichen Verfahren durch. Gib Codex in derselben Aufgabe die konkreten Kommentare, die es bearbeiten soll. Führe anschließend die betroffenen Prüfungen erneut aus. Vor dem Merge prüft die für das Review zuständige Person die erforderlichen CI-Ergebnisse und gibt den finalen Commit frei.
Erforderliche Akzeptanztests
Mit diesen Tests ist das Issue eng genug umrissen, um es zu delegieren, und konkret genug für ein Review. Passe die Namen an deinen Testrunner an. Behalte dabei das Verhalten bei, das jeder Test nachweisen soll.
Stabiler Durchlauf
Lege fünf feste Ereignisse an. evt_105 hat den neuesten Zeitstempel. evt_104, evt_103 und evt_102 haben denselben mittleren Zeitstempel. evt_101 hat den ältesten.
Bei limit=2 müssen genau diese Seiten entstehen: [evt_105, evt_104], [evt_103, evt_102], [evt_101]. Die Ereignisse mit identischem Zeitstempel müssen sich auf die ersten beiden Seiten verteilen.
Prüfe die genaue Reihenfolge und stelle sicher, dass keine ID fehlt oder doppelt vorkommt. Auf den ersten beiden Seiten muss der Cursor ungleich null sein, auf der dritten null. Der Test muss fehlschlagen, wenn der Durchlauf mehr als drei Anfragen benötigt.
Verwende den ersten Fortsetzungscursor bei unveränderten Testdaten erneut mit demselben Limit. Prüfe, ob die zweite Seite dieselben Einträge liefert und die Fortsetzung an derselben Position beginnt.
Standardgröße und Grenzwerte
Lege mehr als 100 Ereignisse an. Prüfe, ob ohne den Parameter limit 25 Einträge zurückkommen, bei limit=1 ein Eintrag und bei limit=100 100 Einträge.
Ungültige Grenzwerte
Prüfe, ob 0, 101, -1, eine Zahl mit einem Bruchteil ungleich null und eine Zeichenkette wie many jeweils HTTP 400 im bestehenden Format für Validierungsfehler liefern.
Leere und letzte Seiten
Prüfe, ob ein leeres Projekt, für das eine Zugriffsberechtigung besteht, items: [] und next_cursor: null liefert. Prüfe bei limit=2 beide Fälle: Bei fünf Ereignissen enthält die dritte Seite einen Eintrag und der Cursor ist null. Bei vier Ereignissen enthält die zweite Seite zwei Einträge und der Cursor ist ebenfalls null. Nach einer vollen letzten Seite darf keine weitere Anfrage für eine leere Seite nötig sein.
Authentifizierung
Prüfe, ob bei fehlender oder ungültiger Sitzung eine Antwort gemäß dem vereinbarten 401-Schema zurückkommt. Das gilt auch für Anfragen mit einem fehlerhaft formatierten Cursor oder einem Cursor aus einem anderen Geltungsbereich. Die Cursor-Validierung darf das Ergebnis der Authentifizierung nicht überschreiben.
Mandantentrennung
Authentifiziere dich als Mandant A und fordere das Projekt von Mandant B oder ein nicht vorhandenes Projekt an. Prüfe, ob in beiden Fällen derselbe vereinbarte allgemeine 404-Antwortkörper ohne Ereignisdaten zurückkommt. Das gilt auch, wenn die Anfrage einen fehlerhaft formatierten Cursor oder einen Cursor mit unpassendem Geltungsbereich enthält. Die Berechtigungsprüfung muss vor der Cursor-Validierung erfolgen.
Geltungsbereich des Cursors
Fordere ein zugängliches Projekt von Mandant A zweimal an: (1) mit einem gültigen signierten Cursor eines anderen Projekts von Mandant A und (2) mit einem gültigen signierten Cursor, der für Mandant B ausgestellt wurde.
Prüfe, ob beide Anfragen denselben HTTP-400-Antwortkörper mit invalid_cursor liefern, ohne Ereignisdaten oder Angaben zum Geltungsbereich. Teste diese Fälle getrennt von Anfragen für ein unzugängliches Projekt. Diese müssen 404 liefern.
Fehlerhaft formatierte und manipulierte Cursor
Prüfe bei einem zugänglichen Projekt, ob HTTP 400 mit invalid_cursor zurückkommt, wenn die Hilfsfunktion ein Token nicht decodieren kann, die Signatur eines Tokens verändert wurde oder in einem signierten Token erforderliche Cursor-Felder fehlen oder den falschen Typ haben. Verwende isolierte Test-Fixtures für die Signierung.
Teste nicht unterstützte Versionen oder abgelaufene Token, sofern die gemeinsam genutzte Hilfsfunktion Versionierung bzw. Ablaufzeiten unterstützt. Prüfe, ob die Antworten dem vereinbarten allgemeinen Fehlerschema entsprechen und keine decodierten Inhalte, Kennungen, unverarbeiteten Fehlermeldungen oder Stacktraces enthalten.
Bestehendes Verhalten
Das Beispiel prüft die bestehende Route für Projektdetails mit berechtigten und unberechtigten Anfragen sowie mit Anfragen für unzugängliche Projekte. Führe in deinem Dienst die bestehenden Regressionstests, die Typprüfung und das Linting aus.
Öffentliches Antwortschema
Validiere die tatsächlichen Antwortkörper für HTTP 200, 400, 401 und 404 anhand der vereinbarten OpenAPI-Schemas. Prüfe die Pflichtschlüssel, die Feldtypen der Einträge, das Zeitstempelformat und ob der Cursor null zulässt. Prüfe außerdem, dass auf keiner Objektebene zusätzliche Eigenschaften vorkommen.
Lege gespeicherte Ereignisse mit internen Feldern an und prüfe, ob diese Felder in den serialisierten Einträgen fehlen. Stelle sicher, dass jede Fehlerantwort nur den dafür freigegebenen allgemeinen Code und die zugehörige Meldung enthält.
Dokumentation
Prüfe, ob die OpenAPI-Operation und die Beispiele die Implementierung korrekt wiedergeben. Dazu gehören die Parameter, die genauen Erfolgs- und Fehlerschemas, der Vorrang der Berechtigungsprüfung, die Sortierung, die Regeln für die letzte Seite und die Grenzen der Zusagen zu wiederholten Abrufen und zur Konsistenz bei festen Testdaten. Führe die Validierung der API-Spezifikation aus, sofern das Repository eine solche Prüfung vorsieht.
Woran du ein gutes Ergebnis erkennst
Gemeinsames Prüfprotokoll
Dokumentiere jedes Akzeptanzkriterium im folgenden Format. Trage die tatsächlich beobachteten Ergebnisse ein. Existierte ein neuer Test beim Prüfen des Ausgangsstands noch nicht, vermerke „noch nicht vorhanden“. Unterscheide das von einer fehlgeschlagenen bestehenden Prüfung.
Kriterium / Test: [konkretes Verhalten und Fundstelle des Tests]
Umgebung: [Verweis auf das veröffentlichte Setup, Versionen der Laufzeitumgebung, der Datenbank und der Abhängigkeiten]
Vorher: [Revision und ID des Diffs mit den reinen Teständerungen, Befehl, Exit-Code, beobachtetes Ergebnis der Assertion, Pfad zum Protokoll]
Nachher: [finale Revision oder Basisrevision mit Diff-ID, Befehl, Exit-Code, beobachtetes Ergebnis der Assertion, Pfad zum Protokoll]
Status: [bestanden / fehlgeschlagen / blockiert / nicht ausgeführt]
Einschränkungen / Handlungsbedarf im Review: [ungeprüftes Verhalten, Hindernis oder erforderliche Entscheidung]
Ordne fehlgeschlagene und erfolgreiche Testläufe dem jeweils geprüften Stand zu. Halte dabei auch Änderungen fest, mit denen du auf der ursprünglichen Revision ausschließlich Tests ergänzt oder angepasst hast. Gib die Protokolle, die Antwort-Fixtures und das finale Diff mit. Datei- und Testnamen allein belegen keine Ausführung. Aktualisiere die Nachweise, wenn sich die geprüfte Revision ändert. Blockierte oder nicht ausgeführte Prüfungen dürfen nicht als bestanden gelten.
Eine gute PR-Beschreibung verknüpft jede Aussage mit dem zugehörigen Nachweis. Verwende diese Vorlage für die Übergabe und ersetze jede Angabe in eckigen Klammern durch tatsächlich beobachtete Ergebnisse.
Titel: Cursorbasierte Paginierung für Projektereignisse ergänzen
Issue: API-142
Basis: [Branch und Commit]
Geprüfter Stand: [Head-Commit oder Basis-Commit mit Kennung des beigefügten Diffs]
Änderungen
- Endpunkt für Projektereignisse mit der bestehenden Hilfsfunktion für den Projektzugriff ergänzt.
- Signierte Cursor wiederverwendet, die an den jeweiligen Mandanten und das jeweilige Projekt gebunden sind.
- Tests für die API-Spezifikation ergänzt und die OpenAPI-Operation aktualisiert.
Nachweise für die Akzeptanzkriterien
- [Eine Zeile je oben genanntem Kriterium mit Test, beobachtetem Ergebnis und Verweis auf das Protokoll.]
Validierung
- Vor der Änderung: [Befehl, Ergebnis und Verweis auf das Protokoll für jede Prüfung des Ausgangsstands].
- Neue Tests mit dem ursprünglichen Code: [Ergebnis oder „nicht ausgeführt“ mit Begründung].
- Nach der Änderung: [Befehl, Ergebnis und Verweis auf das Protokoll für jede erforderliche Prüfung].
- CI: [Link und tatsächlicher Status je Prüfung oder „nicht verfügbar“].
- Offene Prüfungen: [konkrete Prüfungen und Hindernisse oder „keine“ mit entsprechendem Nachweis].
Schwerpunkte für das Review
- [Verhalten mit dem höchsten Risiko und noch offene Akzeptanzkriterien.]
Verbleibende Risiken und Rücknahme der Änderung
- [Beobachtete Einschränkungen. Grenze sie von ungeprüften Annahmen ab.]
- [Wie sich die Änderung rückgängig machen lässt und ob vorhandene Aufrufer davon abhängen.]
Review-Kommentare einarbeiten
Gib Codex für einen konkreten Befund aus dem Review einen gezielten Folgeauftrag. Zum Beispiel:
Setze diesen Review-Kommentar in der aktuellen Änderung um:
„Wiederhole den Durchlauf für die fünf Ereignisse mit limit=3. Prüfe, ob die erste Seite
[evt_105, evt_104, evt_103] und die zweite Seite [evt_102, evt_101] zurückgibt.
Prüfe außerdem, ob der Fortsetzungscursor auf der zweiten Seite null ist.“
Ergänze den Regressionstest. Ändere die Implementierung nur, wenn der Test einen Fehler aufdeckt.
Führe die gezielten Tests für den Endpunkt und alle weiteren erforderlichen Prüfungen erneut aus,
die von der Änderung betroffen sind. Trage den geprüften Stand und die tatsächlichen Ergebnisse
in die Nachweistabelle ein. Halte dich an den vereinbarten Umfang.
Führe weder einen Merge noch ein Deployment durch.
Füge den Wortlaut des Kommentars ein, wenn Codex nicht direkt auf das Review zugreifen kann. Wer das Review durchführt, sollte prüfen, ob die Überarbeitung das beanstandete Verhalten tatsächlich korrigiert. Es reicht nicht, nur dem Wortlaut des Kommentars zu entsprechen.
Wann du die Arbeit unterbrechen solltest
- Die Prüfungen des Ausgangsstands schlagen fehl oder lassen sich nicht ausführen. Gib die fehlgeschlagene Prüfung und die Details zum Setup an. Korrigiere die Umgebung oder vereinbare einen dokumentierten Ausgangsstand, bevor du fortfährst.
- Die Spezifikation widerspricht dem bestehenden Verhalten. Benenne den Konflikt, die betroffenen Aufrufer und die kleinste Entscheidung, die zur Klärung nötig ist. Ändere die Spezifikation nicht stillschweigend.
- Die Änderung erfordert eine Migration, eine neue Abhängigkeit oder eine Neugestaltung der Authentifizierung und Autorisierung. Erkläre den Grund und teile das Issue auf oder grenze es neu ab, bevor du seinen Umfang erweiterst.
- Nach der Implementierung schlagen Tests fehl. Gib die Änderung noch nicht zum Merge frei. Melde die fehlgeschlagenen Testfälle. Entferne keine Assertions und schwäche die Zugriffskontrollen nicht ab, um die Prüfungen zu bestehen.
- Die Repository-Integration bietet keinen Schreibzugriff. Gib das Diff, den Entwurf der PR-Beschreibung und die Prüfnachweise zurück. Jemand aus deinem Team kann die Übergabe im Repository abschließen.
Den Workflow wiederverwenden
Sobald das erste Ergebnis im Review akzeptiert wurde, speichere die zusammengestellten Angaben zum Issue und die Akzeptanzcheckliste in der Issue-Vorlage deines Teams. Halte dauerhaft gültige Anweisungen für das Repository, etwa die Testbefehle und den Speicherort der API-Spezifikationen, in AGENTS.md oder im bestehenden Leitfaden für Mitwirkende fest.
Verwandte Anwendungsfälle
Browserspiele entwickeln
Beschreibe deine Spielidee kurz. Codex kann daraus einen konkreten Plan entwickeln und ihn...
Code migrieren
Ordne mit Codex die Bestandteile eines Altsystems dem neuen Stack zu
Deine Codebasis refaktorieren
Entferne mit Codex toten Code, gliedere große Dateien übersichtlicher, führe doppelte Logik...