I have an idea about letting AI completely take over development on a Theia-based IDE.

[inlann]

Discussion

Right now, our IDE’s source-code development workflow is already fully integrated with AI agents like Claude Code and Cursor. For example, we can feed them a feature requirement, and they can autonomously implement it. After generating code, these agents can automatically run the build process—compiling the source code and producing the application.

However, they still cannot automatically launch the resulting application (especially an Electron-based app), interact with the UI, and verify whether the feature actually works. This final verification step still requires humans to manually open the app and confirm the behavior.

I’m thinking we could reuse ideas from UI testing frameworks. After launching the app, the agent could attach to the UI using something like Playwright, allowing it to autonomously perform UI interactions, validate the functionality, and reason backwards from the results to fix or adjust the generated code. Then it could repeat the cycle: re-compile, rebuild, relaunch, and re-validate.

In other words, this would enable a full end-to-end development loop—from requirement → implementation → build → runtime validation → refinement—without human intervention.

I would really like to help make such a framework possible to accelerate IDE development for everyone. I’m not sure if others in the community are also interested in this idea, but I’d love to discuss it and see if there’s momentum around it.

[github-actions[bot]]

Hi @inlann, thanks for starting this discussion! 👋

The Theia community will take a look soon. In the meantime, you might find helpful information in:

• 📖 Theia Documentation
• ❓ FAQ
• 💬 Previous Discussions

---

💙 Eclipse Theia is built and maintained by a community of contributors and sponsors. If Theia is valuable to your work, consider sponsoring the project. For professional support, training, or consulting services, learn more about available options.

[JonasHelming]

Hi @inlann ,

