The "2x faster" claim on my homepage is not a marketing estimate. It comes from comparing actual project timelines — BookBed and Callidus against equivalent SaaS projects tracked from peers and clients who came from agencies. This post explains the method behind it: what AI actually automates, where human judgment is irreplaceable, and why faster delivery does not mean lower-quality code.
If you are still deciding whether to build or buy, the SaaS MVP guide covers the full process. If you are evaluating AI-powered software vendors more broadly, AI SaaS solutions for business is worth reading first.
What "2x faster" actually means
Speed in software development is measured in time-to-first-working-feature, not lines of code per hour.
A traditional agency approach runs like this: discovery week, wireframes, design approval, backend spec, frontend spec, development sprint, QA, staging, production. Each hand-off introduces delay. Each approval gate adds days. Each "we'll circle back on that" becomes a blocking issue in sprint 3.
An AI-augmented solo approach compresses this because:
- There is no hand-off. The person who understands the requirements is the person writing the code.
- Boilerplate is near-instant. Authentication scaffolding, database migrations, API endpoints, form validation — AI drafts these in seconds. A senior reviews and ships in minutes, not days.
- Context stays in one head. No re-briefing. No "let me check with the team." No decision latency.
The 2x figure is conservative for well-scoped projects. For projects with a clear spec and a known stack, it is often faster. The SaaS MVP strategy guide covers what "well-scoped" looks like in practice.
What AI automates well
These are the categories where AI meaningfully reduces the time spent on solved problems:
Boilerplate generation. Auth flows, CRUD endpoints, form handlers, email templates, cron job scaffolding. These follow patterns. AI knows the patterns. What used to take an afternoon takes 20 minutes — and the review pass ensures it is not subtly wrong.
Type definitions and interfaces. In TypeScript, defining the shape of a Supabase table, a Stripe webhook payload, or an API response is tedious and error-prone. AI drafts it; I review and adjust.
Test scaffolding. Writing the structural boilerplate of a test suite — describe blocks, mock setup, basic assertion structure — is mechanical. AI handles the structure; I write the assertions that actually verify business logic.
Documentation. Inline docs for complex functions, README sections, environment variable tables. Fast to generate, easy to verify.
SQL queries and shell scripts. One-off data queries and transformations are where AI earns its keep daily. "Write a SQL query that finds all properties with iCal feeds that have not been synced in 24 hours" — done in 30 seconds, verified in 2 minutes.
Where AI fails — and must fail
This is the part nobody in the "AI replaces developers" conversation talks about.
Multi-tenant data isolation. The most dangerous thing in a SaaS product is a tenant seeing another tenant's data. Row-Level Security in Supabase and the policies that enforce it cannot be AI-generated and called done. Every RLS policy gets written by hand, tested with explicit role switches in the SQL editor, and verified against the application layer. AI does not understand your specific business rules, your data ownership model, or which columns should be filtered by which policies. A wrong RLS policy is invisible in testing and catastrophic in production.
Architecture decisions. Should this feature use a database trigger or an application-level hook? Should this data live in Postgres or Redis? Should the booking sync be polling or webhook-driven? AI will give you an answer. The answer will sound reasonable. It will often be wrong for your specific load profile, your client's ops capability, or your planned scaling path. These are judgment calls that require knowing the full context — the client, the budget, the team, the next 18 months.
Third-party integration edge cases. iCal feeds are inconsistently formatted. Stripe webhooks arrive out of order. Resend sometimes bounces delivery events minutes late. Real production integrations require understanding failure modes that are not in the documentation and not in AI training data. The BookBed iCal sync handles 12 distinct edge cases — malformed DTSTART fields, floating-time events without timezone, cancelled events that arrive as new events. AI drafted the happy path. The edge cases were written by hand.
Security decisions. Input validation, rate limiting, CSRF handling, token scoping — these cannot be delegated. Every security-adjacent code path gets a manual review pass, regardless of who generated the first draft.
The actual workflow
The stack: Claude for reasoning, code review, and complex generation. Cursor for in-editor generation and refactoring. GitHub Copilot for line completions. The three serve different roles and rarely overlap.
A typical feature looks like this:
1. Spec the feature before touching a keyboard. What does it need to do? What are the failure modes? What does the data model look like? This step is unchanged by AI. Skipping it just means AI generates the wrong thing faster.
2. Generate the scaffold. Auth middleware, database migrations, the API handler structure. AI generates; I read every line before it lands in the codebase.
3. Write the business logic by hand. The part that is unique to this product — the iCal parser, the RLS policies, the real-time subscription handlers, the Stripe webhook reconciliation. This is always manual.
4. Review the generated code. Every AI-generated function gets a deliberate read — not a skim. Looking for: incorrect assumptions about data shape, missing error handling for failure modes the AI did not consider, security gaps, and cases where the AI generated working code that does not match the actual product requirement.
5. Test against real data. Not mocks where possible. Real Stripe test events. Real iCal feeds from Airbnb and Booking.com. Real Supabase RLS policies tested with explicit role switching in the SQL editor.
Real example: Pizzeria Bestek
The Pizzeria Bestek project needed a real-time ordering system to replace phone orders and a third-party delivery app. Requirements: orders arrive at the kitchen dashboard in real time, the customer sees their order status update without refreshing, and the whole thing runs on the inexpensive hardware in a restaurant kitchen.
AI scaffolded the Supabase Realtime subscription setup in about 10 minutes. The subscription pattern is well-documented; AI knows it. What took the bulk of the time:
- State reconciliation logic when the kitchen tablet loses connectivity and reconnects — optimistic UI updates, conflict resolution, duplicate event deduplication
- The order status machine and its edge cases — what happens if a paid order is marked cancelled after a Stripe payment has already captured?
- Performance work to keep the order list responsive on a €150 Android tablet
The result: sub-second order latency, Supabase Realtime with WebSockets. AI got the project to a working first version in a fraction of the time. The production-grade version required a senior thinking through every failure mode.
Why this matters when you are evaluating a developer
If you are evaluating a developer who uses AI tools, the question is not "does AI write your code." The question is "what does AI write, what do you write, and can you tell the difference."
The answer you want: AI handles the solved problems. The developer handles the unsolved ones. And the developer can articulate, for every piece of AI-generated code in the codebase, exactly what it does and why it is correct.
If a developer cannot review their own AI-generated code — cannot spot a subtle bug in it, cannot defend an architectural decision it made — then AI is not a force-multiplier. It is a liability.
The output of every project I ship is code I can explain, defend, and hand off. AI got me there faster. The senior review made sure it was production-grade.
If you are building a SaaS MVP and want to understand what this looks like for your specific project, start a chat and we can walk through the approach in 30 minutes.