OpenAI's "Agent First" Engineering: What Happens When Engineers Stop Writing Code

OpenAI's internal blog shares hands-on experience building a product with Codex and GPT-5, offering a preview of what software teams look like under an "Agent First" model.

Key Numbers

• 0 lines of hand-written code: The first version—from repo structure to AGENTS.md—was entirely generated by Codex
• 1 million lines of code: Repository size after 5 months (application logic, infrastructure, tooling, documentation)
• 3 engineers: Produced roughly 1,500 PRs, averaging 3.5 PRs per person per day
• Hundreds of daily active users: Including heavy users on the product daily
• 10x efficiency: Writing it by hand would have taken about 10 times longer

Shifting Roles: What Do Engineers Do When They Don't Write Code?

The focus shifts from writing code to systems, scaffolding, and leverage.

Humans' new jobs:

• Break big goals into small components (design, coding, review, testing)
• Let agents build step by step, then push into more complex tasks
• When something breaks, ask "what capability is missing" and encode it into the system

Four Strategies: Enabling Agents to Work Independently

Strategy 1: Give Agents an Observable Environment

• UI, logs, and metrics are all wired into the agent's runtime environment
• Agents can check logs, reproduce bugs, and verify fixes on their own
• Single Codex runs lasting over 6 hours are not unusual

Strategy 2: Give Agents a Navigable Knowledge Map

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

Right approach:

• AGENTS.md stays at roughly 100 lines, acting as a directory pointing to the right locations
• The actual knowledge base lives in a structured docs/ directory
• Execution plans, progress, decision logs, and tech debt are versioned in the repo
• CI automatically checks documentation freshness and structural integrity
• A maintenance agent continuously scans for stale docs and opens fix PRs

Strategy 3: Give Agents a Transparent Codebase

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

Concrete actions:

• Knowledge must live in the repository—not scattered across 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-box libraries

Case study: A concurrency control tool like p-limit was readily available, but the team wrote their own—because the agent needs to read the source, run tests, and modify logic

Strategy 4: Give Agents Non-Negotiable Rules

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

Two Breakthroughs

Breakthrough 1: Agents Take Over the Entire Development Loop

Agents don't just write code—they also produce:
• Product code, tests, CI configuration
• Release tooling, design history docs
• Dashboard definitions, admin scripts
• Internal tools, review replies

Even more: the patch fixing a bug in Codex itself was written by Codex

Humans' new role in the loop:

• Prioritization
• Translating user feedback into acceptance criteria
• Verifying final results
• Identifying gaps when agents get stuck and letting Codex fill them itself

Breakthrough 2: Agents Drive Features End-to-End

From a single prompt, agents can complete: 1. Reproduce the bug 2. Fix it 3. Record a video to verify 4. Open a PR 5. Handle feedback 6. Merge

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

Two New Problems

Problem 1: Throughput Exceeds Human Attention—Processes Must Adapt

• 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: fixing is cheap, waiting is expensive

Problem 2: More Output Means More Entropy—Continuous Cleanup Is Required

• Codex copies existing patterns in the repo (whether or not they're optimal)
• Initially the team spent every Friday cleaning up "AI slop"
• Later they encoded "golden principles" into the repo and built a periodic cleanup process

Core principles:

• Reuse shared tools
• Validate data at entry points
• No ad-hoc reinvention of wheels

Automated cleanup:

• Background Codex tasks periodically scan for deviations
• Update quality scores
• Open targeted refactoring PRs
• Most cleanup PRs are reviewed and merged within a minute

Open Questions

1. Can architectural coherence of a fully agent-generated system be maintained over years? 2. Where exactly should human judgment be placed for maximum leverage? 3. How should that judgment be encoded into assets that compound over time?

Core Insights

> "Software development still requires discipline—the discipline is just increasingly embodied in scaffolding rather than in any individual line of code."

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

---

This is a forward-looking practice report on the future shape of AI-driven software development, and well worth the attention of every software engineer.