How I AI: Gumroad CEO Sahil Lavingia’s Workflow for Building Features 40x Faster

In this episode of How I AI, Gumroad founder and CEO Sahil Lavingia moves a product idea through v0, Devin, and Cursor, then shows how his team uses the same agent for small maintenance work.

At the time of recording, Sahil said Devin was writing 41 percent of Gumroad's pull requests and that he wanted the figure to reach 80 percent by year-end. Those are Gumroad's reported adoption numbers, not a recommended target for every engineering team.

His tool sequence is straightforward: clarify the interaction in v0, hand the refined requirement to Devin, and use Cursor when the implementation needs direct intervention. The output still moves through the repository's pull-request process.

The demonstration covered a natural-language date picker, a cleanup to an AI-generated Slack recap, and a time-boxed internal incentive for learning Devin.

Move from product idea to pull request

The v0-and-Devin feature workflow separates interaction design from repository implementation. Sahil clarifies the UI in v0, gives Devin the requirement and codebase, then reviews the pull request and running behavior before merge.

Sahil used the contractor-invitation page in Flexile, a Gumroad internal product. Its native browser date picker worked, but it did not support natural-language inputs such as next Monday.

"Can you do something that used to take two weeks in two hours? And that's like a 40 times speed increase. So that's kinda like the number that I have in my head."

Sahil contrasted the agent workflow with a small change that might otherwise wait through specification, design, and engineering queues. His 40x figure describes an optimistic comparison between a two-week process and a two-hour implementation, not measured output across all work.

Clarify the interaction in v0

Sahil begins with v0 because an interactive prototype helps him decide what the feature should do before an agent edits the production repository.

He iterates on behavior, labels, defaults, and edge cases. In this example, a calendar replacement became a richer input with natural-language dates and common suggestions.

1. Initial direction: Replace the browser date input with a more human-friendly component inspired by shadcn/ui.
2. Iteration: Add inputs such as next Monday, tomorrow at 9:00 AM, and role-specific date suggestions.
3. Refined requirement: Describe the job and user context clearly enough that the prototype can expose missing decisions before implementation.

build a really dope natural language day picker for an HR product onboarding form

The prototype produced an interactive React component with suggestions including Next Monday and In two weeks. Sahil used those iterations to improve the requirement rather than treating the first screen as the final specification.

Hand the requirement to Devin

Once the interaction is clear, Sahil gives Devin the refined prompt, repository, and target page. v0 explores the product behavior; Devin works in the codebase.

The handoff can use the final prompt, a shared prototype, or generated component code when it fits the repository.

"Normally I would take like the final prompt and I would just paste that into Devin... build this form."

Devin prepares its environment, finds relevant files, installs dependencies when needed, edits the implementation, and runs the checks available to it.

The session trace records commands and file changes, which helps a reviewer inspect the implementation and investigate failures. A trace is evidence of what ran, not proof that the behavior is correct.

Review, test, and merge

Devin opened a pull request with a natural-language parser for inputs such as next Monday and tomorrow. Review should cover parsing boundaries, locale and time-zone behavior, accessibility, tests, and the surrounding onboarding flow.

When a change needs direct work, Sahil opens it in Cursor. He also described Devin's pairing mode as a possible way to enter the agent environment and collaborate during implementation.

The first version was merged during the recording. That demonstrated the speed of this particular loop; it did not establish that every task can move from idea to safe production behavior in the same time.

Clean up a Slack recap

The quick maintenance-agent workflow applies the same pattern to smaller work: describe one bounded annoyance, let the agent trace the implementation, and accept the change only after reviewing the diff and result.

Sahil also uses Devin for small maintenance tasks that are easy to describe but often sit below a team's normal prioritization threshold.

Gumroad posts an AI-generated weekly recap in Slack. Sahil wanted to remove empty project categories and stop describing backend-only changes as user-facing shipments.

• Problem 1: Empty categories added noise to the recap.
• Problem 2: Some backend changes were labeled as shipped product work before the related user experience was live.

The request combined a deterministic filtering change with an update to the model instruction.

Sahil assigned the cleanup to Devin in plain language.

"Hey, at Devin, like, could you like, you know, only show the projects that actually have shipments and like hide the other ones... and also, like some of these aren't really shipments... make sure you know the pro update, the AI prompt that we're using for this."

Devin found both the script that assembled the recap and the prompt that generated its text.

• Code change: Filter the project list before rendering the recap.
• Prompt change: Focus the summary on changes that users could actually experience.

The proposed filter kept projects with more than one item. That implementation needs a reviewer to confirm whether a project with exactly one valid shipment should appear, and tests should cover empty, single-item, and mixed categories.

This is a good agent task because the desired output is visible and the diff is small. It is still a pull request, so the owner of the recap should review the logic and generated-language change before merging.

How Gumroad encouraged adoption

Sahil paired demonstrations with a temporary incentive so engineers had a reason to learn the tool and share their workflows.

One internal competition used a $33,000 prize pool.

• The challenge: Split the pool among engineers who opened and merged more Devin pull requests than Sahil during May.
• The reported result: Three engineers beat Sahil. He placed fourth with 27 Devin pull requests.

A pull-request count measures tool use, not value or quality. An incentive like this needs the usual review standards so it rewards learning without encouraging fragmented or unnecessary changes.

What changed in the product workflow

Sahil's system moves more product clarification before implementation. He spends longer on the interaction in v0 because the cost of revising the prototype is lower than revising a finished feature.

The engineering work shifts toward the environment around the agent: architecture, component standards, repository setup, tests, CI, previews, and the technical debt that makes changes hard to validate.

The practical unit is not a 40x promise. It is a well-scoped task with a clear interaction, a repository the agent can navigate, an inspectable pull request, and a person accountable for what ships.

The 40x comparison reflects Sahil's experience moving a specific feature through this stack, not a universal productivity multiplier. The useful detail is where the time disappeared: he could make the interaction concrete before engineering, hand a narrow requirement to an agent that knew the repository, and review a pull request instead of implementing every layer himself.

That speed depends on the codebase around Devin. Stable components, readable architecture, tests, previews, and fast CI give the agent a paved road. When those systems are weak, the agent spends more time guessing and the reviewer spends more time reconstructing what changed.

Sahil also made adoption visible inside Gumroad. Small wins and real pull requests gave the team examples to inspect, while leaders used the tools themselves instead of issuing a broad AI mandate. The behavior spread through demonstrated work rather than a slide deck about future efficiency.