Recently, OpenAI shared on its blog the secret experiments it had run over the past five months:A small team of three engineers built a complete product with 1 million lines of code entirely through Codex AI agents, without writing a single line by hand. This also marks a fundamental shift in the traditional concept of having software engineers (or an entire team) develop large projects: from “humans writing code” to “humans steering AI to write code.” OpenAI calls this new model “Harness Engineering…(Mastery Engineering), its core philosophy can be summarized in one sentence:Humans steer, agents execute。
The Birth of 1 Million Lines of Code: A Product Entirely Generated by AI
This experiment began in late August 2025, when the OpenAI team started from an empty Git repository and used Codex CLI with GPT-5 to generate the initial architecture from just a small set of existing templates: including the repository structure, CI configuration, formatting rules, package manager settings, and application framework. Even the AGENTS.md document instructing agents on how to work within the repository was written by Codex.
After five months, the repository contained roughly one million lines of code, spanning application logic, infrastructure, tooling, documentation, and internal developer tools. During this period, around 1,500 pull requests were opened and merged, while the engineering team behind Codex grew from just three to seven people. That translated to an average of 3.5 PRs per engineer per day, with throughput continuing to rise as the team scaled.
More importantly, this wasn’t output for output’s sake. The product already had hundreds of internal users, including heavy internal users who relied on it daily. Throughout the entire development process, humans never directly contributed any code: this became the team’s core philosophy:No manually written code.。
Harness Engineering: Redefining the Role of Engineers
The term “Harness” comes from horse tack (reins, saddles, etc.), symbolizing humanity’s control over the power of horses. Within the Harness Engineering framework, engineers are no longer code producers dismissively called “code farmers,” but designers of systems and builders of environments.
The OpenAI team found that early progress was slower than expected not because Codex lacked capability, but because the environment was not defined well enough. The agent lacked the tools, abstractions, and internal structure needed to accomplish high-level goals. As a result, the engineering team’s main job became making the agent effective, which meant a depth-first approach: breaking large goals into smaller building blocks such as design, code, review, and testing, prompting the agent to build those blocks, and then using them to unlock more complex tasks.
When something goes wrong, the solution is almost never “try again.” Since the only way to make progress is to get Codex to do the work, human engineers always dig into the task and ask themselves: “What capability is missing, and how can we make it clear and actionable for the agent?”
Humans interact with the system almost entirely through prompts: engineers describe a task, run an agent, and allow it to open a Pull Request. To drive a PR to completion, they instruct Codex to review its own changes locally, request additional targeted agent reviews (both local and cloud), respond to any feedback from humans or agents, and iterate in a loop until all agent reviewers are satisfied. Over time, they have shifted nearly all review work to agent-to-agent handling.
Make applications AI-readable
As code output increased, the bottleneck became human QA capacity. Because the fixed constraint is human time and attention, the team focused on expanding agent capabilities by making the application UI, logs, and application metrics directly readable by Codex.
For example, they made the application launchable per Git worktree, so Codex could spin up and drive an instance for each change. They also wired the Chrome DevTools Protocol into the agent runtime and created skills for handling DOM snapshots, screenshots, and navigation. This enabled Codex to reproduce bugs, verify fixes, and reason directly about UI behavior.
They did the same with observability tools. Logs, metrics, and traces are exposed to Codex through a local observability stack that is ephemeral for any given work tree. Agents can work on completely isolated versions of the application—including their logs and metrics, which are torn down after the task is completed. Agents can query logs with LogQL and metrics with PromQL. With this context, prompts like “ensure service startup completes within 800 milliseconds” or “no span in these four critical user journeys exceeds two seconds” become feasible.
The team often sees a single Codex running on a single task for six hours or more—often while humans are asleep.
Architectural Enforcement and Aesthetic Constraints
Documentation alone can’t keep a fully agent-generated codebase consistent. By enforcing invariants rather than micromanaging implementations, they let agents ship fast without breaking the foundation. For example, they require Codex to parse data shapes at boundaries but don’t dictate exactly how to do it (the model seems to like Zod, but they don’t specify that particular library).
Agents are most effective in environments with strict boundaries and predictable structures, so they build applications around strict architectural models. Each business domain is divided into a fixed set of layers with strictly validated dependency directions and limited allowable edges. These constraints are mechanically enforced through custom linters (also generated by Codex, of course!) and structural tests.
This architecture is usually not adopted until you have hundreds of engineers. But for coding agents, it is an early prerequisite: constraints are the key to enabling speed without degradation or architectural drift. In human-first workflows, these rules may feel harsh or restrictive. For agents, they become multipliers—once encoded, they apply everywhere at once.
Code throughput changes the merge philosophy.
As Codex throughput increases, many traditional engineering norms become counterproductive. Repositories operate with minimal blocking merge gates. Pull requests have short lifecycles. Flaky tests are usually resolved by rerunning rather than blocking progress indefinitely. In systems where agent throughput far exceeds human attention, the cost of fixing is low, and the cost of waiting is high.
This is irresponsible in low-throughput environments. Here, it is usually the right trade-off.
The tipping point of complete autonomy
With more development loops directly encoded into the system—testing, validation, review, feedback handling, and recovery—the repository recently crossed a meaningful threshold: Codex can now drive new features end to end.
Given a single prompt, the agent can now: verify the current state of the repository; reproduce the reported error; record a video demonstrating the failure; implement the fix; validate the fix by driving the application; record a second video demonstrating the solution; open a Pull Request; respond to agent and human feedback; detect and repair build failures; escalate to humans only when judgment is needed; merge the changes.
This behavior relies heavily on the specific structure and tooling of that repository, and should not be assumed to generalize without a similar investment—at least, not yet.
Entropy and Garbage Collection: Maintaining AI-Generated Codebases
Full agent autonomy also introduced new problems. Codex would replicate patterns already present in the repository—even uneven or suboptimal ones. Over time, this inevitably led to drift. At first, humans fixed this manually. The team used to spend every Friday (20% of the week) cleaning up “AI slop.” Unsurprisingly, that didn’t scale. Instead, they began encoding so-called “golden principles” directly into the repository and established a regular cleanup process. These principles are mechanical, opinionated rules that keep the codebase clear and consistent for future agent runs.
It’s like garbage collection. Technical debt is like a high-interest loan: it’s almost always better to pay it down continuously in small increments, rather than letting it compound and then resolving it painfully all at once. Human taste is captured once and then continuously enforced on every line of code. This also lets them catch and fix bad patterns on a daily basis, rather than letting them spread throughout the codebase for days or weeks.
Perspective: Where Is the Future of Engineers?
OpenAI’s Harness Engineering experiments reveal a disturbing yet inevitable future:The ability to write code alone is depreciating rapidly.When AI can produce 3.5 PRs while you’re asleep, and one million lines of code can be completed under the supervision of three engineers within five months, the value proposition of traditional software engineers must be redefined.
But this does not mean engineers will become obsolete. On the contrary, it means engineers must move up the value chain. Engineers of the future will no longer be “the people who write code,” but “the people who design systems”: they define objectives, establish constraints, and design feedback loops, allowing AI agents to operate autonomously within these boundaries.
This shift is similar to the transformation of artisans into engineers during the Industrial Revolution. When machines could manufacture parts, the human role became designing the machines and optimizing the processes. Likewise, when AI can write code, the human role becomes designing what the code should do, how it should be organized, and how to verify that it is correct.
The real insight of Harness Engineering lies not in the technical details, but in its organizational philosophy:When AI runs, humans must learn to steer better.This calls for a whole new set of skills: systems thinking, abstract design, defining quality standards, and a deep understanding of AI capabilities.
For students learning to program, for engineers in their careers, and for the entire tech industry, OpenAI’s experiment is a clear signal:Adapt or be eliminated.Harness Engineering is not a vision of the future, but a reality that has already arrived.
Source: KOCPC Chinese