All field manualsCalugaru OS

Zero to operator · 10 chapters

Codex: From Request to Verifiable Result

A plain-language operating guide for turning domain expertise into safe, reviewable, evidence-backed work across Codex surfaces.

Learn how Codex works across the app, CLI, IDE, and cloud; how to establish repository truth; how to bound authority; how to coordinate agents and extensions; and how to carry one request all the way to an independently verifiable receipt.

Begin chapter one

Deliberate progression

The curriculum

Foundation chapters give you the map. Builder chapters teach you to make controlled changes. Operator chapters teach permissions, recovery, quality, and proof.

  1. 01FoundationStart From Zero and Choose the Right SurfaceStart even if you do not have a project yet: learn the terminal, create or open a tiny Git project, choose the right Codex surface, recover from common setup failures, and finish one verified task.36 min lesson + lab
  2. 02FoundationTurn Intent Into Verifiable WorkTranslate domain expertise into a task contract, establish current repository truth, and give Codex a finish line it can prove rather than guess.42 min lesson + lab
  3. 03FoundationConfigure Codex and Teach It the ProjectUnderstand Codex configuration precedence, deliberately choose one permission system, write durable repository guidance, and place each recurring behavior in the smallest control surface that matches its scope.44 min lesson + lab
  4. 04FoundationBound Authority With Sandbox and ApprovalsGive Codex enough access to finish the work while protecting unrelated files, credentials, external systems, and irreversible actions.40 min lesson + lab
  5. 05BuilderMake the Change and Prove ItMove from a scoped plan to a narrow implementation, then prove the result with code checks and the real user flow instead of stopping at a confident summary.48 min lesson + lab
  6. 06BuilderWork Across Environments and WorktreesKeep source, runtime, preview, production, local work, cloud work, branches, and parallel checkouts separate enough that every change lands where you intend.46 min lesson + lab
  7. 07BuilderDelegate With SubagentsSplit a complex objective into independent lanes, give each agent a bounded contract, and integrate evidence without multiplying confusion.43 min lesson + lab
  8. 08OperatorBuild the Extension StackTurn repeated expertise into skills, distribute broader capabilities through plugins, connect live systems with MCP, and enforce deterministic boundaries with hooks.52 min lesson + lab
  9. 09OperatorAutomate, Embed, and Run Long Work SafelyTurn a trusted workflow into non-interactive, scheduled, SDK-driven, app-server, or long-running work with idempotence, checkpoints, bounded authority, and receipts for success and failure.49 min lesson + lab
  10. 10OperatorCapstone: From Command to ReceiptUse the complete Codex operating system to turn one real business request into a scoped, safe, tested, reviewable, and independently verifiable result.65 min lesson + capstone lab

Capstone

Deliver one command-to-receipt system

Choose a real workflow you understand and use Codex to deliver one complete vertical slice with enough evidence, controls, documentation, and recovery that a second person can verify and operate it without reading the original conversation.

What you must build

  • A task contract with one user outcome, bounded scope, non-goals, business rules, examples, negative cases, and stop conditions.
  • A current repository and environment map distinguishing source, local runtime, cloud task, preview, deployment, and customer state where relevant.
  • A concise AGENTS.md hierarchy and control-surface map containing only durable, correctly scoped guidance.
  • Separate read-only investigation, local implementation, verification, and consequential release authority.
  • An isolated branch or worktree with a narrow diff and no unrelated user changes.
  • Bounded subagent or extension use only where it materially improves independence, repeatability, access, or enforcement.
  • Risk-matched automated checks plus the actual critical user flow and at least one meaningful negative case.
  • An exact release receipt when deployment is authorized, or an explicit statement that the work is not deployed.
  • A tested rollback or recovery procedure and an operator-readable handoff.

How you prove it

  • The final result can be explained from user outcome through interface, logic, state, identity, integrations, and proof.
  • Every consequential action is within explicit authority and every credential remains in an approved secret mechanism.
  • The final diff and all verification commands are independently reviewable.
  • The highest verified environment layer is named without overstating production or customer proof.
  • A second reviewer can reproduce the core result and rollback from the delivery packet alone.
  • The retrospective identifies which workflow, if any, has earned another supervised run before automation or broader autonomy.
Home
Book
Blog
Calugaru Labs
GitHub
LinkedIn
Email
Theme