YC founders on what still compounds when anyone can spin up software
One idea has come up in founder interview after founder interview: if anyone can spin up decent software with Claude, Cursor, or the next agentic coding tool, then where exactly does defensibility come from now? That question sat underneath a lot of the conversations in this batch. Not in an abstract strategy-deck way, but in a very immediate way. Founders are hearing some version of “we can just build this internally” much more often. And to be fair, sometimes the customer is right. A surprising amount of software really can be recreated quickly now. What I found more interesting is that the strongest founders are not panicking about that. They’re adjusting their idea of what compounds. They’re going deeper into verticals, embedding into real workflows, choosing hard environments where wrappers can’t compete, and building internal AI systems that make the company itself learn faster. They’re also rediscovering older moats that were easy to underrate during the pure-product era: distribution, trust, service, and taste. So this post is less about whether moats still exist in the AI era, and more about where they seem to be moving in practice.
This is probably the clearest shift I kept hearing in these interviews: founders are less interested in whether AI can help them code faster, and more interested in what still matters once coding itself gets cheap. If a prospect can plausibly say “we’ll just build that internally,” then the center of gravity moves pretty fast away from product surface area and toward everything around it.
In conversation after conversation, some version of the same objection kept coming up: why buy this if we can just vibe code it ourselves? That’s not a niche complaint anymore. It’s becoming the default posture, especially from technical teams. And it changes the game. Rohan from Ashr Labs says it more directly than most: “With AI coding tools, the technical stuff matters so much less because you can move so quickly regardless. It’s really about having a solid business and a solid sales strategy.” That feels right. The build step has not disappeared, but it has compressed enough that it no longer carries the same strategic weight on its own. What’s interesting is that founders are not responding by backing away from AI. If anything, they’re using it more aggressively for internal work. Anshul from BaseFrame describes measuring tasks in “one-shot Claude” units and throwing together internal tools almost casually. That speed is real. But the lesson isn’t “therefore product doesn’t matter.” It’s that product alone matters less than a lot of founders still want to believe. The companies that feel most durable in this environment are the ones that can beat an internal build on everything around the code: understanding the workflow better, integrating faster, supporting the customer more closely, and solving the messy edge cases a hacked-together tool never really handles. In other words, when code gets cheaper, execution stops being a cliché and starts being the moat.
The throughline across these founders isn’t a single silver-bullet moat. It’s a portfolio: vertical focus that unlocks proprietary data, deep integrations that raise switching costs, operational intimacy with customers, and internal AI systems that compound speed without sacrificing reliability. When the app layer is cheap, what still compounds are relationships, data, distribution, and hard-earned execution in places others won’t go. AI isn’t making moats disappear; it’s moving them. If you’re building now, assume features are fleeting. Win where others won’t follow—own the workflow, the data, or the hard environment—and let your systems and customers make you harder to copy over time.
More founder insights
Explore other topics to learn how YC founders build their products.
Browse all topics
Join hundreds of companies using Human Behavior to turn user sessions into actionable insights. Set up in 90 seconds.
““We were talking to hackers like, ‘Please use our product.’ And everyone’s like, ‘No, I can vibe code this.’ We even spammed YC companies and heard, ‘I have an internal tool. I can ask Claude to do this.’””
““With AI coding tools, the technical stuff matters so much less because you can move so quickly regardless. It’s really about having a solid business and a solid sales strategy.””
““My cofounder and I started measuring coding tasks in shots—like ‘this is a one-shot Claude.’ A lot of things are just one shot now. We put together a CRM internally and it was like, boom, done.””
““In the future you’ll need to find what is defensible in a world where agents are doing everything—maybe data, maybe infrastructure. If you’re building a company now, you should probably think about that.””
Once that became clear, the next pattern in the interviews was pretty obvious: the best founders are getting much closer to the customer than a generic AI product can. They’re not trying to win by being broadly useful. They’re trying to become deeply embedded somewhere specific.
A lot of the strongest companies in this set are making a very deliberate tradeoff: narrower market, deeper context. Caleb from Lance frames it cleanly: you can either get very good at selling self-serve agents, or get very good at a vertical. His team chose the latter. That choice matters because vertical depth gives you access to things a horizontal tool usually never earns — the workflow, the weird exceptions, the compliance constraints, the language customers use, the data exhaust from doing the job every day. Cathleen at Opalite Health makes this point especially well. A medical interpreter is not just a model with better prompts. It has to live inside clinical workflows, fit around HIPAA constraints, and remove friction for providers already operating in a high-stakes environment. That is not a thin wrapper problem. What also stood out to me is that these founders are often willing to do the unscalable part on purpose. Mathias from Balance talks about handholding customers closely, then automating what the team learns from that process. Akash at Chasi is even more direct: they go to the customer, sit with them, implement, and earn trust the slow way. In software, that kind of service can look unsophisticated from the outside. In practice, it’s often exactly how the moat gets built. So if section one is about code becoming cheaper, this is the natural response: get so close to the workflow that replacing you means rebuilding not just software, but accumulated context, trust, and operational know-how. That is a much taller order.
““To be a billion-dollar company, you’re either really good at selling self-serve agents, or you’re really good at verticalizing one thing—fewer clients, way more depth, way bigger contracts.””
““Foundation models aren’t focusing on verticals. For a medical interpreter to work, it must be integrated into the clinical workflow. Even with HIPAA or SOC2, we usually integrate into the EHR so providers have zero friction.””
““We go wherever the customer is—North Dakota, South Dakota, Alabama—sit with them, implement, give them real love and care. That’s our moat: being customer-first.””
Another pattern I didn’t expect to be this strong: some founders are reacting to the “everything is easy to build” moment by choosing problems that are very obviously not easy. They’re leaning into regulated environments, ugly implementation constraints, and technically painful markets where speed alone does not get you very far.
This is the opposite of the usual startup advice to pick the path of least resistance. A number of founders I spoke to are effectively saying: if software is getting commoditized, then I want to operate where commoditization hits a wall. That wall can take different forms. Sometimes it’s regulation. Sometimes it’s safety. Sometimes it’s the reality of physics, logistics, or mission-critical reliability. Skyler at GRU Space talks about going where complexity and economic gravity protect the company from easy replication. Jayram at Byteport has a similar instinct from the infrastructure side: if you are building something truly critical, customers are not eager to trust the vibe-coded version. I also liked the way Leo from DAIVIN framed their strategy. Diving is the hardest environment for what they’re building, which means success there becomes more than validation. It becomes reputational proof. If it works underwater, people reasonably assume it can work somewhere easier too. That’s a powerful kind of defensibility because credibility earned in the hardest setting tends to travel. Kamran at Constellation Space pushes that logic even further into architecture. If intelligence moves on-board, into the satellite layer itself, then the moat stops looking like an app and starts looking like a system. That distinction matters. A lot of AI-era products are easy to copy at the interface layer. It’s much harder to copy the company that chose a domain where the real work sits underneath the interface, inside constraints most competitors won’t want to touch.
The last bucket of defensibility here is the one I think will matter more and more over time: not just what your team builds, but the internal systems it builds for itself. Once everyone has access to similar frontier models, a lot of advantage shifts into the private machinery around them.
Several founders described moats that do not show up cleanly in a demo. They live in internal loops: the data a company accumulates from serving a niche workflow, the agents it builds to compress research or operations, the bespoke tooling that quietly makes a team much faster than it looks from the outside. Amit from Ishiki Labs is a good example of the data version of this. Their product generates in-house scenarios and interactions that can be used to train a more socially aware layer for turn-taking AI. That’s interesting not because “data moat” is a new phrase, but because the data is being created through a very specific product surface and then folded back into capability. The internal-agent version is just as compelling. Atharva at AxionOrbital built an AI co-scientist that can move from hypothesis to papers, methods, code, benchmarks, and results. Christian at Orthogonal has an internal flywheel where support requests and recurring implementation work feed agents that can increasingly handle more of that workload. In both cases, the company is building machines that help build the company. Vincent from Panta makes the workflow angle clear too: sometimes the moat is simply that the internal tool is so tightly coupled to how your team actually operates that nothing off the shelf comes close. That feels increasingly important to me. When features are easier to copy, the more durable edge may be the private operating system behind them — the systems that help you learn faster, ship faster, and absorb customer complexity faster than the next team.
““We’re generating a lot of in-house data on these scenarios and training this layer. You can put it anywhere AI does one-on-one turn-taking and give it social awareness.””
““Our OpenClaw agent builds almost all straightforward features—we just chat with it in Slack. We want a flywheel: support agents gather requests, builder agents ship them, we review, and it goes out.””