Brian Scanlan runs engineering at Intercom. Last year, his team doubled their throughput without doubling headcount. The method: treat Claude Code like a new hire. Onboard it properly. Write skills for it. Connect it to production systems. Give it context and let it ship code.
The result? 17.6% of pull requests now auto-approved with full compliance sign-off. Developers save hours per week on grunt work. The team ships features faster without sacrificing quality. And the approach isn't magic - it's just disciplined application of tooling that already exists.
The Onboarding Analogy
Most teams use AI code tools like fancy autocomplete. They paste a problem into ChatGPT, get a snippet, modify it, move on. That works for isolated tasks but doesn't scale. Scanlan's insight was simpler: if you wouldn't expect a new developer to be productive without onboarding, why expect it from an AI?
Intercom built an onboarding process for Claude. They documented the monolith architecture - how services connect, what the data models look like, where the gotchas are. They wrote coding standards and patterns specific to their stack. They gave Claude access to internal docs, style guides, and example PRs. The same materials a human engineer would read in their first month.
Then they started writing skills - reusable workflows Claude could execute end-to-end. Not one-off prompts. Full processes: analyse a bug report, identify the root cause, write a fix, run tests, open a PR. Or: take a feature spec, scaffold the implementation, wire up the backend, update the frontend, document the change. The kind of work junior developers do all the time.
Connecting to Production Systems
The breakthrough wasn't the AI itself - it was the infrastructure around it. Intercom connected Claude to their CI/CD pipeline, their test suite, their compliance checks. When Claude opens a PR, it triggers the same validation a human PR would: linting, unit tests, integration tests, security scans. If something fails, Claude reads the error logs and fixes it. No human in the loop unless the AI can't resolve it after a few attempts.
That's the part most companies skip. They generate code but don't integrate it into their workflow. So a developer still has to manually test, fix issues, reformat, and shepherd it through review. The time savings evaporate. Intercom automated the entire flow. Claude writes code. The system validates it. If it passes, it merges. Humans review when complexity demands it, not as a default gate.
The 17.6% auto-approval rate is the stat that matters. Those are real PRs shipping to production with zero manual review beyond automated compliance checks. Not trivial changes - feature work, bug fixes, refactors. The kind of work that used to take days now ships in hours.
What Changed for Developers
The team didn't shrink. Nobody got replaced. Developers do different work now. Less boilerplate, less debugging obvious issues, less copying patterns from existing code. More time spent on architecture decisions, complex logic, and work that requires human judgement. The boring stuff got offloaded. The interesting stuff got more attention.
That shift is what doubling throughput actually looks like. It's not twice as many features of the same complexity. It's shipping the same volume of foundational work faster, which frees capacity for harder problems. The team tackles larger projects because the scaffolding work doesn't bottleneck them anymore.
There's a practical detail here: onboarding Claude is cheaper than onboarding humans. A new developer takes months to reach full productivity. You pay them the whole time. Claude's context window holds your entire onboarding doc set. It ramps in days, not quarters. And when the codebase changes, you update the docs and Claude absorbs it instantly. No re-training, no ramp-down, no turnover risk.
The Limitations They Hit
Scanlan is clear about what doesn't work yet. Claude struggles with highly ambiguous requirements. If the spec is vague, it guesses - and guesses wrong. Human developers ask clarifying questions. Claude just picks an interpretation and runs with it. So Intercom invests more upfront in clear specs. That's not a bad trade.
Complex architectural decisions still need humans. Choosing between database schemas, refactoring major systems, making trade-offs between performance and maintainability - Claude can't weigh those properly because it lacks business context and long-term vision. It's good at execution within constraints. It's not good at setting the constraints.
And there's the edge case problem. The first 80% of a task is easy for Claude. The last 20% - handling weird user input, optimising for edge cases, debugging rare race conditions - still takes human time. That gap is closing, but it's not closed.
What This Means for Other Teams
Intercom isn't special. They're a SaaS company with a monolith and microservices, like thousands of others. The approach they used - onboard the AI, write reusable skills, integrate it into CI/CD - is reproducible. You don't need Intercom's scale or their stack. You need discipline about documentation and process.
The ROI is obvious. If 17.6% of your PRs could auto-ship with compliance sign-off, what does that free up? If your developers spend 30% less time on boilerplate, what could they build instead? The math works for teams of five and teams of five hundred.
The catch: this requires investment in process. You can't hand Claude a messy codebase with no docs and expect magic. You need the same foundations you'd need for a high-performing human team - clear standards, automated testing, documented patterns. If you don't have that, adding AI just exposes the gaps faster.
But if you do have that foundation, or you're willing to build it, the returns are real. Scanlan's full talk at AI Engineer walks through the implementation details. Worth watching if you're serious about scaling output without scaling headcount.