DotPilot: my first extension for Visual Studio Code

I just published my first Visual Studio Code extension. It's called DotPilot and it runs projects from a panel inside the editor.

The case is simple: you're reviewing an application, you make a change, and you need to start the right project to check it. Then you have to stop it, run it again, or look into why it failed. DotPilot brings those controls together and also lets an AI assistant use them, with your permission.

It's available on the Visual Studio Marketplace. Here I'll tell you how it works and how it differs from C# Dev Kit, Code Runner, and .NET Core Test Explorer.

What DotPilot does

When you open a compatible workspace folder, DotPilot looks for projects it can run. It shows them in its panel so you can pick one and choose how to start it.

It currently recognizes projects built with these technologies:

The DotPilot documentation describes which files and configurations it uses to recognize each project.

This has a practical consequence: if the project doesn't meet the detection conditions, it may not show up. The extension needs to find a way to run it that it knows about.

How to use it

The usual flow is short:

1. You open the project folder in Visual Studio Code.
2. You go into the DotPilot panel.
3. You select the project and its run profile.
4. You press the button to start it.
5. You check the application and stop it when you're done.

A profile is a startup configuration. In simple terms, it tells the extension how you want to launch that project.

DotPilot also reads the server address from the application's messages. If it starts on a different port, it can show the address it's actually using.

For whoever is reviewing the result, that avoids relying on an address remembered from a previous run. For the developer, it keeps access to the application right next to the controls they used to start it.

The browser can become tied to the application

DotPilot provides a linked Edge or Chrome window with a temporary profile. That window has a direct relationship with the run: when you close it, the application tied to it also closes.

This is a behavior worth knowing from the start. If you're used to closing the browser and leaving the server running, you'll need to choose the browser option that matches the way you work.

There's also an option to use your default external browser, without that link.

The idea is for you to recognize which window belongs to the run you just started and control that run from the same flow.

What additional features does it have for .NET

In .NET projects, DotPilot includes actions to build and run tests. It also offers debugging using Microsoft's C# extension.

Debugging means stopping the application at a specific point to investigate what's happening. It's useful when an error can't be understood just from what appears on screen.

Another feature is Hot Reload, which lets you apply compatible changes while the application keeps running.

These additional features are exclusive to .NET. The fact that DotPilot can start a Python or Node.js application doesn't mean it offers the same tools for every technology.

This difference should be clear when you install it, especially if your team maintains projects of several types.

How it connects with AI assistants

DotPilot lets you connect assistants like Claude Code and Codex through MCP. It also exposes tools for GitHub Copilot inside Visual Studio Code.

MCP is a mechanism for an assistant to use external tools. In this case, it gets access to specific DotPilot actions.

For example, the assistant can check which projects the extension found, select one, and request that it run. After that, it can read the available output to check whether it started or what error appeared.

The connection is enabled by the user's decision. Actions that start work request permission based on the chosen settings.

There's an important limit: the assistant uses the actions and projects that DotPilot recognizes. That access doesn't let it run any arbitrary instruction through the extension.

What has been verified so far

The published listing reports complete sessions verified with the Claude Code and Codex command-line tools.

It also distinguishes integrations whose verification was partial and notes that interactive sessions inside Visual Studio Code have not yet been verified.

So if you want to use it with an assistant, it's worth testing the full flow in your own environment. Just because the connection exists doesn't mean every combination has been verified.

How it compares to other extensions

Some features overlap, but the tools have different scopes.

Versus C# Dev Kit

C# Dev Kit includes project management and testing, and relies on the C# extension for language capabilities.

DotPilot overlaps on some run and build actions, but it doesn't replace that entire environment.

If you already use C# Dev Kit, the decision would be to check whether DotPilot makes it easier for you to switch between .NET projects and apps built with other technologies. They can complement each other; it will depend on your routine.

Versus Code Runner

Code Runner lets you run files and code snippets in numerous languages.

To check a small function or an isolated file, that approach may be enough. DotPilot organizes execution around detected projects and their profiles.

The most useful comparison starts with the task you need to do: run a snippet or start a full application.

Versus .NET Core Test Explorer

.NET Core Test Explorer focuses on discovering and running tests.

DotPilot has an action for running .NET tests. That's not the same as offering the same experience for browsing them and checking results.

If that's the work you want to improve, consider the test explorer as a specialized tool.

What still needs to be verified

The documentation states manual testing on Windows and points out environments that haven't been tested yet, including Linux, macOS, and several forms of remote work.

I also don't have a published measurement to say that DotPilot saves a certain number of minutes per day. I'd rather verify it with repeatable walkthroughs before attributing any savings to it.

A simple test would be to launch a typical application with the current flow and repeat the task with DotPilot. Tracking the time and steps required would show whether it helps on that project.

My takeaways

For my first Visual Studio Code extension, DotPilot already has a clear scope: detect compatible projects, bring together run controls, and offer those actions to AI assistants.

Now it's time to test it in more scenarios and fix whatever comes up. Its limits are published so you can decide which project to start with.

Conclusion

If you work in Visual Studio Code and switch between applications built with different technologies, you can install DotPilot from the marketplace and try it with a project you already know.

The best way to evaluate it is to use it during a real review: launch the application, check a change, and stop it when you're done.

References

• DotPilot: features, requirements, and verification status
• C# Dev Kit: documentation and license
• Code Runner: official documentation
• .NET Core Test Explorer: official documentation