From Vibe Coding to GPT‑5.2: The Rise of Agentic Software Development

Over the past year, the way I write and ship software has been reshaped by a series of model breakthroughs. My first surprise was that a prompt that once produced a half‑finished snippet could now return a fully working module with no debugging. That expectation has hardened into a daily reality, and the token budget I spend on these requests has become a strategic consideration.

Early Vibe Coding and the Promise of Agentic Engineering

When I first met the concept of "vibe‑coding"—writing code that feels natural to the AI and letting it fill in the details—I was skeptical. The models then were prone to hallucinating syntax, misreading file structure, and frequently requiring manual “plan” passes. However, repeated use taught me that with enough exposure the model learns the project’s rhythm and stops wandering into dead‑ends. For the majority of applications—data pipelines, simple CLIs, or user‑facing front‑ends—this makes the development cycle feel almost instantaneous.

The Model Shift: GPT‑5.1 to GPT‑5.2 and CodeX

The real turning point was the release of GPT‑5.1, which gave me a glimpse of what a factory‑grade model could achieve. After a few weeks of tuning, I noticed a steady improvement in the model’s understanding of large codebases and its ability to preserve consistency across multiple files. GPT‑5.2 expanded this even further by raising the knowledge cutoff to the end of August and dropping the 50‑minute bottleneck that earlier models suffered from when parsing extensive directories.

Codex vs. Opus: Readiness vs. Speed

Opus, though quick for small edits, often skips files when executing a refactor and produces suboptimal code. CodeX, trained on a far larger corpus of pre‑execution code, spends 10–15 minutes scanning all relevant files before generating a patch. This extra pre‑processing means that the final output tends to be more accurate, and I spend less time fixing mistakes—despite CodeX occasionally taking four times longer than Opus for a comparable task. The perceived trade‑off is real; slower write times are offset by shorter subsequent edit cycles.

Oracle: Bridging the Gap Between Code Generation and Browsing

When CodeX struggled with complex, multistep problems—especially those requiring external data—I built a lightweight CLI known as Oracle. The tool runs GPT‑5.2 in a controlled session, uploads files, executes a web‑search request, and feeds the findings back to the model. In practice, Oracle turned a 4‑hour refactor into a one‑shot solution in most cases, and the need for day‑to‑day intervention has shrunk from several times per day to just a few per week. The experience also revealed that GPT‑5.2’s broader context window (up to 273k tokens with a 25k token tool‑output cap) gives it a distinct advantage over Opus.

Case Study: VibeTunnel and Migration to Zig

VibeTunnel, a terminal multiplexer I began in early 2024, sat on my desk until a recent prompt‑powered migration turned it into a Zig codebase in a single generation. The model read the forwarding logic, re‑implemented it in Zig, handled compiler errors, and produced a fully functioning build script in under five hours. That episode is a testament to how far the latest models have come: a complex rewrite that previously would have required manual effort and a deep familiarity with the original code can now be delegated to an agent.

Workflow: Iterative, Agent‑Centric Development

I keep the focus on linear evolution rather than speculative branching. CodeX’s “ghost commit” feature lets it generate a safe, temporary worktree, but in practice I usually commit directly to main. If a patch looks messy, I let the agent revert or modify the file; full rollbacks are rare. I maintain a global AGENTS.md that lists a docs:list script and other skills, so the model can pull in documentation automatically—this reduces prompt length by a large factor and keeps my mental load manageable.

Multiple machines are no longer merely a convenience. With a dedicated MacBook Pro for heavy editing and a stationary Mac Studio for UI/browser automation, I can keep long‑running tasks alive on the Studio while I travel. Tailscale and DNS‑automation skills let me trigger updates on the Studio without opening a new shell, preserving the illusion of a single‑pane workstation.

Choosing Dependencies and Architectures

Despite the power of agents, the human decision‑maker still owns the architecture. Selecting a lightweight, well‑maintained library or deciding between web sockets and REST often requires a more nuanced judgment that agents cannot yet capture. I rely on a quick audit script that enumerates peer dependencies and popularity metrics before I hand a project to an agent for implementation.

Practical Configuration

An example ~/.codex/config.toml (adapted from my setup) demonstrates how to push the model’s token budget to the limit while keeping the system efficient:

# ~/.codex/config.toml
model = "gpt-5.2-codex"
model_reasoning_effort = "high"
tool_output_token_limit = 25000
model_auto_compact_token_limit = 233000

[features]
ghost_commit = false
unified_exec = true
apply_patch_freeform = true
web_search_request = true
skills = true
shell_snapshot = true

[projects."/Users/steipete/Projects"]
trust_level = "trusted"

Conclusion

Agentic software development is no longer a futuristic aspiration; it has become a practical workflow for those willing to embrace iterative prompt engineering and lean tooling. GPT‑5.2 with CodeX, augmented by Oracle and a disciplined workflow, allows me to deliver complete features in hours that previously took days. Still, thoughtful architecture decisions, careful dependency selection, and hands‑on documentation remain essential. For anyone looking to adopt this paradigm, the key is to start with a thin, CLI‑focused prototype, let the model surface the problem space, and then iterate rapidly—each time learning how the agent behaves and adjusting prompts accordingly.