In this post we’re going to do two things. Firstly, we’re going to step through how to create an Uno Platform application with VS Code. Then, we’re going to use VS Code to generate an instructions file that will help guide Copilot Chat to generate output that’s more consistent with your application structure.
Setting up VS Code for Uno Platform Development
The first step is to install the Uno Platform extension for VS Code (you can follow this link, or install from the Extensions list inside VS Code):
Once install, you’ll want to make sure you run uno-check to ensure all the dependencies are installed. In the past you would have had to download uno-check but it’s now part of the extension, so you can invoke it directly from the command palette.
Uno-check will run as a separate process, stepping through each set of dependencies to make sure you’re all setup to build and run Uno Platform applications.
Now that we have all the dependencies installed, let’s go ahead and create a new project. You can do this directly from the command line by exploring the options of the unoapp template by running "dotnet new unoapp -h". Alternatively, you can use the Uno Platform Live Wizard to step through the available options and then generate the appropriate dotnet new command that you can run to create your application.
In this case we’re going to be creating a new application using the Recommended preset.
dotnet new unoapp -o InstructionsSampleApp -preset "recommended"
Inside a Terminal within VS Code we can execute this code in order to create the application.
The last thing to do is to open the newly created InstructionsSampleApp folder in VS Code.
After opening the application in VS Code, use the highlighted (red) project selector button at the bottom of the screen to select the project file as the active project.
Next, pick the target platform (click the target platform selector button at bottom of screen), in this case net9-desktop.
Now we can run the application. If you run without the debugger you’ll see that the Hot Design button (left) in the Studio toolbar is enabled.
Clicking the Hot Design button will launch the runtime design experience, allowing the creation, selection and modification of elements in the running application.
If you haven’t already checked out the Hot Design experience, give it a shot today as we’d love to hear your feedback.
Creating Instruction files
Ok, now we have our Uno Platform application setup and ready to go, we can use Copilot Chat in VS Code to use AI to modify our application. Chat can be launched from the View menu.
Opening Copilot chat gives us various options to pick the AI model and the mode – in this case I’m using Agent mode with Claude.
Before I start interacting with Copilot Chat, I make sure that I setup my application to guide AI as to how I want code to be created. To do this you can define instruction files that will help guide AI. Rather than create instruction files manually, in the latest VS Code Preview, there’s a new option to Generate Instructions.
When you select this option, Copilot will spend a couple of minutes analyzing your existing project structure in order to determine the appropriate instructions.
Here you can see a snapshot of the instructions created for our sample application – we created an application using the Recommended presets in the unoapp template, so the instructions are quite opinionated and use a lot of the Uno Platform features such as Toolkit and Extensions.
If I repeat this process using the Blank preset, the instructions file is still quite detailed but isn’t as opinionated when it comes to how code should be structured.
After creating the instructions file, you should see that the output of any interaction with Copilot Chat will be more inline with the existing structure of your application. Of course, you’ll want to adjust and extend the generated instructions file as you continue to develop your application.
Hopefully in the post you’ve seen how to successfully create an Uno Platform application and how you can improve the output of Copilot Chat using instruction files.