the workflow you describe is already possible withe Theia Coder today. In the latest 1.69 version (see #17080), in Theia Coder Agent Mode you can turn AppTesting on. It currently works with Browser Applications, but as Theia runs in the browser as well, that does the trick. If you want, please have a look and report whether this addresses your idea.

Best regards,
Jonas

[inlann]

From what I understand, the scenario mentioned here seems more oriented toward IDE users—for example, using agents to help develop and test their own web applications inside the IDE.

What I had in mind is slightly different. My idea is more from the perspective of IDE developers, meaning using agents to help develop and validate the IDE itself.

In other words, instead of using agents to build applications within the IDE, the goal would be to use agents to iterate on the IDE codebase, automatically build it, launch the IDE (for example an Electron-based Theia application), interact with its UI, and verify whether the implemented feature actually works.

So the target would be the development loop of the IDE itself, rather than applications built inside the IDE.

[JonasHelming]

We do exactly this:

Using the Theia IDE you can work on the Theia IDE, including building, testing and UI testing. Have you just tried to use Theia Coder in Agent mode?
The only point from your list above that does not work out of the box is testing Electron applications, mainly because instrumenting a browser is simpler. But the same should very likely also work with Electron, I just have not tested this yet. again, as the browser-based Theia IDE is functionally the same, we usually just use the browser variant for UI testing.

[inlann]

I did some experiments around this idea and found a potentially workable approach.

For the Electron-based Theia application, I tried launching the development build with the Chrome DevTools Protocol (CDP) enabled, for example:

cd applications/electron
yarn start --remote-debugging-port=9222

This exposes a debugging endpoint on port 9222. Then I can connect to the running Electron app from Playwright using CDP:

import { chromium } from 'playwright';

const CDP_URL = process.env.CDP_URL || 'http://localhost:9222';

const browser = await chromium.connectOverCDP(CDP_URL);
const contexts = browser.contexts();
if (!contexts.length || !contexts[0].pages().length) {
    throw new Error('No pages found. Is electron application running with --remote-debugging-port=9222?');
}
const page = contexts[0].pages()[0];

After connecting, Playwright can interact with the UI and perform automated operations.

With this setup, an AI agent could follow a loop like this:

1. Generate or modify code
2. Compile and build the IDE
3. Launch the Electron application
4. Connect to the running app via CDP
5. Perform UI interactions and verify whether the feature works correctly
6. If the behavior is incorrect, update the code and repeat the cycle

So far, this path seems technically feasible. It allows the agent to validate functionality by interacting with the actual IDE UI after building and launching it.

Right now I’m implementing this using Claude Code + custom skills, and I’m still refining the workflow.

[joeblackwaslike]

@inlann I think @JonasHelming was just explaining how everything you describe is already possible and that in fact they are already doing this more or less just using the browser version because it's all the same and much easier to implement than trying to remotely control an electron app. There doesn't seem to be any appreciable advantage to doing this specifically against the electron version of Theia so why make things harder than they need to be?

I too have recently discovered Theia because I want something similar to vscode but without all the closed source m$ fuckery. I'm looking specifically to have something that operates in the way cursor should have if it wasn't so focused on raising millions in VC funding. I know it should not be a vscode fork under any circumstances (I think cursor shot themselves in the foot by forking vscode). That would be a long term maintenance headache I wish on nobody.

I feel like M$'s control over vscode puts them in a position where theres a clear conflict of interest between them allowing people to integrate advanced AI tooling via vscode extensions vs being forced to use the first party github copilot only native AI features. Because of that they have a defacto monopoly on sophisticated agentic integrations.. it's simply not in their interests that competition be allowed to exist in the form of extensions. It's really a shame to see all of that potential wasted on github copilot, which is so comically bad compared to Claude Code or Opencode.

I'm auditing Theia as a potential starting point to building an IDE deeply integrated with modern agentic coding practices and workflows, something like Opencode but with deep IDE integrations like shown on that video where they demo the Claude Code agent (@claude Code). Also first-class support for these new very powerful but still affordable Chinese models like Kimi2.5 and GLM. Opencode is a typescript project as well and supports using AI coding subscription plans (claude pro/max, codex plus/pro, kimi for coders, opencode zen). This IMO is much more sustainable for agentic coding long-term than raw dogging it with a handful of API keys to the tune of $1000+/month. I think what's been done with Theia now vs whats possible is just scratching the surface. Here are my inspirations:

• Theia/CC integration: https://www.youtube.com/watch?v=Mz5puixbnDM&vl=en
• Gastown!: https://github.com/steveyegge/gastown
• Oh-My-Opencode: https://github.com/code-yeongyu/oh-my-opencode

There seem to be enough of us where if enough of us really wanted to do this we could build the open-source agentic-coding vscode killer we all want so badly using the modern models. Anyone else who's interested in seriously making this happen, should reach out @ me@joeblack.nyc. If there seems to be enough interest I'll set up a discord where we can organize further. I'd love to hear other peoples ideas too! :)

[JonasHelming]

@joeblackwaslike Thank you for the clarification.

In short: I think there is a lot of interest in what you describe. However, before you start something new, please have a close look at what is already there: Theia Coder in Agent Mode in the Theia IDE.

The Theia IDE is an open IDE built on Theia (the platform) with native AI support
Theia Coder is an agent running within the Theia IDE. It has an agent mode that operates like both of you describe. So an agent that works like Copilot or Claude Code.
Both are completely open.
We continoulsy evolve Theia Coder with an open and existing community, see for example: #17125 for the next version with a more swarm like approach.

However, there are for sure many possible improvements, e.g. the once you mentioned: (1) better integration into the workflow (2) first-class support for OS models (this technically works, but it is not optimized against specific models at the moment) and of course many other innovations. But Theia Coder is an agent that is used every day for real development.

As a community, we are very interested in driving this further.

You basically have two paths:

1. You can investigate Theia Coder and the Theia IDE and join its development. With this you do not start from zero and you ideally become part of an existing community
2. You start a new IDE based on the Theia platform. With this you can evolve wherever you want, but you start with zero community.

Both approaches are completely fine and due to the modular approach of Theia, you can likely avoid forking for approach 2. There are many commercial products based on Theia that do exactly this (but in a closed way) and it is also what the platform was build for. However, if your goal is an open community, approach 1 might kick-start it, because it is already there and you could make it better. There are existing communication channels, users, contributors, regular meetings, releases, ...

I will ping you personally in case you want to discuss this further.

My suggestion for both of you:

1. Get Theia IDE latest preview version 1.69: Theia IDE 1.69.x Preview Testing #17080
2. Use Opus-4.6 (or comparable) as a model
3. Use Theia Coder in agent mode
4. Try to do the same thing you do today with Claude Code or Copilot

I hope this makes sense, thank you to both of you for contributing to this discussion!