From first idea
to real product.
Accelerate your build with AI & coding agents - Build to Learn
Anyone can cook
Not everyone is a chef — but a great one can come from anywhere.
The shift
The cost of turning an idea
into software just collapsed.
A team. A few months.
A runway-sized bet just to find out if the thing was worth building.
A builder. An agent. A weekend.
You find out by Monday — for the price of an afternoon.
Who's talking
I build the tools that build software.
{
"name": "Vagmi Mudumbai",
"coding_since": 2002,
"role": "CTO for 14 years",
"track_record": "24 years building enterprise software",
"scaled": "$2M → $18M ARR",
"built": ["retailtech", "musictech", "logistics", "developer tools"]
}
The real unlock
Builders,
not just developers.
The person who knows the problem can finally build the solution.
- The operator who knows the workflow
- The designer who can finally ship it
- The founder who prototypes Friday, tests Monday
The honest catch
Agents make it just as easy to build
the wrong thing — fast, and insecurely.
Leverage cuts both ways. The rest of this talk is how to hold it by the handle.
Old Craft,
New Leverage
The part of building software that people keep missing — and the discipline that fixes it.
The mental model to kill
“The agent writes
the code.” → Done.
Every stalled AI build starts here.
Code is the 10% you can see.
The agent is fastest at the part that was never the bottleneck.
The bottleneck moved
When code becomes cheap,
judgment becomes the job.
Deciding what's right, and proving it's correct and safe, is the work now.
How agents build, by default
Agents print cookie-cutter software
Engineers iterate on design
Builds one layer at a time
You cannot course correct the software as it is being built.
One thin slice, end to end.
UI-first.
Architecture-led.
Validate every step
make it easy to adapt and evolve.
With the right guidance, an agent can grow software too.
We've solved this before
Extreme Programming.
Kent Beck, late ’90s. Thoughtworks made it how good teams ship — a handful of practices for shipping reliably, under pressure, in small teams.
Everything old is the unlock again.
XP Practice · 01
Small releases
XP Practice · 02
Test-Driven Development
XP Practice · 03
Continuous Integration
XP Practice · 04
Pairing → pair-prompting
XP Practice · 05
Simple design & refactoring
The synthesis
Agents are infinitely fast,
infinitely junior pairs.
XP is the operating system for working with junior pairs at speed. Discipline is what turns speed into trust.
Security
The part builders miss most — because it's invisible until it isn't.
Why builders are exposed
You ship to real users on day one.
- Real data and real payments — immediately
- You're moving fast, and you're moving alone
- On code you didn't write line-by-line
How agent-built apps break.
Secrets in the repo
API keys and tokens committed “just to make it work.”
Auth you can walk around
Checks that look right but miss a path.
Multi-tenant data leaks
One org reads another's data. The #1 SaaS killer.
Injection
SQL, shell — and prompt injection in your AI features.
Vulnerable dependencies
Whatever package made the error go away.
All of it looks plausible.
That's exactly the danger.
My day job
I run untrusted code
for a living.
I build secure sandboxes with microVM isolation. So I think about two problems, not one — securing what the agent builds, and securing the agent itself.
Guardrail 01
Isolate tenants by construction.
Every row scoped to the organization. Never trust a client-supplied identity — derive it from the session.
select … where org_id = session.orgId — the starter you'll build on today does this on every query.
Guardrail 02
Secrets out of code.
Least privilege everywhere.
Secrets live in the platform, never in a commit. Give the agent — and the app — the access they need, and nothing more.
Guardrail 03
Verify. Don't trust.
Treat agent output like a confident junior's PR: review it, test it, run automated security review before you ship.
And sandbox the agent's own execution — it runs code too.
The reframe
Security isn't a phase.
It's how you set up the work.
The template, the tests, the review loop — that's where safety lives. Slower is faster.
The Right
Substrate
Where a builder's app should actually run — from zero users to a million.
The startup infra trap
Pick two of three.
Cheap at zero
No bill before you have users.
Effortless to run
No servers to babysit at 2am.
Instant to scale
Survive the day it actually works.
Most stacks make you choose. A builder shouldn't have to.
Serverless at the edge
Scales to zero.
And to millions. Same code.
No servers to babysit. Global by default. You pay for success, not for waiting.
Everything you need, in one place.
SQL database
Relational, on the edge.
Object storage
Files & images — no egress fees.
Edge cache
Fast key–value reads, everywhere.
Stateful & realtime
Coordination, sockets, presence.
Async work
Background jobs off the request path.
Inference
Run models next to your data.
One platform. One deploy.
Why it fits this moment
Built for building with agents.
- One coherent platform an agent can reason about end-to-end
- A genuinely generous free tier — start for nothing
- You only “graduate” to heavier infra after you've won
Today's stack
Workers · D1 · Drizzle · Clerk · Polar.
Auth, a typed multi-tenant database, billing — wired and tested. The principles from this talk, made concrete.
It already has a name. →
Meet your starting capital
முதல் = the first · the capital
What you start with — and what you build on.
What you'll build today
A production-grade starter —
then make it yours.
- Auth & organizations, billing & plans — already wired and tested
- One example resource to copy into your own
- Install whole features as skills
- Deploy to Cloudflare — live in an afternoon
The loop you'll practice
product
In an afternoon.
You don't need a team
to start.
You need leverage, discipline, and a substrate that scales with you.