See pricing
What Happens When Everyone Can Build Software
Y Combinator Startup PodcastAI

What Happens When Everyone Can Build Software

Supabase is seeing roughly 70% of new activity come from agents and more than a million new databases created each week. Paul Copplestone explains why that changes product design, why personal software may explode, and why the real bottleneck is shifting from writing code to knowing what to build.

October 30, 2026 · 49 min listen · 12 min read · Paul Copplestone
0:00
–:––

Context

Paul Copplestone is co-founder and CEO of Supabase, the open source Postgres platform that has become a default backend for AI coding tools. In this conversation he explains what Supabase is seeing as software creation shifts from developers writing code by hand to agents building on their behalf: 13 million users, more than 1 million new databases a week, and roughly 70% of new activity coming from agents. This matters to PMs because the user is changing. The product surface, onboarding, debugging experience, and even the definition of the customer are moving from developer-only workflows to builder and agent workflows.

The Big Idea

As software building gets cheap, the bottleneck moves from writing code to deciding what should exist and making products easy for agents to use.

Supabase's growth suggests this shift is already here. The winning products are not just simpler UIs for humans. They give agents code-native ways to act, keep user data in durable systems, and help both humans and agents recover quickly when something breaks.

Key Insights

Builders expanded the market

  • Supabase grew from about 3 million signups to 13 million in 12 months. Databases under management went from about 8 million to nearly 50 million, and the company is now creating more than 1 million databases per week.
  • The interesting signal was not just top-of-funnel growth. Paul said activation and conversion also kept improving while signups accelerated. That suggests the new users are not low-quality curiosity traffic. They are successfully building.
  • The product lesson is that AI is not only making existing developers faster. It is creating a new builder segment: people with domain knowledge and pent-up ideas who previously could not justify, afford, or recruit engineering help.

Agents changed product surfaces

Supabase describes its own evolution in three chapters: dashboard company, then API company, and now code-first company. The reason is simple. Agents do not want to click around a dashboard. They want CLIs, infrastructure as code, sandboxes, and reliable programmatic paths. Paul said Supabase now expects anything that exists in the dashboard to work in lockstep in code. For PMs, that is a strong signal that the primary interface of a product may no longer be the UI your human user sees most often.

Defaults shape agent distribution

  • Supabase benefited from being selected as a default database inside AI coding tools.
  • Paul framed agent adoption as more than a brand win. A product first has to be picked by the model or tool, then it has to avoid losing the agent when something goes wrong.
  • For PMs, this means distribution has moved deeper into product design. Defaults, starter templates, and tool integrations are now acquisition channels, not just partnerships.

Open source aids recovery

Paul thinks open source was likely critical to Supabase's rise in agent workflows. When an agent hits a wall, open source gives it a way to inspect the code and reason about what went wrong instead of stopping at a black box. The same property matters to enterprises, which increasingly want inspectable systems for security reasons. Supabase also benefited from supporting existing Postgres tools and communities, which spread the product beyond a single branded surface.

Personal software became viable

  • Paul described building his own personal software stack, including email triage, finances, health tracking, CRM, and file ingestion.
  • He argued that his personal finance module already meets or beats the feature set he needs from products like Mint or Monarch because it can use his own context, such as calendar events and relationship data, to interpret transactions correctly.
  • The broader point is that software can now be built for an audience of one. A taxi driver from Brazil built a local taxi app from his phone. Those products would not have existed a few years ago, not because the problems were fake, but because implementation used to be too expensive.

Own the data layer

The durable value in Paul's personal stack is not the chat interface. It is the database that stores the facts of his life. He explicitly wants to keep routines, CRM records, files, and personal history out of a single assistant's memory and inside a system of record that many agents can use. For PMs, this is a useful way to think about defensibility. Interfaces may be replaced quickly. Structured, portable, well-permissioned data becomes harder to replace.

Knowing what to build

Paul's strongest human advantage argument was not about prompting skill. It was about judgment. He believes the hard part is increasingly knowing what to build, shaping the information architecture, and bringing domain knowledge to the problem. That is why domain experts are so important in this wave. A product-adjacent founder can now build sophisticated finance software for personal use because he already understands the workflows, the edge cases, and what good looks like. AI lowers the cost of execution. It does not remove the need for taste.

