DEV Community: Steve Baker

Using Ollama with VS Code for Local AI-Assisted Development

Steve Baker — Sun, 08 Mar 2026 00:33:17 +0000

Using Ollama with VS Code

If you want an AI coding assistant without sending your code to the cloud, Ollama makes it easy to run an LLM locally and easily integrates with Visual Studio Code and other IDEs.

1. Install Ollama & Run Your Chosen Model

Download and install Ollama from the official site.

After installing, verify it works via your terminal:

ollama --version

Then select a model to run. You will need to choose a model, version and number of parameters based on your hardware (RAM/CPU/GPU specs). You may also need to limit the context length for the best performance. One of the models I tested for coding tasks was qwen3-coder:7b:

ollama run qwen3-coder

The model will download automatically when you run it.

You can select & test this model out via the Ollama GUI.

2. Setup 'Continue' VS Code Extension

To use Ollama inside VS Code, install an extension that supports it - a popular option is Continue.

Installation Steps:

Open VS Code
Go to Extensions
Search for Continue
Click Install

3. Configure Your VS Code Extension to Use Ollama

Open the Continue config file - it should be located in your profile: ~/.continue/config.json

Then add your local Ollama model(s):

{
  "models": [
    {
      "title": "My Llama Model",
      "provider": "ollama",
      "model": "qwen3-coder:7b"
    }
  ]
}

Restart VS Code after saving.

4. Start Using Local AI!

You can now ask questions or give instructions directly in your IDE, such as:

"Explain this codebase"
"Add the following feature [..]"
"Write unit tests for the file @UserService.cs"

All requests are handled locally through Ollama, using the model you previously setup

Conclusion

Using Ollama with VS Code gives you a private, offline AI coding assistant that can act as an alternative to ChatGPT, Claude and other popular AI tooling, especially if an AI provider has downtime, you run out of credits or you want a privacy focused, offline AI assistant! Ollama is simple to set up, free to run and works with many open-source models.

Troubleshooting DefaultAzureCredential: Identifying Which Credential Is Used

Steve Baker — Wed, 10 Dec 2025 14:09:04 +0000

The Problem

When using the Azure Identity NuGet package, DefaultAzureCredential attempts to load a range of credential types such as Environment Variables, Visual Studio, Azure Managed Identity and more. The full list is documented on Microsoft Learn

Determining which credentials are being used can be tricky unless you manually enable logging. When doing this, the Microsoft recommended approach will give you a very verbose output. To simplify the output, insert the below snippet into your applications startup.

⚠️ Security note: enabling IsAccountIdentifierLoggingEnabled may
include sensitive account information in your logs. Only use this during
debugging and ensure these logs are not persisted or exposed.

The Solution

using var listener = new AzureEventSourceListener((e, message) =>
{
    if (e.EventSource.Name == "Azure-Identity")
    {
        Console.WriteLine(message);
        // Alternatively, use _logger.LogInformation() if running in Azure
        // WARNING: These logs may include sensitive credentials
        // depending on the options selected below
    }
},
System.Diagnostics.Tracing.EventLevel.LogAlways);

var options = new DefaultAzureCredentialOptions
{
    Diagnostics =
    {
        IsAccountIdentifierLoggingEnabled = true,
        // Useful extra options for debugging
        // These act as a Whitelist of fields to log. By
        //LoggedHeaderNames = { "x-ms-request-id" },
        //LoggedQueryParameters = { "api-version" },
        // This enables logging the request or response body
        //IsLoggingContentEnabled = true
    }
};

var credential = new DefaultAzureCredential(options);

AzureEventSourceListener will create a verbose logger. Adding that filter will remove a lot of noise.

Sample Output

You should get an output similar to this:

EnvironmentCredential.GetToken invoked
EnvironmentCredential.GetToken was unable to retrieve an access token
...
VisualStudioCredential.GetToken succeeded

This output makes it straightforward to identify exactly which credential type was successful (or unsuccessful).

