The hype cycle has officially shifted from writing code to cleaning up the mess. OpenAI’s Core Experimentation team just proved that agents are exceptionally good at the grunt work humans hate. In a two-week sprint involving just five engineers working part-time, GPT-6 Astra identified and facilitated the deletion of over 800,000 lines of dead code across 1,400+ pull requests. This isn't just a vanity metric; the cleanup shrank a service’s container image by 48% and cut median CI times in half, proving that agentic maintenance is ready for prime time.

The Death of Manual Static Analysis

Traditional static analysis fails when it hits dynamic contexts like Slack threads or internal trackers. The old way required heavy logging and often missed dead code that was actually an emergency killswitch. With GPT-6 Astra, the team moved to a vague, human-like prompt: find and clean up dead code; feel free to check Slack, Statsig, or any other source to confirm it's really unused. The agent dug through PR history, pulled context from communication channels, and verified production profiling tables to ensure lines were never executed. It even attached a rationale to every deletion, speeding up human review.

The Cheaper Model Was Almost as Good

Here is the insider detail that matters for your budget: GPT-6.1 Sol, running at Ultra effort, produced 92% of the findings that the more expensive GPT-6 Astra did, but at only 14% of the cost. The API bill for Sol was $15.12 compared to Astra's $109.06 for the same 6,000-file repository scan. While Astra caught slightly more complex dependencies, the cost-per-finding for Sol was $0.12 versus $0.77 for Astra. For most maintenance tasks, the cheaper model is the logical default, saving massive amounts of compute while delivering nearly identical results.

The Permanent Flag That Wasted CPU

The most telling story from the report involves a permanent feature flag that had been burning ~0.42% of CPU in a main service. Astra identified the inefficiency but refused to delete it on its own, escalating to a human reviewer because the flag was marked Permanent in the console. This demonstrates a crucial capability: knowing when to stop. The agent calculated the cost, understood the intent, and handed the final decision to a human, avoiding a potential operational disaster. After review, the flag was removed, saving significant resources without breaking the system.

CI Speedups and the Review Bottleneck

Beyond code deletion, the agents optimized the CI pipeline itself. By scanning run history and suggesting fixes, the team reduced median CI time from ~10 minutes to 4.5 minutes. One standalone fix, adding a missing mock, cut a 63-test suite runtime by 95%. However, the author notes a critical bottleneck: human review. With 1,400 PRs, even a 10-minute review per PR equals 230 person-hours. The agent generates the work, but the human must verify it. This shifts the scarce resource from token generation to reviewer attention, meaning your CODEOWNERS strategy needs to be tighter than ever.

Key Takeaways

  • Verification is cheaper than generation: Agents excel at tasks where confirming safety (via logs, Slack, profiling) is easier than writing new logic.
  • Cost efficiency is real: GPT-6.1 Sol delivers 92% of Astra’s findings at 14% of the cost, making cheap models viable for bulk maintenance.
  • Observability is a prerequisite: Without production telemetry and profiling data, agents are just guessing; investing in observability unlocks agentic maintenance.
  • Human review is the bottleneck: The API cost is negligible compared to the hours spent reviewing 1,400 PRs; optimize PR format and ownership routing.

The Bottom Line

Stop waiting for agents to build your next feature; let them delete your tech debt. The ROI on cleaning up old code is immediate, measurable, and less risky than generation, but only if you have the telemetry to back it up.