Ship payments, even as a designer

Designers are shipping real products now. We can build the homepage, the app, the onboarding, the parts we always wished we controlled. And then we hit the wall: payments.

Taking money, splitting it, paying sellers, handling refunds. It's genuinely hard, and it's usually where most builds stall. This skill exists for one reason: so you can build and test the payments yourself and get your idea to a working, try-it build, instead of stopping at the wall.

I packaged everything I learned wiring up payments for Chiblu, my marketplace, into a small, free skill. The point of this piece is to show you, as a designer, how you'd actually use it. No code. Promise.

First, what's a "skill," really?

Think of a skill as a playbook you hand to your AI assistant. You don't read it; your AI does. It's like having a specialist teammate sitting beside your AI, someone who has done this exact thing before and quietly says "no, not like that, do it this way" at the moment it matters.

That's the unlock for designers: the knowledge you don't have is now something you can load. You bring the judgment and the product sense. The skill brings the part you were never taught.

What this particular skill knows

In plain words, it knows how to take a payment, split one payment between your platform and many sellers (the marketplace move, aka Razorpay Route), onboard a seller so they can actually get paid (the bank-and-PAN paperwork, aka KYC), run refunds, and, the rare part, get unstuck when the payment provider throws an error nobody documented. It's the difference between "it works in the demo" and "it works when a real person's bank says no."

How you'd actually use it

The goal is a build you can actually try. The loop looks like this:

1. Add it to your AI assistant, once. A one-time setup (drop it in a folder, or install it as a plugin). Takes a minute, and you never open the files. From then on, your assistant just knows payments.
2. Describe what you want, in your words. You don't need the right technical terms; the skill has them. You just say what you're building: "Add a checkout where the buyer pays once, and the money automatically splits between us and the seller."
3. Your AI builds it the right way, in test mode. It follows the skill's patterns and sidesteps the traps the skill warns about: the silent webhook (the automatic "payment confirmed" ping) that never fires, the seller account that gets stuck, the error that costs engineers days. You get a version that already learned from someone else's mistakes, running on fake money so you can try the whole flow safely.
4. You review it like a designer. Does the flow feel calm? Is the empty state handled? Does the error message sound human instead of a stack trace (a wall of red error text)? That's your job, and it's the job that matters. The plumbing is handled; the experience is yours.

What you could build with it

• A real checkout for the side project you've been sitting on
• A small creator marketplace where makers get paid directly
• A membership or subscription for your community
• A "pay what you want" tip jar for your work

Things that used to mean "I need to find a backend developer," and so quietly never happened.

The shift underneath all this

For most of our careers, "I'm a designer, I can't build that" was just true. The expertise lived in other people. Skills change the sentence: the expertise you lack is now loadable, on demand, into the assistant building alongside you. Taste, plus a skill, plus the willingness to ship, that's the whole kit now.

I'm not saying skip the experts. You don't have to wait for one just to begin, and once you've got a working, tested build, the engineer who helps you take it live will find you already speak their language. That's the whole idea behind Designers Who Build, and this skill is one less reason to hand your work off before you've even tried.

It's built as a Claude Code skill, so with Claude it loads itself and just works. With another assistant, the same knowledge still applies: you point it at the repo instead, or read it yourself. The playbook is the same either way.

The skill is free and on GitHub at github.com/pradeepsiddappa/razorpay-integration. Adding it to Claude Code takes a minute: drop it in your skills folder or install it as a plugin, and the README has the exact commands. It's for Indian payments via Razorpay, unofficial, and always defers to the official docs.

Build the scary part yourself, test it, then take it live with help. That's the whole move now.