Why MCP is Often Overkill
Matt argued that MCP is overused and that developers should favor Skills over MCP for most use cases, estimating that simple Skills with API calls via curl could handle roughly 80% of scenarios. He pointed out that MCP often provides a false sense of security; since most are built in Python or Node.js, they introduce significant supply chain risks and require constant expert handling and maintenance to avoid becoming bloated, vulnerable entry points.
Death of the Line-by-Line Review
The conversation then shifted to a confession many at the table shared: the sheer volume of code generated by modern AI agents has effectively ended the traditional line-by-line inspection. Senior engineers admitted that reviewing every single line is no longer viable. Instead, they shared how they are shifting their focus to reviewing the overall system architecture, checking file placements, and looking for high-level code smells. Theodo shared their internal strategy: when the AI detects blueprint components in a PR, it flags them accordingly, signaling to human engineers that they can safely skip reviewing the boilerplate.
The Mechanics of a Startup Pivot
The discussion emphasized the absolute necessity of removing emotion from a pivot process. Sacha and Hugo described their highly methodical approach, which involves setting strict deadlines with predefined metrics and outlining distinct pivot scenarios. Sacha used a framework inspired by Geoffrey Moore and gathered hard data by surveying dozens of CTOs to identify the strongest market signal. Some also noted that pivoting can be harder for experienced founders: past successes can create the belief that an original idea can be forced to work, often delaying the difficult decision to shut down a failing project.
Hiring AI-Native Talent
The conversation turned to the shift toward AI-native talent, highlighted by recruitment tests designed to be unsolvable without the heavy use of AI. Some argued that very young developers natively think in a new way, unburdened by legacy habits and focused on managing agents to solve harder problems. However, a skeptical counter-view emerged: because these juniors lack foundational experience, they are prone to making poor architectural choices without a good understanding of system complexity, still necessitating heavy senior oversight to prevent significant technical mistakes.