OpenAI 'Agent First': What Software Teams Look Like When Engineers Stop Writing Code

An OpenAI internal blog post, republished on zhichai.net, describes the company's hands-on experience developing a product with Codex + GPT-5 in an "Agent First" workflow.

Key Data

• 0 lines of hand-written code: the first version, from repo structure to AGENTS.md, was fully generated by Codex
• 1 million lines of code: repository size after 5 months (application logic, infrastructure, tooling, docs)
• 3 engineers: completed roughly 1,500 PRs, averaging 3.5 per person per day
• Hundreds of daily active users, including heavy daily users
• 10x efficiency gain: hand-writing the same code would take ~10x longer

Role Shift: What Do Engineers Do When They Stop Writing Code?

The focus moves from writing code to systems, scaffolding, and leverage. The new human work:

• Breaking large goals into small components (design, coding, review, testing)
• Letting agents build incrementally, then advancing to complex tasks
• When something breaks, asking "what capability is missing" and encoding the fix into the system

Four Strategies for Agent Autonomy

1. Give Agents an Observable Environment

• UI, logs, and metrics are all wired into the agent's runtime
• Agents can check logs, reproduce bugs, and verify fixes themselves
• Single Codex runs of 6+ hours are not unusual

2. Give Agents a Navigable Knowledge Map

Wrong approach: stuffing all rules into one giant AGENTS.md (long and quickly stale).

Right approach:

• Keep AGENTS.md to ~100 lines as an index pointing to the right places
• Put real knowledge in a structured docs/ directory
• Keep execution plans, progress, decision logs, and tech debt versioned in the repo
• CI automatically checks documentation freshness and structural integrity
• A maintenance agent continuously scans for stale docs and opens fix PRs

3. Give Agents a Transparent Codebase

Core principle: for an agent, information not available in its runtime context effectively doesn't exist.

Concrete actions:

• Knowledge must live in the repo, not in Google Docs, chat threads, or people's heads
• Prefer "boring technology" (more composable, stable APIs, well represented in training data)
• Write critical tools in-house rather than depending on external black boxes

Example: although the concurrency tool p-limit was available off the shelf, the team wrote their own—because agents need to read source, run tests, and modify logic.

4. Give Agents Rules They Cannot Bypass

Three layers of constraints: 1. Boundary constraints: all data entering the system must be validated at the boundary 2. Dependency direction: the app follows a fixed layering; business domains may only depend in prescribed directions 3. Taste invariants: structured logging, type naming, file size limits, platform reliability requirements

Two Breakthroughs

Agents Own the Full Development Loop

Agents produce more than code:
• Product code, tests, CI configuration
• Release tooling and design history docs
• Dashboard definitions, admin scripts
• Internal tools, review replies

Even the patch fixing a Codex bug was written by Codex.

The new human-in-the-loop role: prioritization, translating user feedback into acceptance criteria, verifying final results, and identifying gaps when agents get stuck so Codex can fill them.

Agents Drive Features End-to-End

From a single prompt, an agent can: 1. Reproduce a bug 2. Fix it 3. Record a verification video 4. Open a PR 5. Handle review feedback 6. Merge

No human handoff in between; escalation happens only when human judgment is genuinely needed.

Two New Problems

Throughput Exceeds Human Attention

• Traditional blocking merge strategies became inefficient
• The team adopted merge strategies that minimize blocking
• PR lifecycles are short; flaky tests are fixed by subsequent runs
• Core principle: fixes are cheap; waiting is expensive

More Output Means More Entropy

• Codex copies existing patterns in the repo, whether or not they are optimal
• Initially the team spent every Friday cleaning up "AI slop"
• Later they encoded "golden principles" into the repo and established periodic cleanup workflows

Core principles: reuse shared tools; validate data at entry points; no ad-hoc wheel reinvention.

Automated cleanup: background Codex tasks periodically scan for deviations, update quality scores, and open targeted refactoring PRs—most are reviewed and merged within a minute.

Open Questions

1. Can architectural consistency in a fully agent-generated system be sustained over years? 2. Where exactly should human judgment sit to create maximum leverage? 3. How should that judgment be encoded as an accumulating asset?

Core Insight

> "Software development still requires discipline—it's just that discipline increasingly lives in scaffolding rather than in any single line of code."

> "What really matters are the tools, abstractions, and feedback loops that maintain codebase consistency."

---

A forward-looking practice report on the future shape of AI-driven software development, worth every software engineer's attention.