Amplify Partners

I got to sit down with Sunil Dhaliwal (@dhaliwas) for E30 of @WeThe_Builders. He has been in investing for 27 years, he was a General Partner at @BatteryVentures for 14 years before starting @AmplifyPartners ($2.4B AUM fund). He founded Amplify 13 years ago with the thesis of backing technical founders. Interestingly, he shared the story of how “business guy” was more investable back in the even back 2010/11 era. I thought that was more common in the 1980s and 90s venture investing. A ton of great stories of that era and the origins of venture capital in Power Law. Amplify is an investor in companies like @datadoghq , @fastly , @RecursionPharma , @chaidiscovery , @LangChain , @Anchorage , @CovariantAI , @runwayml , @temporalio , @NeuralRendering to name a few. These are either publicly traded or have privately achieved unicorn valuations. They have launched a dedicated bio fund after their latest $900m fund announcement building on top of the success of their bio portfolio, Sunil explains on the pod why they are uniquely positioned to operate in the space. We had a great conversation covering how to train junior investors, the madness of the dot-com era and how it rhymes with some of what we see today in technology bubbles, his investing philosophy, fundraising advice and more. Timestamps: 00:00 - Introduction 03:20 - What was going on in the Dot-Com bubble? 08:15 - Collapse of the Telecom value chain 09:37 - Why the AI boom is supply-constrained, not demand-constrained 12:37 - OpenAI canceling Sora 17:15 - Why brand and trust are self-reinforcing in enterprise software 19:17 - Shipping frequently as a mechanism to preserve vendor trust 22:58 - Debunking the SaaS apocalypse 30:23 - The Amplify playbook 38:05 - The shift from scale-up servers to agent-first platforms 41:42 - Progression timeline of autonomous agents 49:23 - Investing in Runway and the AI-meets-creativity thesis 52:08 - Why you're an idiot if your early-stage firm has an investment committee 55:00 - The failure of consensus markets and competing for growth deals on price 1:07:00 - Early-stage fundraising is a search problem, not a sales process 1:10:24 - Capping limited partner allocation at 10% 1:14:07 - The necessity of letting people learn from their own failures 1:14:58 - Launching a dedicated bio fund to capture compounding variables 1:17:57 - The art of training junior investors 1:26:05 - Why traditional biotech is a terrible place for returns 1:34:52 - How networks and relationship goodwill compound over decades 1:49:54 - Designing a platform team for recruiting and go-to-market execution 1:52:57 - Closing

x.com/i/article/2057…

Many people don’t know that before there was Modal, there was Polyester, a vision to solve “any data problem” through better infrastructure. Specifically, @bernhardsson and @akshat_b believed that most infrastructure delivered scalability and reliability, but sacrificed developer productivity. They believed data and AI teams deserved amazing tools and workflows that could turbocharge them. The entry point to deliver this vision was clear: figure out how to run code. 6 years later, that vision hasn’t really changed. Yes, the needs of AI engineers are evolving every single day. Yes, they need even more scalable, more reliable, more performant systems. But Modal’s commitment remains the same: give data and AI folks tools that feel good and make them deliver deeper impact faster. Proud that I convinced them to change the name; proud that they raised a sh#t ton of cash; proud that every time Erik shares a revenue plan, I balk, and then he beats it by over 100%, and grateful to learn from Erik, Akshat, and the Modal team throughout this journey.

Today we're announcing our Series C funding: $355M at a $4.65B valuation, led by some great investors @generalcatalyst and @Redpoint. We've had insane growth in the last year, but we're still very early. So proud of the team and what we have built so far!

Today we're announcing our Series C funding: $355M at a $4.65B valuation, led by some great investors @generalcatalyst and @Redpoint. We've had insane growth in the last year, but we're still very early. So proud of the team and what we have built so far!

