How I Built a Fully Async Feature Pipeline With Claude, Notion & Vercel

Six months ago, I could only write code when I was sitting at my desk, laptop open, fully present.

That's just how it worked. You need to develop a feature, you sit down and build it. That was the deal.

Not anymore.

The old way wasn't broken. It was just slow.

I'm building Finly — a personal finance assistant. And like most side projects, the bottleneck was never ideas. It was time. Specifically, the time I had to actually sit down and build things.

So I started asking a different question. What if the pipeline itself was async? What if a feature could go from idea → production without me needing to be available for hours at a stretch?

"The goal wasn't to remove myself from the process. It was to stop being the bottleneck in it."

Here's what I ended up building.

It starts with a conversation, not a ticket

When I want to build something for Finly, I open Claude and just... talk about it. What do I want? Why do I want it? What should it actually do?

I have a skill that takes that conversation and turns it into a proper user story in Notion — with the right format, the right questions asked, the right details captured. No code discussion at this stage. Just the requirement, written cleanly.

And then I mark it with one property: execution mode = async.

That's it. That's the whole trigger. I close my laptop and move on with my day.

9am. Claude picks it up.

Every morning at 9am, a Claude routine fires automatically. It scans for async tasks, picks the right one for the day, and starts working through it.

But here's the thing — it doesn't just go write code. It runs through five gates. And I'm the approver at every single one.

Gate 1 — Understanding. Claude reads the requirement and maps it against the actual codebase. Then it pings me: "here's what I think we're building, is this right?" I correct it if needed, then approve.

Gate 2 — High-level design. Claude proposes the approach. I approve.

Gate 3 — Technical implementation plan. Claude breaks the design into steps. I approve.

Gate 4 — Code. Only now does it actually write anything.

Gate 5 — PR. Once the code's done, Claude raises the pull request.

Five gates. Five deliberate checkpoints where I stay in the loop without being in the weeds. 💡

"Async doesn't mean fully autonomous. It means the work happens without me being present — but I still make every meaningful decision."

Testing from my phone

Finly runs on Next.js, deployed on Vercel. So every PR automatically generates a preview link.

I get that link on my phone. I tap it. The Vercel app opens the preview, and I test the feature right there — on mobile, the way a real user would experience it.

If it looks good, I open the GitHub mobile app, do a proper code review, and merge.

No laptop. Not once in that entire flow.

Same prompts. Same codebase. Completely different working style.

What happens after merge (still being built)

This part isn't live yet — but I'm close.

Once a PR merges, another skill kicks in. It takes the merged code, combines it with the original feature requirement, and drafts:

• A launch tweet for the feature

• A LinkedIn post

• A prompt to generate the cover image

Right now I'm still manually taking that image prompt and feeding it into an image gen model myself. That's the last bit of friction left in the announcement pipeline, and it's annoying enough that it's next on the list.

The plan: route the prompt straight to an image gen model, get the image back, and have everything land as a draft — tweet, post, image — ready for me to review and post. I haven't shipped this yet, but I know it'll work.

Next: AI does the first code review

There's one more thing I want to add.

Right now, after the code is written, I do the code review myself. I have a separate skill for this called "review ask me." And in a few days, I'm folding it directly into the async pipeline — so Claude does a first-pass review before I even look at it.

I still review. But I come in as the second set of eyes, not the first. That's a very different position to review from. And honestly, that's the part I'm most excited about right now. 🚀

"The goal is to only do the work that actually needs me. Everything else should run."

Wrapping Up

This is what 99% async feature development looks like in practice. A conversation turns into a user story. A morning routine picks it up. Five gates keep me in the loop without slowing things down. I test on my phone, merge on my phone, and soon — the launch post writes itself too.

It's not magic. It's a deliberately designed pipeline with the right checkpoints in the right places.

And honestly — it's the most fun I've had building Finly so far.

Hope you liked the read, follow me on my socials for more tech content. See you in the next blog 👋🏻