Speed up your Docker builds using layer caching (avoid reinstalling dependencies)

Steve Baker — Sun, 11 Oct 2020 10:40:32 +0000

A project I worked on recently had a ~7 minute Docker build time. Config changes required a rebuild, so 7 mins per change. Something i noticed was npm packages being installed for config changes and even HTML changes - why do I need to download 1000+ npm packages if i'm only changing HTML? Madness! There is a simple solution to this.

How Docker layer caching works

Docker will cache commands but only if the Dockerfile is written in a certain way. Take the following scenario:

FROM node:9
COPY /src /src
RUN npm install
RUN npm run build

Docker can cache each command and create a Layer. Layers are cached if Docker detects that no files have been changed for that command.

By splitting the COPY into 2 commands, we can utilize caching and speed up the build time for builds that haven't modified npm packages:

FROM node:22-alpine
COPY /src/package*.json /src
# Docker will cache these 2 layers if package.json and package.lock.json are unmodified
RUN npm install

# copy the rest of our code and run a fresh build
COPY /src /src
RUN npm run build

The Result

One extra line saved our team several minutes per build - in my scenario it was local builds and CI server builds (as npm packages rarely change in larger/mature project).

This pattern also works for any package manager: swap package.*json and npm install to align with your package manager (dotnet restore, bundle install, pip install etc)

Randomize your Windows desktop background with PowerShell

Steve Baker — Mon, 14 Sep 2020 08:29:51 +0000

Hi!

Tired of the same desktop background? Here's a small PowerShell script that pulls a random wallpaper from WallHaven's free API and sets it every time Windows starts

Note: this will only work on Windows.

There are 2 files involved:

Set-RandomBg.ps1 - downloads a random image using the WallHaven API
Set-Wallpaper.ps1 - a reusable module to change the Windows wallpaper which requires an image file path

Set-RandomBg script

# You can specify a search term here or leave it blank:
# $keyword=$null
$keyword="nature"