We’re watching Git melt down in front of our eyes as agents write most of our code. This is why many people, present company especially, are excited about Jujutsu (jj). Some observations on Git’s history, why it’s creating problems for an agent-first SDLC, and how jj may help: A brief history of version control systems: In the early days of computing, version control didn't exist because it didn't need to. Programs were small enough that a single developer could hold one in their head. As teams grew, early systems like RCS tried to solve coordination with file locks that serialized work one person at a time, but locks created as many problems as they solved. Centralized systems like SVN and Perforce reframed the question entirely, reconciling simultaneous work through merging rather than preventing it. Then Git arrived in 2005, built by Linus Torvalds in a matter of days and described in its first commit as "the information manager from hell." What it added was decentralization: every developer got a full local copy of the repo, which made branching trivial and gave the whole system a resilience no centralized tool could match. Even so, Git didn't win on technical merit alone; GitHub understood that version control systems are fundamentally collaboration platforms, and that insight, more than anything else, is what made Git the standard. Why Git is suboptimal for an agent-first world Git's well documented (and memed) problems fall into two categories: data structures and UX. At scale, operations like finding merge bases require walking the entire commit history, and Git's reconciliation algorithms max out at roughly 2-3 merges to main per second. That’s fine for startups, but a hard ceiling for hyperscalers. The UX problems are more universally felt. Git exposes its internal state model to the user, forcing developers to reason about whether a file is untracked, staged, committed, or stashed, when most people just want their work recorded. Merge conflicts are incredibly frustrating because Git treats them as invalid states that must be resolved before you can continue, with no way to set one aside and come back later. The maintainers know all this, but Git is load-bearing infrastructure with 20 years of backwards-compatibility requirements, and the core team is severely constrained in what they can change. Agents make all of it exponentially worse, amplifying Git's limitations by generating code at high velocity, turning hyperscaler edge cases into mid-sized-team problems, and the same state machine complexity that frustrates developers becomes reasoning overhead for agents. Jujutsu (jj) and why people are excited about it jj started in 2019 as an experiment towards a next-generation VCS by Martin von Zweigbergk at Google. The core difference is that jj eliminates the staging area entirely; every change is always committed, just like Dropbox, and all the little Git incantations are abstracted away. Several design choices follow naturally. Undo is a primitive: jj maintains an operation log of every action you've taken, so undoing a rebase is one command, whereas Git users have all lost data hunting through the reflog. Conflicts are first-class, represented in the underlying data structures rather than treated as invalid states, which means you can have a conflicted commit, move it around, and come back later without interrupting your work. And jj builds its own data structures on top of a storage backend, which today is Git, so you could start using it at work without anyone knowing. For those nodding along, check out @erscio. ERSC was started by JJ’s core committers and they’re building the version control system and forge that will take software development into the next 20 years, for humans and agents.

x.com/i/article/2056…

We’re watching Git melt down in front of our eyes as agents write most of our code. This is why many people, present company especially, are excited about Jujutsu (jj). Some observations on Git’s history, why it’s creating problems for an agent-first SDLC, and how jj may help: A brief history of version control systems: In the early days of computing, version control didn't exist because it didn't need to. Programs were small enough that a single developer could hold one in their head. As teams grew, early systems like RCS tried to solve coordination with file locks that serialized work one person at a time, but locks created as many problems as they solved. Centralized systems like SVN and Perforce reframed the question entirely, reconciling simultaneous work through merging rather than preventing it. Then Git arrived in 2005, built by Linus Torvalds in a matter of days and described in its first commit as "the information manager from hell." What it added was decentralization: every developer got a full local copy of the repo, which made branching trivial and gave the whole system a resilience no centralized tool could match. Even so, Git didn't win on technical merit alone; GitHub understood that version control systems are fundamentally collaboration platforms, and that insight, more than anything else, is what made Git the standard. Why Git is suboptimal for an agent-first world Git's well documented (and memed) problems fall into two categories: data structures and UX. At scale, operations like finding merge bases require walking the entire commit history, and Git's reconciliation algorithms max out at roughly 2-3 merges to main per second. That’s fine for startups, but a hard ceiling for hyperscalers. The UX problems are more universally felt. Git exposes its internal state model to the user, forcing developers to reason about whether a file is untracked, staged, committed, or stashed, when most people just want their work recorded. Merge conflicts are incredibly frustrating because Git treats them as invalid states that must be resolved before you can continue, with no way to set one aside and come back later. The maintainers know all this, but Git is load-bearing infrastructure with 20 years of backwards-compatibility requirements, and the core team is severely constrained in what they can change. Agents make all of it exponentially worse, amplifying Git's limitations by generating code at high velocity, turning hyperscaler edge cases into mid-sized-team problems, and the same state machine complexity that frustrates developers becomes reasoning overhead for agents. Jujutsu (jj) and why people are excited about it jj started in 2019 as an experiment towards a next-generation VCS by Martin von Zweigbergk at Google. The core difference is that jj eliminates the staging area entirely; every change is always committed, just like Dropbox, and all the little Git incantations are abstracted away. Several design choices follow naturally. Undo is a primitive: jj maintains an operation log of every action you've taken, so undoing a rebase is one command, whereas Git users have all lost data hunting through the reflog. Conflicts are first-class, represented in the underlying data structures rather than treated as invalid states, which means you can have a conflicted commit, move it around, and come back later without interrupting your work. And jj builds its own data structures on top of a storage backend, which today is Git, so you could start using it at work without anyone knowing. For those nodding along, check out @erscio. ERSC was started by JJ’s core committers and they’re building the version control system and forge that will take software development into the next 20 years, for humans and agents.

