My JetBrains Rider Setup for Surviving Live-Coding Demos

Hey lovely readers,

If you've read any of my Public Speaking at Tech Events 101 blog posts, you already know I take demo prep very seriously. What I haven't written about yet is my IDE setup. I spend most of my working hours in JetBrains Rider, and I also spend most of my stage time there. Over the years I built a setup that helps me get through a live demo without fighting my own tools on top of fighting my nerves.

This post is that setup written down. That way it can help you too if you ever want to challenge the demo gods.

A quick note before we start: I'm writing this as a Rider user, since that's where I live most days. But almost everything here works the same way in WebStorm, IntelliJ IDEA, PyCharm, and the other JetBrains IDEs, since it's mostly the same underlying platform.

Presentation Mode and light theme

The first thing I do before any talk is turn on Presentation Mode. You'll find it under View > Appearance > Enter Presentation Mode. It makes the editor fill the whole screen and it makes the font bigger automatically. That way you don't have to change font sizes by hand right before you walk on stage.

You can also set a fixed zoom level ahead of time. Then it's already right the moment you turn Presentation Mode on, instead of adjusting it in front of a room full of people. Go to File > Settings (or Preferences on macOS), then Appearance & Behavior > Appearance and look for the Presentation Mode settings there.

The second thing I do is switch to light theme. I know, most of us live in dark mode (me included). But dark themes often look washed out under conference lighting and projectors. Light backgrounds are simply easier to read from the back of the room. Your eyes might need a minute to adjust, but your audience will thank you.

Markdown-powered slides with MARP

This one changed how I build talks completely. Instead of switching between PowerPoint and Rider during a demo, I now write my slides in Markdown. I preview them right inside the IDE, using MARP (Markdown Presentation Ecosystem).

Here is the short version of the setup. Add a package.json file next to your presentation file:

{
  "scripts": {
    "marp": "marp index.md -w --html --allow-local-files"
  },
  "devDependencies": {
    "@marp-team/marp-cli": "^4.5.0"
  }
}

Then create an index.md file in the same folder. Write your slides in Markdown, and separate each slide with ---. Run npm install, and Rider will show a small run button next to your script. Run it, and the -w flag keeps watching your Markdown file. It rebuilds the HTML every time you save.

To show the presentation, right click the new HTML file and choose Open In > Browser > Built-in Preview. Now your slides live in a tab right next to your code. You can switch between them using Rider's normal tab shortcuts, instead of switching to a completely different app.

A few things that are worth knowing. Press P while previewing to open a window with your speaker notes, which you can keep on a second screen. If you use the --html flag like in the script above, you can also add things like Mermaid diagrams straight into your slides. Unfortunately I don't get lots of opportunities to add Mermaid Diagrams to demos but I do love them :)

I like this setup because my whole talk, slides and demo code both, lives in one place. That's one less app to manage, and one less thing that can go wrong.

Quick side note if you do JavaScript or Vue talks: I use Slidev for those instead. It's also Markdown powered, but it's built with the JS ecosystem in mind, so it fits that kind of talk a bit better. Same idea, just a different tool depending on the stack I'm presenting.

Switching files and projects quickly

During a demo, the last thing you want is to search through 5 different projects, trying to remember where you put a file. Search Everywhere (press Shift twice) is your best friend here. Type a few letters of a file, class, or action name, and you jump straight to it. No scrolling needed.

Recent Files (View > Recent Files, or Ctrl/Cmd+E) and Recent Locations (View > Recent Locations, or Ctrl/Cmd+Shift+E) are both super useful in addition to Shift + Shift. Recent Files just shows you the files you had open recently. Recent Locations goes a step further and shows you actual code snippets from the places you edited, which is handy if you remember what the code looked like but not which file it was in.

All three of these search options help you move fast between the two or three files a demo actually uses. And if something goes wrong and you need to switch from a working project to a backup project, being able to jump between run configurations or entire projects fast matters just as much as knowing your code.

dotnet run and .http files

Since .NET 10 we can now use single C# files without setting up a full project first. This is great for quick demos. I often skip run configurations completely and just use dotnet run from the terminal. It's fast, it's predictable, and there is less to explain if something looks unfamiliar to the audience.

For live API demos, .http files are one of my favorite Rider features. Instead of switching to an API client and breaking the flow of your talk, you write the request right there in your project:

GET https://localhost:5001/api/dadjoke
Accept: application/json

Click the small run icon next to it, and the response shows up right there. No separate tool, no window switching, no explaining why you suddenly switched apps.

Live templates

The live templates might be the best thing ever for demos. They are one of the best tools for reducing what can go wrong on stage. A live template is a code snippet you can insert with a short name and a press of Tab.

You'll find them under File > Settings (or Preferences on macOS), then Editor > Live Templates. From there you can create a new template group, or add templates to an existing one, each with its own abbreviation, description, and body.

I use these a lot, but especially for two of my talks: Minimal APIs and modern C# features. Both involve a lot of boilerplate. If I had to type every endpoint or every record from scratch during a session, I would be typing the whole time instead of talking to the room.

This is where a naming format helps. Instead of picking random short abbreviations, I group mine by talk topic with a short prefix. api-get, api-post, and api-delete are all Minimal API templates. csx-record and csx-pattern are all modern C# templates. That way I'm not stuck remembering fifteen unrelated abbreviations, I just remember the prefix for the talk I'm giving, and Rider's autocomplete shows me the rest as I type.

Less typing under pressure means fewer mistakes. That's really the whole point.

Shortcuts worth knowing by heart

I'm not going to give you a giant list of every Rider shortcut that exists. That's not useful in the middle of a talk. These are the ones I actually know by heart, the ones that help when your brain isn't at its sharpest:

• Shift Shift for Search Everywhere
• Ctrl/Cmd + Shift + F10 (or the run icon) to run the current file or test
• Shift + F9 to debug
• Ctrl/Cmd + Alt + L to reformat code, handy if a live edit gets messy

That's the list. You don't need fifty shortcuts. You mostly need these four to get you out of trouble.

That's a wrap!

None of this actually removes the nerves before a talk. I still feel them every single time, and that's completely normal. What this setup does is remove the things you can actually control. That way your nervous energy can go into the talk itself, instead of into fighting your IDE.

I hope this helps you for your upcoming presentation or talk. If you have questions about anything above, feel free to leave a comment or reach out to me on my socials.

See ya!