AI-First Engineering
Not prompt-and-pray code. Senior engineers backed by AI tooling that compounds their judgment, so we ship at a pace traditional shops can't, with the production reliability AI alone can't deliver.
// PR Review: Senior engineer on AI-generated webhook handler
// File: src/webhooks/revenuecat.ts
- async function handleRenewal(event: RCEvent) {
- await db.update('subscriptions', { userId: event.appUserId });
- }
+ async function handleRenewal(event: RCEvent) {
+ // Idempotency key prevents duplicate processing on retry
+ const existing = await db.findByEventId(event.id);
+ if (existing) return; // Already processed
+
+ await db.transaction(async (tx) => {
+ await tx.update('subscriptions', {
+ userId: event.appUserId,
+ processedAt: new Date(),
+ });
+ await tx.insert('webhook_events', { id: event.id });
+ });
+ }
// Comment: Without idempotency, every retry on a failed
// delivery creates a duplicate subscription update.
// RevenueCat retries up to 5x with exponential backoff. Every shop says they "use AI" now. Most use it as a typing aid.
We use it as an engineering force multiplier. Cursor, Claude, and Codex are part of our stack the way React Native and Expo are. We use them for code generation, for diff review, for migration audits, for documentation, for onboarding new clients to existing codebases. We use them where they add leverage and we don't use them where they create risk.
The result is a team that ships meaningful releases on a steady cadence with senior-engineer judgment on every line, at a fraction of the all-in cost of an in-house team.
Code generation is not, and has never been, the bottleneck in shipping production software.
The bottlenecks are knowing what to build, knowing what NOT to build, knowing the specific production behavior of the platforms you depend on, owning consequences when production breaks, and maintaining codebase coherence across years.
None of these are solved by better code generation. As AI commoditizes implementation, the value of platform-specific production scars, accountability, and ownership compounds. Vermillion sells senior judgment on top of AI-generated code in production subscription mobile systems, not implementation alone. The bet is that buyers will pay more, not less, for senior engineers who own the consequences when production breaks, because the floor of generic implementation has dropped to zero.
When everyone can ship code, the question becomes: is it the right code?
That's what we sell.
It doesn't know that RevenueCat webhooks need idempotent handlers and that missed events past the 5-retry window are unrecoverable without a support ticket.
It doesn't know that Superwall experiments can trigger App Store review rejections under Guideline 2.1 when reviewers get bucketed into a single variant and can't see all your IAPs.
It doesn't know that StoreKit 2's Transaction.updates has documented gaps where AppStore.sync() returns empty even with a confirmed Apple ID on iOS 26.4, and the only reliable fix requires a server-side reconciliation pattern.
It doesn't know which architecture decisions reverse cleanly and which harden into rewrites.
That's the platform authority we put on top of the AI tooling. That's why our work doesn't fall over at 100K subscribers. That's the part you can't prompt your way to.
What we don't do: ship AI-generated code without a senior engineer reviewing it line by line. Ever.
Start with The Trial. We review your React Native setup and your subscription infrastructure, and show you specifically where AI-first engineering would change your shipping velocity.
Four weeks · See how we work