Mental Models & Frameworks

Dashboard to code-first ladder

  • Dashboard phase: optimize for humans operating the product directly.
  • API phase: expose the core system so software can create, configure, and manage many instances.
  • Code-first phase: design for agents and coding tools as primary users, with CLIs, sandboxes, and infrastructure as code.

Use this ladder when a product's historical interface no longer matches the behavior of its fastest-growing users. Supabase used it to explain why a strong dashboard was once an advantage and is now no longer enough.

Two-stage agent adoption

  • Stage 1: get chosen. Default placement inside coding tools and model ecosystems creates a huge distribution advantage.
  • Stage 2: keep the agent unblocked. Once an agent hits an error, the product has to supply enough guidance that the agent can recover instead of switching away.

This model is useful for any PM building agent-facing software. It forces acquisition and retention to be considered inside the same technical loop.

Use-case eval loop

  • Pick a real build task, not a vague benchmark.
  • Run different models through that task.
  • Record where each model fails, especially on debugging and recovery.
  • Improve docs, CLIs, and error messages until the task becomes closer to one-shot.

Paul said much of Supabase's engineering effort now goes into testing specific use cases rather than just shipping features. That is a good pattern when product quality changes every time models improve.

Prototype to petabytes

Supabase is trying to serve both the lightweight prototype and the serious company. The idea behind its proposed Spark tier and the Turso acquisition is to let a builder start with a cheaper, lighter architecture and still keep a path to large-scale Postgres workloads later. Use this model when the same product must serve hobby builders, prosumers, startups, and eventually enterprise teams without forcing an early migration.

Decision Principles

Principle: Code every action

  • When: a product still requires important work to happen through a dashboard click path.
  • Why: agents work through code, CLIs, and APIs. Even human builders increasingly delegate execution to agents, so every missing programmatic path becomes a dead end.

Principle: Win on day one

  • When: switching costs are high, as they are for databases, payments, or identity systems.
  • Why: Paul said getting a customer to migrate databases later is extremely hard. The better strategy is to be present when the project starts and then scale with the customer as usage grows.

Principle: Prefer inspectable systems

  • When: deciding between a closed product that feels convenient and an open product that is easier to inspect.
  • Why: agents recover better when they can inspect source or rely on open ecosystem tools, and enterprise buyers increasingly care about security visibility.

Principle: Keep slack for inflections

  • When: the market changes faster than normal roadmap cycles can handle.
  • Why: Supabase leaves capacity to react to model shifts and partner feedback. Many experiments fail, but missing the inflection is more costly than carrying some unused capacity.

Trade-offs & Nuance

Chat needs durable structure

Paul initially wanted everything to stay in markdown and chat, with no real UI and no database. His own usage changed that view. He found that chat is a great interface for asking for changes, but durable products still need structured data and purpose-built screens once complexity grows. For PMs, the lesson is not to confuse a great conversational front end with a complete product architecture.

Prosumer versus enterprise pull

Supabase is being pulled in two directions at once. One direction is personal builders launching tiny projects and databases by the million. The other direction is serious workloads that need multi-terabyte or petabyte scale. Paul's answer is not one compromise product. It is different tiers and architectures under the same brand. The trade-off is operating complexity in exchange for capturing both ends of the market.

Default placement is fragile

Being a default inside an AI coding tool can create explosive growth, but it is not durable on its own. The same agent that chooses a default can switch away when setup or debugging gets painful. That is why Supabase invested in code-first flows, CLI improvements, and error messages that tell the agent how to fix the problem, not just that a problem exists.

Common Mistakes

Mistake: Designing for human clicks

A product that only works well through a human dashboard is increasingly misaligned with how software gets built. The better approach is to map every critical workflow to an API, CLI, or infrastructure-as-code path and treat those paths as first-class product surfaces.

Mistake: Shipping generic errors

