From API Recommendations to AI Coding Assistants: A Step-by-Step Guide to Reducing Developer Friction

Introduction

Developer productivity isn’t about building the biggest model or the flashiest feature. It’s about removing tiny, repetitive obstacles that break a programmer’s flow. Neel Sundaresan, GM of Automation and AI at IBM Software and a founding engineer of GitHub Copilot, has spent over two decades hunting those friction points. His work culminated in IBM Bob, an AI coding assistant now used by 80,000 IBM developers. This guide distills his approach into actionable steps—whether you’re building your own tool or just trying to make your team more efficient.

What You Need

• Familiarity with software development workflows and common pain points (e.g., API calls, autocomplete, code reviews)
• Basic understanding of AI/ML concepts (recommender systems, transformers) but no deep expertise required
• A development environment where you can test small changes (e.g., a code editor plugin or simple CLI tool)
• Access to developer usage data (anonymous telemetry or user interviews preferred)
• Patience to iterate: the first solution won’t be transformative

Step-by-Step Guide

Step 1: Identify the Most Common Friction Point in Your Workflow

Start by analyzing what developers do most often that interrupts their thought process. Sundaresan discovered early that 30% of all developer code is API calls—and each call requires choosing from a long list of methods. That moment of scrolling and searching is a tiny, repeated interruption. Look at your own team’s commit history, tracked warnings, or even survey them: what task consumes seconds but happens dozens of times a day? That’s your first target.

Step 2: Build a Minimal Solution That Targets That Single Moment

Your first tool doesn’t need to be an AI. Sundaresan’s initial system was a recommender for API calls, treating the problem as a search ranking task. It surfaced the most likely function based on context—no transformers, no deep learning. The goal was to reduce friction, not generate code. Create a simple autocomplete or shortcut that eliminates the interruption. Test it in isolation with a small group. The metric is not accuracy; it’s whether developers feel less distracted.

Step 3: Prioritize User Experience Over Model Sophistication

“Coding is an analytical task,” Sundaresan says. “If the system makes a wrong recommendation or interferes with my thought process, that matters.” A more powerful model can produce a worse product if the interface is jarring. Ensure your tool does not disrupt flow—suggestions should appear quickly, be easily dismissible, and never force a decision. The user experience is orthogonal to the AI underneath. Test for cognitive load, not just precision.

Step 4: Let Model Advancement Inform Your Next Iteration

As AI evolved from Long Short-Term Memory (LSTM) to encoder-decoder architectures to transformers, each step made generation more feasible. Sundaresan’s team had already mapped the problem; they just needed the right tools. Keep an eye on research without jumping on every trend. When GPT and transformers matured, apply them to your existing friction point—now you can move from recommending to generating small code snippets. IBM Bob likely builds on that progression.

Step 5: Test Internally at Scale Before a Wider Launch

IBM Bob runs with 80,000 internal users before any external rollout. This gives real-world feedback on interruptions, false suggestions, and workflow integration. Set up a gradual rollout within your own organization. Collect quantitative data (time saved, suggestion acceptance rates) and qualitative feedback (interviews, open-ended surveys). Iterate based on what breaks developer flow—not on model improvements alone.

Step 6: Avoid Over-Engineering—It’s Like Taking a Ferrari to Buy Milk

Sundaresan uses the Ferrari analogy to warn against building a sophisticated system for a simple task. If your solution is too complex, it introduces new friction. Keep the scope narrow. For IBM Bob, the core value is reducing small moments of friction—not replacing the developer. Resist feature creep. Each additional capability must pass the question: “Does this make the developer’s job easier or just more complicated?”

Step 7: Measure Success by Developer Satisfaction, Not Output Volume

Lines of code per day is a poor metric. Sundaresan looks for whether developers feel less interrupted and whether they trust the tool. Use a simple post-session survey: “How many times did the tool disrupt your thinking?” or “Did you feel you were in the zone more often?” Satisfaction correlates with real productivity, but only if the tool respects the user’s cognitive state. Track net promoter score among early adopters.

Tips for Success

• Start with the smallest possible friction. A one-second interruption repeated 100 times a day is a better target than a multi-step process.
• Focus on flow. Developers hate being pulled out of their mental context. Any suggestion must be non-blocking.
• Don’t chase model benchmarks. A 95% accurate model that annoys users is worse than a 90% model that feels seamless.
• Use your own dogfood. If you build a developer tool, use it yourself; you’ll feel the pain points firsthand.
• Keep the “Ferrari” in the garage. Simple solutions beat clever ones every time if they reduce friction.
• Iterate with user stories. Sundaresan’s team published research at every stage—document what worked and what didn’t.

Following these steps won’t guarantee you build the next IBM Bob, but it will steer you toward tools that developers actually feel make them more productive. The key takeaway: reduce friction, not complexity.