Has AI Finally Made Computers Useful for Everyone?

For decades computers promised to make life easier for everyone. For decades that promise was only kept for the people who already knew how to use them. AI might be the first thing that actually changes that.

In our third episode of Choose Your Stack, recorded at the MCP Dev Summit in New York City, Ryo Koyama sits down with Chris DiBona, Vice President from the Office of the CTO at Microsoft, to explore what the open-source era taught us about developer ecosystems — and why those lessons matter more than ever in the age of AI agents. Chris has spent his career at the center of open source, from Google to Android to now Microsoft, and has a uniquely long view on why some technologies get adopted and others do not.

“The thing I take away from all this is that as a computer industry, we can finally actually meet the promise that we’ve been giving our users for decades now. It’s like we’ve given them so much great hardware, so much capacity, so many tools, and they can’t use them. Now we’re finally at the point where it’s like somebody can say, you know what, I bet you a computer should be able to do this thing. And they explain it to their LLM. And suddenly, it opens up all this capacity.”

— Chris DiBona, Vice President, Office of the CTO at Microsoft

Together, they explore why MCP succeeded where other protocols failed, why the line between programmer and non-programmer is disappearing, why developer relations is evolving into agent relations, and why the real challenge for the industry is building tools that are personalizable and secure for billions of people who do not all look or think the same.

“I think the best thing about AI in a lot of ways is that it’s going to make everything extraordinarily personal, because it makes it very simple. And it’s like, thank goodness the year of the dashboard is over. That’s the way I look at it. Everybody always focuses on 0 to 1, but maybe in the year of AI, we’re thinking about billion to one. I think that’s the push.”

— Ryo Koyama, President of Parinita AI

The age of the autonomous agent is fulfilling computing’s promise for everyone, shifting the focus from enabling a few developers to empowering billions of personalized users. This transition means agents are becoming the primary consumers of tooling, requiring an evolution from traditional developer relations to a focus on agent relations. Achieving this necessary personalization and security at massive scale demands a new paradigm: the Agent Native Cloud.

This infrastructure must be purpose-built for a distributed, agent-first environment, ensuring every agent has the secure tools needed to maximize user capacity. This secure foundation for a billion personalized agents is the mission of Parinita AI, championed by founder Parind Parekh.

Key takeaways from the episode

• MCP succeeded because it made it easy for developers to try it out immediately. Chris argues that great developer communication is the difference between a protocol that gets adopted and one that does not, and MCP nailed that by giving developers a simple starting point they could experiment with and build on rather than a complex standard they had to implement from scratch before seeing any results.

• CLI and MCP are complementary, not competing. Chris sees CLI as another tool in the agent’s toolbox rather than a replacement for MCP, and points to tools like OpenClaw — a harness built on top of Chrome because no proper agent interface existed — as a cautionary example of what happens when agentic interfaces are not built well and built fast. The alternative to good interfaces is not no interfaces; it is insecure ones.

• The line between programmer and non-programmer is disappearing — and has been for decades. Chris argues that anyone who has ever built a complex Excel spreadsheet or a Visual Basic macro has always been programming; the industry just refused to call it that. AI removes that gatekeeping entirely, and the result is that computers can finally deliver on the capacity they have always had but most people could never access.

• Developer relations is evolving into agent relations. As agents become the primary consumers of documentation, APIs, and tooling, Chris argues that the next logical evolution of developer relations is making sure your platform is legible to the agents that will be integrating it. If your documentation is not in the training data, your platform does not exist to the agent.

• The real challenge is personalization at the billion-user scale. Chris closes with the observation that Microsoft has a billion active Windows users and Android has two and a half billion. Those users do not all speak the same language, use the same devices, or have the same needs. Building tools that are simultaneously personalizable and secure for that diversity is the defining challenge of the AI era, and the industry is only beginning to grapple with what that actually requires.

Chapters

• 0:00 — Intro
• 0:21 — Microsoft’s open-source contributions
• 2:07 — The excitement behind MCP
• 5:22 — CLI vs. MCP
• 8:04 — Who counts as a programmer?
• 11:23 — Chris’s Hong Kong cabinet AI project
• 14:04 — Agents as toil reducers
• 15:19 — The future of developer relations
• 17:04 — Open source and LLM training
• 19:40 — Hot take: the industry doesn’t know real programmers
• 21:08 — Personalization at a billion-user scale