Claude to the left of me, GPT to the right. There I was, stuck in the REPL with you, pulling the lever on a terminal window and hoping something good comes out the other end.
Anxiously Failing to Connect
In early 2025, I set out to build a Java implementation of ConnectRPC using AI coding agents. I followed the playbook: Claude MD file, plan mode as soon as it was supported, iterate on the plan, then let the agent loose. The accepted wisdom. Best practices, I was told.
And I was anxious the whole time.
Every prompt I sent, I’d sit there waiting for the result, wanting to unwrap it so I could nudge the output closer to acceptable. Everyone online was talking about shipping at impossible speed. AI-assisted development was supposed to feel like a superpower. Instead, it felt like a slot machine: pull the lever, check the result, pull the lever again. I told myself I was moving fast. I forgot a thing I’ve known for years: slow is smooth, smooth is fast.
The Dopamine Trap
But I was hooked.
I think for a certain segment of the population (people who are eager to create, especially if they’re competitive) vibe coding is a social media feed that doesn’t even need an algorithm. You supply your own dopamine loop. You type what you want, wait a bit, and there it is: you unwrap your code present and it’s… sort of there. Almost right. One more spin and you’ll nail it. Just one more revision. I swear I can get it right this time. Everyone else is getting it, why can’t I?
I can see why I got a little addicted to it. The loop feels productive. You’re typing, things are happening, code is appearing on screen. That’s work, right?
It wasn’t work. I was pulling the arm on a slot machine and hoping. And when the result wasn’t right, I didn’t pause to think about why it was wrong. I just pulled again. Faster. More tokens. More spins.
Who Benefits From the Loop
The tools and platforms around me were selling a very easy, very dopamine-friendly way to fall into the REPL trap. Keep revising the plan, keep pulling the lever, and you’ll eventually get something. The “best practices,” the Claude MDs that Claude followed (most of the time, until it very much didn’t), the plan modes, the iterate-iterate-iterate cycle, were a smooth on-ramp to spending more time in the terminal, burning more tokens, staying in the loop.
This isn’t a conspiracy. It’s just incentives. Most tools in this space exist to wrap agent loops and take a margin on every token you burn. Token volume is the business model. The more time you spend in the REPL, the better the quarter looks for someone who isn’t you.
Breaking Out
Multiple revisions of my process later (and I mean revisions of the process, not the code) I had something that actually worked. A skill-driven workflow that was, honestly, beyond cumbersome to use, especially across multiple sessions. But it emitted good code.
What changed? Two things.
First, I left the TUI behind. Specs and drafts stopped living in the terminal. They lived in GitHub Issues, then eventually Jira, places where I could actually read them, think about them, come back to them. A terminal is great for execution. For many people, it’s a terrible place to think. Some folks do their best work in NeoVIM, and that’s fine, but it’s not me. There’s a reason we don’t use blue-screen WordPerfect anymore.
Second, I shifted the REPL left. Instead of typing a prompt and hoping, I started planning. Not writing binders of specs or tomes of PRDs, just a reasonable “wait, what are we actually doing here?” The conversation you’d have with a junior developer before they started coding. Light, fast, but real.
I was shocked at first how easily we’d forgotten this. How quickly the basics of “think before you build” had eroded. Then I wasn’t shocked at all, because everything around me (the tools, the incentives, the culture) was designed to skip that step.
What You Lose, What You Gain
If the agent writes the code, do you atrophy?
Only if you abdicate your own understanding.
If you type, wait, accept or reject, and never stop to ask why, then yes. You atrophy. You stop understanding what’s being built. You lose the instincts that make you a good engineer. When something breaks at 2 AM, you’re right back at the slot machine, pulling the lever under pressure, understanding less than you did six months ago.
But if your tool is built for participation, if it makes you think before you build, if it surfaces the decisions that matter, if it shows you why and not just what, then the opposite happens. You come away understanding more, not less. You absorb patterns and architectural approaches at a rate you never could have managed alone. Your toolbox gets bigger.
There’s an honest tradeoff here. You might not memorize every API signature or recall the exact syntax for a library you used once. But you’re expanding into concepts and approaches you’d never have explored on your own. That’s the tradeoff senior engineers already make: they know systems, not syntax. AI-assisted development can make that trajectory available at every level. But only if the tool is designed to keep you in the loop as a participant, not a spectator.
What We’re Building
This is why we built Cate.
Cate’s Plan mode starts with a conversation. Not ceremony, not a PRD generator, not a spec factory. Just that “looking before you leap” moment that you’d want before delegating a task to anyone on your team. The planning agent interviews you. It asks the questions that matter. By the time code starts getting written, you know what you’re building and why.
We want Cate to meet your SDLC where you are. That might not sound exciting. A low-drama, non-chaotic development team rarely is exciting. But that’s the point. We save our energy for the crunch times that actually matter instead of turning every single day into a breathless sprint, wondering whether the next spin of the AI roulette wheel is going to pay off.
We’re not wrapping agent loops to take a margin on your token burn. We’re not incentivized to keep you in the REPL. We want you in, we want you understanding, and we want you out the other side as a better engineer than you were yesterday.
Predictability. Productivity. And, frankly, just lowering anxiety.
Slow Is Smooth
I started this story anxious at my terminal, pulling an arm, hoping for a result. I was doing what everyone said to do. It felt fast. It wasn’t.
Slow is smooth, smooth is fast. We forgot it. Then we remembered it. Then we built a tool around it.
That’s Cate.
Cate is the workflow layer that makes agentic development actually ship. Request early access or get in touch.