Cate is an AI-assisted development tool. We built it using itself: 1,654 merged PRs, 67% needing no finishing work at all. A typical week: ~129 PRs, each backed by a Jira spec and a post-mortem.
For context: the best published numbers for fully autonomous agent PRs range from 28% to 45% merge rates. Industry-wide, AI-generated code churn has doubled since 2021, PR review times are up 441%, and bugs per developer are up 54%. The speed is there. The quality, for most, isn’t.
This is the first in a series about how we got here: what worked, what didn’t, and what we learned. We wanted AI to handle the boring parts, both the code and the paperwork, so we could ship software that makes people’s lives better. To get there, we needed a process we could measure, repeat, and trust.
Four Attempts
I’d been experimenting with AI coding on my own time for over a year before Blue Ghost existed. The test subject was ConnectRPC for Java: a from-scratch implementation of the Connect protocol, built entirely through AI-assisted development.
I chose it because Connect has a conformance suite. Pass or fail. No ambiguity about whether the output was correct.
- December 2024: vibe coding. Trash.
- Spring 2025: large spec, long sessions. Initial promise, then snowballing mistakes leading to failure.
- Summer 2025: split the difference with a dedicated skill. The start of a process. Better.
- Late 2025: stop reinventing wheels. Teach agents to work like a human team: a small session doing just enough design, distribute the work to focused code sessions, then independent review against specs small enough to fit in context. Three weeks → 99% conformance, w/ bidi streaming, proto + JSON… and experimental MCP support.
(It’s also faster than Google’s gRPC-Java, but that’s mainly just how Connect works.)
We’ve never shipped connect-java. We may not. I’m not sure we’d have time to support it properly. That was never the point. The point was finding a repeatable process: plan a small scope, attempt it, capture what happened, revise, attempt again. Not one-shot. Not waterfall. Iterative, structured, and fast.
The Inflection
Matt had reached the same conclusion from a different direction. We’d both spent enough time with these tools to see the same thing: when the process works, it changes the math on what a small team can ship. When it doesn’t, you’re just generating technical debt at machine speed.
We either needed to dedicate ourselves to this full-time or find a new line of work.
Not because AI is magic. Because once you have a reliable process around it, the gap between teams that do and teams that don’t will be enormous. We didn’t want to be on the wrong side of that.
The Wrong Prescription
The industry is anxious right now. Engineers are questioning whether their careers have a future. CEOs are stressed about transitions they don’t fully understand. Some employees are quietly sabotaging AI initiatives they didn’t ask for.
The instinct, when everything feels like it’s changing, is to tear it all down and rebuild. New tools. New processes. New roles. Throw out the issue tracker, throw out the SDLC, start fresh with something built for the AI era.
That instinct is wrong. It’s vibe coding applied to organizational strategy: throw AI at it and see what happens.
What Didn’t Change
The goal hasn’t changed. Ship working software. That was true before AI, and it’ll be true after whatever comes next.
Your tools aren’t broken. Jira works. GitHub works. Linear works. Your team’s judgment isn’t obsolete. Your knowledge is more valuable than it’s ever been, because AI multiplies whatever you bring to the table. Bring clear thinking, get more done. Bring nothing, get nothing worth keeping.
What’s new is that you have teammates who are incredibly fast and have zero institutional memory. They don’t know your architecture. They don’t know your business rules. They don’t know what you tried last quarter and why it failed. They’ll work 24 hours a day and never once ask a clarifying question unless you make them.
The answer isn’t to reinvent your workflow. It’s to extend it so those new teammates can participate. Robot arms for code: fast, strong, tireless. Robot legs for the coordination and documentation that was always the real bottleneck. The planning you meant to do but didn’t have time for. The issue descriptions that were always too thin. The architectural context that lived in your head and nowhere else.
There’s more higher-order work to do now, not less. But if you do it, you ship faster than you thought possible.
Cate Shipped Cate
Cate orchestrates AI coding agents across your existing issue trackers and git workflow. It’s half AI, half deterministic code, and the deterministic half is the part that matters most.
What Cate looked like in its first weeks is nothing like what shipped for its first private beta. The leap between private beta and early access was just as dramatic. That’s not a failure of planning. That’s the process working: attempt, capture, revise, attempt again. Every iteration traceable. Every lesson fed back into the next round.
What’s Next
This series is what we’re learning by shipping with AI, using the tool we built for it. Not theory. Not projections. What we did, what broke, and what shipped.
Next week: we think we’re writing about what we do and don’t like about spec-driven development, but at this pace, nothing’s set in stone.
Ready to put your Claude Code setup to work? Request early access to Cate, or get in touch. We'd love to hear what you're building.