My Year of Vibe Coding: From Debugging Loops to Directing Agents

A year ago, I was burning API credits watching Claude loop endlessly on the same bug. By December, I was shipping features in days that would have taken weeks. I learned to stop coding and start directing: plan obsessively, speak instead of type, trust the machine.

This is the story of how I became a different kind of developer.

Paying Tuition

I started 2025 copy-pasting code from ChatGPT and Gemini into VS Code. Canvas had just launched in both, and inline editing felt revolutionary.

I wanted seamless development without the copy-paste shuffle. Cursor's free tier hit limits fast. Cline seemed more capable, but costs mounted for marginal results. Aider was worse: twenty dollars in thirty minutes, nothing but buggy code and failing tests.

First Contact

Cursor's hype pulled me back, so I paid for a subscription. Tab autocompletion was good, but I wanted agent mode: describe a feature and watch it get built. With Claude 3.5, features eventually worked, but I spent so much time working through bugs I could have written the code myself. The agentic approach was slowing me down.

Claude 3.7 arrived, and for the first time, I could hand off small tasks—reformatting a component, wiring up a form—and watch the agent complete them without spiraling into bugs. This was the promise finally delivering. Larger features still meant debugging sessions, but I was making real progress instead of spinning in circles.

The Right Tool

In February, Anthropic had released Claude Code, a terminal-based coding agent. I kept hearing about it, so I tried it in May. Within weeks, my Cursor subscription lapsed. VS Code plus a terminal was enough.

Features that once took weeks landed in days. Bugs still surfaced, but I stopped measuring progress by bugs fixed and started measuring by features implemented.

The models kept improving through the summer, each release more capable than the last. But the real breakthrough wasn't just the models. Claude Code itself was evolving: slash commands, subagents, skills, plugins. It became the benchmark against which I judge every other agentic tool.

I tried other tools along the way—OpenCode, Copilot, Gemini CLI, Replit—but kept coming back to Claude Code. The others were capable, but none matched its pace of development.

Specs Before Code

I discovered spec-driven development early in the year from Harper's Blog. My first attempts were clunky: dozens of Google Docs, prompts pasted into Cursor one at a time, specs summarized just to fit the context window. Mixed results.

AgentOS changed that. Instead of diving into code, I'd trigger a workflow to clarify intent first: user flows, edge cases, data models, architecture, syntax conventions. The process was cumbersome and token-heavy, but it asked the questions I'd been skipping. That discipline made the difference.

Before specs, I'd build a feature, discover edge cases, refactor, find conflicts with other features, refactor again. With a solid spec upfront, the agent built toward a coherent architecture from the start.

A few months later, I abstracted AgentOS's essentials into a Claude Code slash command and skill. No more installing AgentOS into each project. Just my own portable spec workflow.

Speaking Code

I took an AI-assisted code development course that covered ground I'd already walked. But it introduced one practice that changed everything: dictation.

The instructors used Monologue. I didn't expect much. I type fast enough. But when I type, I edit as I go, and editing slows my thinking. Dictation with AI cleanup removes that friction. I can think out loud, explore ideas as I express them, and let Monologue clean up the stream while the AI captures the full nuance of my intent. It surprised me more than any model upgrade.

Now I dictate specs, feature descriptions, bug reports, even commit messages. The time I used to spend typing and editing gets spent thinking instead.

The Review Dial

By fall, my relationship with code review had traced an arc.

At the start, I wanted pure agentic flow. But early tools like Aider would loop endlessly when debugging, forcing me deep into the code just to steer it.

Then I swung the other way. The course emphasized following along closely to understand and guide the code. Comprehension improved, but speed suffered. Rapid prototyping ground to a halt.

Now I've found the middle ground. During prototyping, I barely look at the code. The agent handles implementation, and when bugs surface, I work with the agent to fix them rather than debugging myself. Spec-driven development and better models made this possible.

But I still go deep in specific situations: learning a new framework, reviewing critical business logic before production. I want to know exactly what ships.

I don't rely solely on my own review. I'll ask multiple models to find opportunities to simplify or refactor, each offering a unique perspective. Combined with DevOps automation—credential scanning, vulnerability detection, linting, type checks, tests—problems get caught without me reviewing every line.

A Different Developer

The strangest part of this year is that I'm developing more software than ever while barely opening my code editor. That used to feel like cheating. Now it feels like the job finally matching the ambition.

I still love writing code. What surprised me is discovering a different craft underneath: knowing what to build, how to structure it, and how to guide an AI to implement your vision. The conversation comes first now. The code follows.