Field guide / primary domain

Codex

26

sources in this field

Updated July 15, 2026

Current thesis

The shortest path to orientation.

Codex orchestrates multi-agent work by routing Claude for architectural reasoning and Codex for deterministic execution, reducing wasted agent PRs from ~50% to 0% in documented cases. Record & Replay converts demonstrated workflows into inspectable, editable skills without manual scripting. Self-managing threads create, organize, pin, and spawn worktrees autonomously, enabling Chief-of-Staff topologies where one persistent thread holds cross-context knowledge and routes work to child threads. The four-gate self-packaging filter prevents over-engineering: occurrence ≥2 or clearly recurrent; stable inputs, repeatable procedure, clear stopping condition; material speed/quality/consistency gains; not redundant. Durable pinned threads act as persistent workspaces. Multi-device setups require Tailscale as a hard dependency; a single always-on desktop serves as the sole code-writing node. Codex can replace SaaS with agent-native alternatives—Superhuman→Gmail CLI demonstrates the pattern of replicating well-understood UX conventions via agent-built CLI while eliminating vendor lock-in.

Evidence board

Claims worth carrying forward
01

Codex can replace a $30/mo SaaS (Superhuman) with a fully customisable agent-native email client running on Gmail CLI, replicating UX patterns while removing vendor lock-in.

02

Most of the 'AI' in the custom email client is not LLM inference — it's reading Gmail labels/archives and updating Gmail filters. Reminder that classical automation often underpins what's marketed as AI-native product.

03

The pattern: identify a subscription SaaS with well-understood UX conventions, replicate those conventions via an agent-built CLI tool, and replace recurring cost with one-time build effort. Superhuman → Gmail CLI is the worked example.

04

The /goal command works across Codex, Claude Code, and Hermes. The common failure mode is writing vague goals like 'make no mistakes'—the fix is a structured template with eight named sections that force clarity before execution.

05

STOP RULES section is the highest-leverage addition: halt on high-impact ambiguity or risk; surface uncertainties with ranked highest-confidence proposals before acting (not open-ended questions); do not expand scope after goal is satisfied. This directly targets scope creep and hallucinated architecture.

06

PLAN section enforces understand-first execution: restate understanding before non-trivial changes, prefer minimal sufficient changes over broad rewrites. DONE WHEN requires a verifiable completion state, not a subjective judgment.

07

VERIFY section must include: tests/build/lint/typecheck/manual validation; explicit statement of what could not be verified and why; and a rollback/containment plan for destructive or high-risk changes—making incompleteness visible rather than hidden.

08

Claude Code /goal and Codex /goal separate doing from judging: a working agent loops across turns while a small fast model (Haiku by default) evaluates whether the stated condition is met from conversation evidence alone—it cannot run commands or read files independently.

Adjacent fields

Key voices

Latest evidence

Recent additions

All synthesized insights →

klöss

/goal Command Structure for Codex, Claude Code, and Hermes

A structured /goal prompt template for AI coding agents (Codex, Claude Code, Hermes) that prevents scope creep, ranks uncertainties before acting, and closes completion loops. Key sections: GOAL (single measurable outcome), CONSTRAINTS, PLAN (understand-first), DONE WHEN (verifiable state), VERIFY (tests + rollback), STOP RULES (halt on ambiguity, surface ranked proposals not open questions).

George from 🕹prodmgmt.world

The /goal Command and What It Demands from Product Managers

Claude Code's /goal and Codex's /goal commands implement a completion-contract pattern: a working agent loops until a separate evaluator confirms a stated condition is met, judged only from evidence surfaced in the conversation. The post argues this punishes vague PM requirements faster than traditional development, raising the bar from 'write enough detail an engineer understands' to 'define done clearly enough an agent can keep trying and a harness can inspect proof.' Includes a practical goal template and anti-patterns.

jason

Codex-maxxing: Operating Loops, Memory, and Heartbeats

Jason Liu's workflow guide for getting maximum leverage from OpenAI Codex by treating it as a persistent work OS rather than a one-shot chat tool. Key primitives: durable pinned threads (Command-1 through Command-9), voice input for unedited thinking, steering to queue intent mid-execution, an Obsidian vault as shared agent memory, Heartbeats for recurring loops, and the side panel for artifact inspection and annotation.

Vijay Iyengar

When 1:1s Are Worth It: An Opt-In Management Framework

Vijay Iyengar argues the default weekly 1:1 is structurally flawed because its fixed cadence decouples meetings from actual need. He proposes replacing most 1:1s with public-channel work, real-time escalation, written decision communication, ambient connection, and work-oriented feedback—while preserving 1:1s for onboarding (daily for 2-3 weeks), early-career reports, remote teams, on-demand requests, and peer-manager alignment.

jason

Getting the Most Out of Codex: From Coding Assistant to Personal Work OS

Codex has matured from a coding assistant into a general work OS. Core patterns: durable pinned threads (Cmd+1–9 shortcuts), voice input for vague prompts, steering (mid-task interruption) vs. queuing (next-task scheduling), tool layers ($browser/$chrome/@computer), thread automations on a schedule, Goals with explicit verifiers (test suites, benchmarks), side panel for in-place artifact review, and shared memory via Obsidian vault with AGENTS.md routing rules.

Guinness Chen

Codex Can Now Manage Its Own Threads and Worktrees

Codex has gained self-management capabilities: it can create threads, search and organize them, pin important ones, and spin up git worktrees for parallel tasks — reducing the manual overhead of maintaining a multi-thread coding workflow.