When organizations plan to build a new tool or IDE today, AI integration is almost always a key requirement from day one. The success of GitHub #Copilot in #VSCode has naturally created a strong desire to offer similar experiences, such as code completion, terminal help, commit message generation, and AI chat, for users of custom tools.
Given this trend, one may instinctively consider building on top of VS Code and Copilot as the fastest path to meet those expectations. After all, Copilot provides a rich AI feature set and some extension points, and the idea of plugging into that system sounds promising - at least at first.
However, once you dive deeper, it becomes clear that this path comes with trade-offs. While you can augment the Copilot experience to a certain extent, you don’t get to define the AI experience - VS Code does. If your goal is to deliver a truly AI-native, domain-specific tool experience, you may find yourself quickly constrained.
This post explores what you can (and can’t) do with Copilot in VS Code, and when choosing an open AI-native platform like Eclipse Theia AI may be the better fit when AI is central to your tool’s value.
What You Can Do with GitHub Copilot in VS Code
GitHub Copilot in VS Code provides several AI features out of the box:
Code Completion
Terminal Assistance
Commit Message Suggestions
AI Chat (Copilot Chat)
These features are well-integrated into the user interface and provide great value in generic coding environments. But naturally, these features are designed for broad, mainstream use cases: they're not tailored to support your specific requirements, domain knowledge, or workflows. Whether you're building a tool for embedded systems, robotics, low-code engineering, or domain-specific modeling, this lack of alignment becomes apparent quickly.
While the VS Code extension API allows you to augment some of these features, especially in the chat, it’s important to understand the limits of what can be adapted and where you’ll hit hard boundaries.
Customization: The Reality Behind the Flexibility
Customizing Anything Besides the Chat
The AI features beyond the chat, such as code completion, terminal suggestions, and commit message generation, cannot be customized at all using the VS Code extension API. You cannot hook into these features, modify their behavior, or extend them with domain-specific capabilities. This means you cannot build on top of Copilot’s standard AI user experiences to reflect your users' workflows or data models.
At best, you can register context menu entries in standard VS Code views and trigger your own commands, possibly using the Language Model API. However:
You must implement the entire interaction flow yourself.
You can’t reuse Copilot's behaviors or prompt engineering.
You’re limited to the extension API, with no control over existing UI components.
In other words, it’s equivalent to building your entire AI functionality from scratch, within the confines of the VS Code extension API.
Customizing the Chat View
The Copilot Chat does allow some customization, including:
Variables (#yourVariable) to inject extra context.
Slash Commands (/yourCommand) to trigger predefined prompts.
Participants (@yourAgent) to handle custom requests.
But even here, there are important caveats:
Participants only handle requests they are explicitly mentioned in.
They don’t see the full chat history, just what they were tagged in.
There’s no drag-and-drop from custom views.
No reuse of Copilot chat modes or prompt engineering.
The UI is limited to markdown, links, buttons, and file references: no custom views or rich interactive experiences.
You can build chat-based flows using your own LLMs, but everything beyond the basics must be built from scratch, and you’re confined to the default Copilot Chat UX.
Microsoft’s Recent Open-Sourcing: Did This Change Anything?
Recently, Microsoft announced they were open-sourcing significant parts of the GitHub Copilot Chat extension for VS Code under the MIT license. This improves transparency: developers can now inspect and contribute to the client-side Copilot chat integration.
At first glance, this sounds like a breakthrough. But did it change anything material for tool builders who want to create AI-native, domain-specific tools?
Not really.
Here’s why:
Only parts of the frontend are open: Some Copilot-related features (like inline chat, terminal AI assistance, commit message generation) are still closed. Maybe they will be open sourced later, maybe not.
Tight Coupling to Github Copilot: The VS Code integration is still tightly coupled to the Github Copilot infrastructure and backend, from authentication to model communication.
Backend remains a black box: The Copilot AI engine itself - the LLMs, APIs, service infrastructure - remains fully proprietary and tied to Microsoft’s backend.
Even though you can now see how VS Code integrates AI suggestions into the editor, you’re still locked into Microsoft’s infrastructure if you want to offer a similar experience.
In theory, you could fork this newly available client code. But practically, you would need to rebuild significant backend infrastructure, rip out the Code Editor centric parts that don’t align with your vision and re-implement private internal APIs just to make it work with your own AI service.
So while Microsoft’s move is great for improving transparency and enabling community contributions for VS Code itself, it doesn’t change the fact that VS Code + Copilot is still a product you can extend in limited ways, not a platform for building your own AI-native tools.
The Real Constraint: Who’s in the Product Manager Seat?
This is the key takeaway:
With VS Code and Copilot, you're a guest in someone else's product. You get to plug in at predefined points, but the core experience is not yours to define.
In contrast:
With an open platform like Theia AI, you’re the product manager. You define the experience. The platform gives you tools - but you call the shots.
This is not a criticism of VS Code: it’s simply a reflection of what it is: a generic code editor with extensibility focused on adding features to VS Code as a product. The recent open-sourcing makes this extensibility more transparent but doesn’t change the structural nature of that relationship.
The Hidden Costs of Strategic Dependency
If you build your AI features via GitHub Copilot:
You depend on Microsoft’s pricing, rate limits, and product roadmap.
Your chat extensions work only if the user has an active Copilot subscription.
Microsoft can change terms, UI behavior, or availability - and you have no control.
In short, you’re still dependent on another product’s roadmap and business decisions, with limited ownership.
A Better Alternative: Build with an Open Source AI-Native Platform
If AI capabilities are core to your tool’s value, these limitations aren’t just inconvenient - they’re structural blockers.
You need:
Full control over AI models and prompts.
The ability to embed AI deeply into your tool where you envision it, not just a chat view.
Freedom to define your own workflows.
An open platform where you own every layer.
A community of like-minded tool builders to share experience, innovation and maintenance with.
That’s exactly what Theia AI offers.
Theia AI: Full Flexibility for Custom AI-Native Tools
Theia AI is an open source framework built for AI-native tools and IDEs. Unlike Copilot, Theia AI is not a SaaS product - it’s a foundation for building your own product.
Crucially, it is developed and shared under the governance of the @Eclipse Foundation ensuring a vendor-neutral and truly open environment. This is not a single-vendor open source effort: it’s a community-driven initiative, designed for transparency, collaboration, and long-term sustainability.
Key benefits:
🧠 AI agents with deep tool integration - agents that understand your domain, data models, and workflows.
💬 Custom chat interfaces - build your own chat UX, with interactive multi-step workflows.
🧰 Open architecture - choose any LLM (hosted, self-hosted, local) and maintain control over data and infrastructure.
With Theia AI, you’re in charge. You define what’s possible. You decide how it behaves, looks, and integrates.
Conclusion
Microsoft’s decision to open source parts of GitHub Copilot’s VS Code integration is a welcome step for transparency - it allows developers to audit and contribute to how AI suggestions show up in VS Code.
But it doesn’t change the fundamental facts:
Copilot’s backend remains a proprietary service.
The core AI capabilities are still coupled to Microsoft’s cloud.
VS Code + Copilot is still a product you can extend - not a platform you can own.
So before committing to Copilot as your AI foundation, ask yourself:
Do I want to add some AI features to someone else’s editor? Or do I want to build my own tool - with AI at its core?
🚀 Explore Theia AI to take full control of your AI-native tool’s future.
🔧 Or try the AI-powered Theia IDE to see what’s possible.
