AI Software Factory: How to Eliminate Bottlenecks for Speed

Key Insights

• Speed isn't about working harder—it's about removing bottlenecks in your build process. Just like F1 pit stops dropped from 67 seconds to 1.8 seconds, product teams can dramatically accelerate by identifying and fixing the system constraints, not pushing engineers faster.
• AI agents shift, not eliminate, bottlenecks. The winning strategy is finding each bottleneck faster, removing it, then moving to the next one in an endless cycle of iteration.
• Automate small loops to focus on big strategy. When AI handles routine improvements and UX fixes automatically, product managers can focus on ambitious, high-impact initiatives instead of reactive work.
• Organization legibility is key. For AI agents to truly scale, your company's data, roadmaps, and decisions must be centralized and readable—not siloed across Slack, Notion, Linear, and email.
• Product roles will evolve into three tracks: technical PMs building the factory, tastemakers holding the steering wheel, and GMs owning business outcomes across functions.

The Bottleneck Mentality: Learn from Racing

At Ramp, speed is central to culture. But the critical insight comes from professional racing: the driver is only 15% of race performance. The real impact is the system—the interaction between driver, car, and team.

F1 teams prove this relentlessly. In the 1950s, tire changes took 67 seconds. Today, 1.8 seconds. That 37-fold improvement didn't come from asking mechanics to work 37 times harder. It came from finding bottlenecks and removing them: specialized roles, better tools, relentless practice. F1 replaces 90% of its 16,000 parts annually. Only 10% carry over.

For software teams, the question becomes: What if 90% of your code changed every year? That's the competitive bar you're racing against.

Identify: Cut Through the Noise with AI

The first step in product development is identifying customer pain. But at most companies, that pain data lives everywhere—Gong transcripts, Zendesk tickets, LogRocket sessions, angry emails to executives. The bottleneck isn't lack of data; it's signal buried in noise.

Ramp initially tried a simple solution: a "hate channel" posting all negative customer feedback daily. It got out of hand quickly—too much raw data, no structure.

The fix: a customer insight agent that pulls from all data sources, uses vector search to cluster similar issues, understands the product and teams, and surfaces insights to the entire organization. This agent became accessible through multiple interfaces:

• Slack queries for quick answers
• HTML dashboards for deeper exploration
• A podcast of customer feedback ("the hate podcast")

The principle: get people access to data as fast as possible. This doesn't mean fewer customer conversations—it means identifying which customers to talk to because the data is traceable and searchable.

Define: Connect AI to Your Systems

Once you've identified what to focus on, the next bottleneck is translating insight into a fully scoped product definition.

Generic AI assistants ask, "What do you want to build?" and wait for you to stare blankly at the screen. That's not actionable. The breakthrough is connecting AI to your actual systems.

Ramp built an AI agent called Glass that understands both qualitative research and quantitative data by connecting to Snowflake, user research repos, and customer call transcripts. This specificity ensures the agent nails the actual job customers are asking for—not a generic solution.

Build & Review: Distribute Coding Across the Team

Building used to be the bottleneck. Now it's not—but new bottlenecks appear immediately.

Coding bottleneck → Inspect agent

Ramp built Inspect, an internal coding agent that works in Slack, understands the codebase deeply, runs in under 5 seconds, and returns deployed previews. The impact:

• 1 million Inspect sessions across the company
• 75% of PRs built by Inspect
• 1,000+ PRs in the last month submitted by non-engineers

The key: strong architecture and codebase make AI coding agents vastly more effective. This expanded who in the company could code.

Code review bottleneck → ReviewBuddy agent

Shipping more code created the next bottleneck: engineers drowning in code reviews. ReviewBuddy understands the codebase, quality standards, security concerns, and the prompts that led to the code being written. It finds the right human reviewer and provides visible context.

Result: 93% of PRs automatically handled by ReviewBuddy, freeing top engineers to focus on the critical 7% that require deep judgment.

Test: Browser-Based QA at Scale

Testing is traditionally a bottleneck—spinning up QA environments, tweaking variables, waiting for feedback.

Testo, a browser-based QA agent, simulates product usage across 100+ combinations based on production data. It can follow instructions ("Pay an invoice, but amortize it"), click through the product like a user, and return both blocking bugs and qualitative design feedback.

In 30 days, Testo caught 425 bugs—bugs the team fixed before customers encountered them—plus design feedback that fed back into the product loop.

Coordinate: Organize Human Attention with Gadget

With code shipping at velocity, the bottleneck shifts to human coordination and attention.

Product managers become inundated with notifications and status questions from sales, support, and the team. Too much process slows builders; too little creates chaos.

Gadget, an AI agent, understands the intent of every question and connects it to the formal record: Notion roadmaps, specs, customer calls, Slack threads, Linear tickets. It answers questions with evidence and proactively updates stakeholders.

Examples:

• "What's the status of this launch? Are we on track?" → Gadget pulls the full picture, identifies owners, pings people late on deliverables
• "What's this feature? How do I sell it? Is it available in Brazil?" → Gadget answers from product specs; if unsure, it routes to the PM
• Launch coordination → Gadget writes help articles, blog posts, customer emails

Result: 85% of questions to PMs are now fully answered by AI, with the remaining 15% answered and fed back into the system.

Improve: Automate the Small Loops

Most product teams get stuck in reactive work: small fixes, visible wins, incremental improvements. This is the opposite of ambitious.

Ramp flipped this: AI now fully owns the small improvement loops. An agent identifies a UX issue, routes it to the right team, dedupes similar issues, ranks by impact, writes the plan, codes it, tests it, and launches it—with humans only checking in via Slack ("Ready to go?").

Thousands of small loops run autonomously so PMs can focus on big bets.

Result: 60% of identified UX issues are fixed within 24 hours.

Measuring Speed: Hire Drivers Who Know Velocity

How do you measure product velocity? It's harder than lap time at a racetrack.

The insight comes from Niki Lauda, who took a test drive in a Ferrari and told Enzo, "This car is a piece of shit. It drives poorly, it handles poorly, it brakes poorly." He fixed it.

The lesson: hire people who recognize speed and quality, give them authority to challenge you, and actually listen. You'll know if you're moving fast enough when your best people tell you.

Constraints Force Focus

Limited engineering resources? Limited token budgets? That's an advantage, not a handicap.

In 2006, Audi had a slow Le Mans car. Instead of trying to outrace competitors, they asked: "How can we win if we can't go faster?" Answer: fuel efficiency. Fewer pit stops, more track time. Audi won Le Mans three years in a row.

Constraints force you to choose one dimension where you're world-class. Find the bottleneck that will 10x your company and start there. Embrace constraints; reject bottlenecks.

The Future of Product Management

As AI loops run autonomously, what happens to product managers?

Three evolving tracks:

1. Technical PM: Builds the factory itself—identifying bottlenecks, removing drag. Ships tools that help the team build, not customer-facing products.
2. Tastemaker: Holds the steering wheel. Does what AI cannot. Sets the bar for great taste and product direction.
3. GM: Expands from product to marketing, sales, growth, operations. Owns business outcomes across functions.

Conclusion

Speed isn't about pushing harder. It's about building a software factory that identifies bottlenecks, removes them, and moves to the next one—faster than competitors. Connect AI to your systems, automate small loops, make your organization legible to agents, and obsess less about the product and more about the factory that builds it.

As Enzo Ferrari said: "The best Ferrari ever built is the next one." The best product you'll ever build is the next one you launch—and that begins in the software factory you build today.

---

Original source: The limiting factor—how to design an AI software factory for speed | Geoff Charles (Ramp CPO)

powered by osmu.app