We’re watching Git melt down in front of our eyes as agents write most of our code. This is why many people, present company especially, are excited about Jujutsu (jj). Some observations on Git’s history, why it’s creating problems for an agent-first SDLC, and how jj may help: A brief history of version control systems: In the early days of computing, version control didn't exist because it didn't need to. Programs were small enough that a single developer could hold one in their head. As teams grew, early systems like RCS tried to solve coordination with file locks that serialized work one person at a time, but locks created as many problems as they solved. Centralized systems like SVN and Perforce reframed the question entirely, reconciling simultaneous work through merging rather than preventing it. Then Git arrived in 2005, built by Linus Torvalds in a matter of days and described in its first commit as "the information manager from hell." What it added was decentralization: every developer got a full local copy of the repo, which made branching trivial and gave the whole system a resilience no centralized tool could match. Even so, Git didn't win on technical merit alone; GitHub understood that version control systems are fundamentally collaboration platforms, and that insight, more than anything else, is what made Git the standard. Why Git is suboptimal for an agent-first world Git's well documented (and memed) problems fall into two categories: data structures and UX. At scale, operations like finding merge bases require walking the entire commit history, and Git's reconciliation algorithms max out at roughly 2-3 merges to main per second. That’s fine for startups, but a hard ceiling for hyperscalers. The UX problems are more universally felt. Git exposes its internal state model to the user, forcing developers to reason about whether a file is untracked, staged, committed, or stashed, when most people just want their work recorded. Merge conflicts are incredibly frustrating because Git treats them as invalid states that must be resolved before you can continue, with no way to set one aside and come back later. The maintainers know all this, but Git is load-bearing infrastructure with 20 years of backwards-compatibility requirements, and the core team is severely constrained in what they can change. Agents make all of it exponentially worse, amplifying Git's limitations by generating code at high velocity, turning hyperscaler edge cases into mid-sized-team problems, and the same state machine complexity that frustrates developers becomes reasoning overhead for agents. Jujutsu (jj) and why people are excited about it jj started in 2019 as an experiment towards a next-generation VCS by Martin von Zweigbergk at Google. The core difference is that jj eliminates the staging area entirely; every change is always committed, just like Dropbox, and all the little Git incantations are abstracted away. Several design choices follow naturally. Undo is a primitive: jj maintains an operation log of every action you've taken, so undoing a rebase is one command, whereas Git users have all lost data hunting through the reflog. Conflicts are first-class, represented in the underlying data structures rather than treated as invalid states, which means you can have a conflicted commit, move it around, and come back later without interrupting your work. And jj builds its own data structures on top of a storage backend, which today is Git, so you could start using it at work without anyone knowing. For those nodding along, check out @erscio. ERSC was started by JJ’s core committers and they’re building the version control system and forge that will take software development into the next 20 years, for humans and agents.

It’s the most wonderful time of the year 🎶 The 2026 AI Engineering Survey is live, this year in partnership with @NotionHQ and @vercel. If you’re an engineer working on AI products, we’d love you to fill it out. We're raffling off fantastic prizes too.

“AI that isn’t just correct, but feels right.” RL has done well in environments with clear rules. The next challenge is building for the real world. Today’s afternoon keynote explored the growing importance of RL environments, and why better verification, higher-quality feedback loops, and stronger real-world data may be critical to moving AI beyond benchmarks and into practical use. The conversation also touched on a key frontier ahead: applying these ideas in more subjective domains, where quality is harder to define and context, taste, and human judgment matter more. Thank you to our outstanding speakers for sharing their insights! @sarahcat21, GP, @AmplifyPartners @nicoup, Co-founder & CEO, @fleet_ai @vincentweisser, Co-founder & CEO, @PrimeIntellect @thaiscbranco_, Founder & CEO, Taste

So excited to have Sarah support us at @Recursive_SI. She has been following our founder's Open-Endedness research for many years... even before it was cool. I have rarely seen a VC that is that deeply knowledgeable and opinionated (and correct) about future AI trends.