Key points
- OpenAI ran a radical experiment in 2025: 3 engineers, 5 months, ~1,000,000 lines of code, 0 human-written lines, using its Codex agent — a paradigm they call Harness Engineering (~1,500 PRs, ~3.5 PRs per person per day, estimated 10x efficiency gain).
- Core philosophy: "Humans steer. Agents execute." Engineers shift from writing code to designing environments, specifying intent, and building feedback loops.
- The term "harness" (control equipment for horses) refers to an engineering framework that guides, constrains, and empowers AI agents. The idea was partly inspired by Mitchell Hashimoto's blog posts and summarized by Martin Fowler.
- Phase 1 — Environment building (slowest): Early slowness was due to an underspecified environment, not weak models. On failure, the team never just said "try again"; they asked: what capability is missing, and how to make it clear and actionable for the agent?
- Phase 2 — Agent-readability optimization: Since the repo is agent-generated, it was optimized first for Codex's readability. Inaccessible context (Google Docs, chats, tribal knowledge) = nonexistent. Architectural consensus from Slack was written into versioned repo documents.
- Phase 3 — End-to-end autonomy: Given a single prompt, the agent could verify repo state, reproduce bugs, record demo videos, implement fixes, verify via app automation, open PRs, respond to feedback, fix build failures, and merge — escalating to humans only for judgment calls. (Highly dependent on this specific repo structure; not universally transferable.)
- AGENTS.md as a map, not manual: Large monolithic guides crowd out task context, rot instantly, and can't be verified. Use short links to structured docs instead.
- Make the app agent-readable: Once code throughput rose, the bottleneck became human QA. Solutions: per-git-worktree dev instances, Chrome DevTools Protocol integration (DOM snapshots, screenshots), LogQL/PromQL queries, automated bug reproduction. Single Codex runs often exceeded 6 hours (often overnight).
- Merge philosophy shift: Minimize blocking gates; short-lived PRs; flaky tests get follow-up runs rather than indefinite blocks. Rationale: when agent throughput far exceeds human attention, corrections are cheap and waiting is expensive — a tradeoff only responsible at this throughput level.
- Pattern copying (agents replicate suboptimal code), context drift over long runs, heavy dependence on specific repo structure/tooling, and unknown long-term architectural consistency over multi-year timescales.
- Open questions: where does human judgment add the most leverage, how to encode it so it compounds, and how the system evolves as models improve.
- OpenAI's own framing: "building software still demands discipline, but the discipline shows up more in the scaffolding rather than the code."
- OpenAI original: https://openai.com/index/harness-engineering/
- Martin Fowler's analysis: https://martinfowler.com/articles/exploring-gen-ai/harness-engineering.html
- Anthropic on context engineering: https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
- Agent Skills open-source project: https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering
- Codex introduction: https://openai.com/index/introducing-codex/
The three pillars
1. Context Engineering — Context window is a scarce resource. Instead of a 1,000-line encyclopedia-style AGENTS.md, keep it as a ~100-line directory pointing into a structured knowledge base (docs/architecture/, docs/design/, docs/quality/, docs/plans/, docs/beliefs/). Principles: progressive disclosure, map-not-manual, mechanical verification via linters and CI.
2. Architectural Constraints — Agents work best in strict, predictable boundaries. Practices: rigid layering (Types → Config → Repo → Service → Runtime → UI), mechanically enforced via custom linters and structure tests, dependencies only "forward," cross-cutting concerns enter through a single Providers interface.
3. Garbage Collection — Agents copy existing patterns, including suboptimal ones, causing drift. A weekly 20%-time cleanup proved unsustainable; the solution is encoded "golden rules" (prefer shared toolkits; no YOLO-probing of data), periodic cleanup agents that open refactor PRs, and small, frequent debt repayment.
Timeline: from 0 to 1M lines
Key practices
Context engineering
A natural evolution from prompt engineering: managing the full context state (system prompt, codebase context, git history, tool definitions, team standards, conversation history, retrieved docs) across long multi-turn agent runs.
Five strategies: selection (retrieve only relevant fragments), compression, ordering, isolation (split across specialized agents), and format optimization.
Research caveat — "Lost in the Middle": even with a claimed 1M-token window, correctness can degrade after ~32,000 tokens. More context ≠ better performance; optimal density wins.
Challenges and limitations
Impact on software engineering
| Dimension | Traditional | Harness Engineering | |---|---|---| | Core activity | Writing code | Designing environments & feedback loops | | Division of labor | Humans write, machines assist | Humans steer, agents execute | | Code origin | Human-written | Agent-generated | | Quality assurance | Manual review | Mechanical constraints + agent review | | Tech debt | Periodic paydown | Continuous garbage collection | | Scaling | Rising marginal cost | Falling marginal cost |
Skills rising in value: system architecture, tooling, process design, quality control, abstraction design. Declining: syntax details, API memorization, hand-written algorithms, boilerplate.
Martin Fowler's predictions: AI may push convergence toward fewer, more "AI-friendly" tech stacks; standardized codebase topology; harnesses becoming the starting template for new services.
How to start
1. Assess your current harness: pre-commit hooks, desired architectural constraints, structure-testing frameworks (e.g., ArchUnit). 2. Start small: Week 1 — a short directory-style AGENTS.md; Week 2 — one custom linter; Week 3 — doc-validation CI; Week 4 — a cleanup agent. 3. Iterate: OpenAI's team invested 5 months. But when it works, throughput grows with team size, tech debt is continuously repaid, and agents drive features end to end.
References
Conclusion
Harness Engineering represents a potential paradigm shift in software development — not about AI replacing engineers, but about the evolution of the engineering role: from writing every line of code by hand to designing systems in which AI can work reliably. As the OpenAI team put it: "The canary is still alive."
*Based on public OpenAI materials from 2025–2026; Harness Engineering is a fast-moving field and practices may evolve.*