A generic server error used to be frustrating. In an agent workflow, it is a conversion leak. If an error message only reports failure and not a likely cause or next step, the agent stalls and may abandon the product. The better approach is to write error messages as recovery instructions.

Mistake: Assuming builders are engineers

Paul's fastest-growing segment includes people who know a domain deeply but do not think like traditional software engineers. Product teams that design docs, terminology, and onboarding only for professional developers will miss that growth. The better approach is to treat domain experts as a primary persona, not a fringe case.

Practical Application

Audit click-only workflows

  • List the top five jobs users or agents try to do in your product.
  • Mark which jobs can be completed through an API, CLI, or configuration file without touching the UI.
  • Treat every click-only step in a critical flow as agent debt, especially if the flow is part of setup or debugging.

Rewrite top failure messages

  • Pull the most common setup and runtime failures from logs or support tickets.
  • Rewrite each message in plain language with three parts: what failed, the likely cause, and the next step to try.
  • Test each revised message with a coding agent. The bar is not prettier copy. The bar is whether the agent can recover without a human opening a search tab.

Research non-engineer builder jobs

Interview users who have deep domain expertise but limited engineering background. Ask what they would build if implementation were cheap, what they currently track in spreadsheets or documents, and where current software forces them into bad workarounds. This is a practical way to find the next wave of products that agents make possible.

Separate data from interface

Store the core facts of a workflow in durable, structured systems instead of burying them inside one assistant's memory or a disposable front end. This makes it easier for multiple agents, tools, and future interfaces to work from the same source of truth.

Hold capacity for shifts

Reserve a small part of the roadmap for sudden changes in models, tools, or partner behavior. Supabase's own story shows that fast platform shifts reward teams that can re-architect quickly, not just teams that plan well a year in advance.

Questions to Consider

  • If an agent tried to complete your product's main setup flow today, where would it stall first: missing API coverage, confusing permissions, or a useless error message?
  • Which part of your product creates the most durable value: the interface, or the underlying data that multiple future agents and apps could reuse?
  • What would your roadmap look like if you treated non-engineer domain experts as a primary builder persona instead of assuming every serious user is a developer?
  • Where is your team still optimizing for ease of implementation when the scarcer skill may now be choosing the right problem and information architecture?

Bottom Line

AI is making software creation abundant, but it is not making product judgment less important. The advantage is moving toward products that agents can use directly, data layers that outlast any single interface, and teams that can adapt faster than the next tooling shift.

Case Studies Mentioned

Brazilian taxi app

A taxi driver from Brazil showed Paul a local taxi application he had built from his phone after the Supabase conference. The important part of the story was not technical novelty. It was that a working person with direct market knowledge could now ship a niche mobility product without first becoming a software engineer or recruiting one. That is the builder expansion in concrete form.

Paul's personal control tower

Paul built a personal system that handles email triage, finance tracking, health data, files, and CRM-like relationship context. He said the finance module is at least at feature parity for his needs with dedicated consumer tools because it uses his own context, such as calendar events and personal history. The lesson for PMs is that an audience-of-one product can now outperform a mass-market product when personalization matters more than standardization.

Tools & Products

Tool / ProductWhat it doesWhy it was mentioned
SupabaseOpen source Postgres platform with databases, APIs, auth, and storageThe central example of a backend being redesigned around agent and builder workflows.
PostgreSQLRelational database systemThe ecosystem Supabase builds on and helps maintain, which also gives agents and enterprises an open, inspectable foundation.
TursoLightweight database architecture compatible with SQLite and Postgres workflowsMentioned as part of Supabase's plan to serve very small prototype workloads at much larger scale.
SQLiteLightweight embedded databaseRaised as a strong fit for many early or personal workloads that do not need a heavyweight database setup.
Cloud Code and CodexAI coding toolsUsed as examples of coding environments where Supabase became a default backend choice.

People to Follow

Paul Copplestone

Co-founder and CEO of Supabase. He is worth following for practical thinking on open source infrastructure, AI coding tools, agent-first product design, and how a product adapts when its core user expands from developers to builders.

AI PM course

Everyone hears the same episodes.
Few can do what they describe.

Start for free