[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12

$url = "https://wallhaven.cc/api/v1/search?sorting=random&q=${keyword}";

# See full list of API options here:
# https://wallhaven.cc/help/api#search

"Loading results from: $url"

$response = Invoke-RestMethod -Uri $url

# Filter out landscape results
$response.data = $response.data | Where { $_.dimension_y -le $_.dimension_x }

$count = $response.data.length -1
"Found $count images"

$random = Get-Random -Minimum 0 -Maximum $count
"Random id: $random"

$wallUrl = $response.data[$random].path

$filename = "C:\temp\bg.jpg"

"Downloading $filename"

Invoke-WebRequest $wallUrl -OutFile $filename

# load the Set-Wallpaper module so we can execute it
. $PSScriptRoot/Set-Wallpaper.ps1

Set-Wallpaper -Image $filename

# To debug any issues, uncomment the following line:
# pause

Set-WallPaper script

The Set-WallPaper script looks a little scary at first but all it's doing is changing the Windows desktop wallpaper setting via C# (there's no PowerShell way and alternative methods like updating the Registry wouldn't work for me)

The script can be found here:
https://www.joseespitia.com/2017/09/15/set-wallpaper-powershell-function/

Running via start-up

To run this script on start-up, create a new Shortcut in your startup folder located at shell:startup with the following TargetPath
"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe " -file C:\MYSCRIPTSFOLDER\Set-RandomBg.ps1. Make sure to replace MYSCRIPTSFOLDER with the location of the PowerShell scripts!

Thanks for reading! If you know a better way to achieve this, or want to
extend it (WallHavens API supports multiple filtering options), leave a comment below.

Creating a portfolio site using Gatsby & Trello

Steve Baker — Thu, 20 Aug 2020 22:18:09 +0000

If you want a portfolio site that updates itself without managing a CMS, this might be the approach for you. I had all my project data already sitting in a Trello board - so instead of duplicating it somewhere else, I wired it directly into a Gatsby static site. Here's how it works and whether it's worth it.

What is Gatsby?

Gatsby is a free and open source framework based on React that helps developers build blazing fast websites and apps

https://www.gatsbyjs.org/

Gatsby allows you to build a static site, similar to Jekyll but with a lot more to offer - you can use a range of node packages & use React features such as Components etc. You will build a site using React but when built, a static site will be generated (with minimal JavaScript & dependencies - just good ol' HTML and CSS!)

My Trello 'Projects' board

The idea for this project was to expose data from my personal Trello board & showcase some of the projects I've done in the past or am currently working on. The information was already in this board so why not expose it (as opposed to duplicating this data in a Content Management System)

Hooking it up to Trello

This project was surprisingly simple in the end, I basically ended up with a handful of components - a ProjectList Component, ProjectItem Component and ProjectDetail Component ('Project' mapping to a single Trello Card).

To scrape the data from Trello & dynamically generate a page per Trello Card (& also a Project List page), I used the gatsby node APIs and ended up with something like this:


...
// Use a Trello API to gather the data
const trelloCards = myTrelloHelper.getAllCards();
...

exports.createPages = ({ boundActionCreators }) => {
  const { createPage } = boundActionCreators;

  // Page to list all projects
  createPage({
    path: `/`,
    component: require.resolve("./src/all-projects-template.js"),
    // Data for this page - we require all of the Trello Cards & Labels
    context: { trelloCards },
  })

  const cardTemplate = path.resolve(`src/card-template.js`);

  var showdown = require('showdown');
  var converter = new showdown.Converter();

  // Create a page for each Trello Card
  trelloCards.forEach((card) => {
    const path = card.path;

    // Convert our Trello markdown to HTML
    card.details = converter.makeHtml(page.desc);

    createPage({
      path,
      component: cardTemplate,

      // Send the card data to this component so we can render the cards details
      context: {
        card
      }
    });
  });
};

Benefits & Drawbacks

Benefits

Security - The data source (Trello) isn't publicly available - only my CI and my local dev environment have access to the Trello API Key (although it's just a readonly key, I still wouldn't want users to access my other Trello boards or cards!)
Cost - Hosting a static site is cheap / free as there is very little architecture - no API's to host & using Trello means no cost for data storage
Stability - As this is a static site with no JavaScript, no API's and no database, there's less points of failure. No worries of unhealthy API's or databases having issues etc. If the API being consumed does have performance issues or is down, the end user won't see this - the generated content will just be slightly outdated.
Speed - Static content means there's very little / no JavaScript (bulky front end frameworks can drastically reduce page load and render speeds, especially when not configured properly or minified) & everything can be cached via a Content Delivery Network.
Effort - I don't have to duplicate my content! As long as I add the correct tags & readable content on my private Trello board, it will get transformed into a readable web page

The main drawback I found was:

No real-time updates: It currently doesn't update in real time though I have my project set to rebuild & redeploy on a regular schedule along with any git commits. I could also use Trello web-hooks to trigger a build which seemed a little overkill for my needs

Conclusion

This approach is quite flexible - swapping in another data source (CMS, API or even a different Trello board!) would take minimal effort.

DEV Community: Steve Baker

Using Ollama with VS Code for Local AI-Assisted Development

Using Ollama with VS Code

1. Install Ollama & Run Your Chosen Model

2. Setup 'Continue' VS Code Extension

3. Configure Your VS Code Extension to Use Ollama

4. Start Using Local AI!

Conclusion

Troubleshooting DefaultAzureCredential: Identifying Which Credential Is Used

The Problem

The Solution

Sample Output

Further Reading

Speed up your Docker builds using layer caching (avoid reinstalling dependencies)

How Docker layer caching works

The Result

Randomize your Windows desktop background with PowerShell

Set-RandomBg script

Set-WallPaper script

Running via start-up

Creating a portfolio site using Gatsby & Trello

What is Gatsby?

My Trello 'Projects' board

Hooking it up to Trello

Benefits & Drawbacks

Conclusion