Visual Studio Code on Chris Reddington

Rubber Duck Thursdays - Let's build down tech debt

Thu, 11 Dec 2025 00:00:00 +0000

Chris reviews the latest GitHub changelog and explores the major VS Code December release, then continues building custom agents for a game MCP server project.

GitHub Changelog Highlights

CodeQL 2.23.6 adds Swift 6.2.1 and new C# security queries
GPT-5.1 Codex Max now in public preview for GitHub Copilot across VS Code, GitHub.com, and GitHub Mobile
Workflow dispatch inputs limit increased from 10 to 25
Copilot code generation metrics now available in the enterprise insights dashboard
Enterprise teams limits increased over 10x — up to 2,500 teams and 5,000 users per team
Dependabot-based dependency graphs for Go now provide more complete transitive dependency trees
npm classic tokens revoked — replaced with session-based and CLI token management
Repository custom properties now support GraphQL management and a URL type with built-in validation
GitHub MCP server adds tool-specific configuration, lockdown mode for untrusted contributors, and default content sanitization against prompt injection
GitHub Enterprise Server 3.19 GA with rule set history import/export, SSH/TLS cipher configuration, and OpenTelemetry metrics
Auto model selection GA in VS Code for all Copilot plans

VS Code December Release — Agent Features

Agent HQ for managing multiple coding agents — background, cloud, or local — working simultaneously
Background agents with git worktrees for isolated workspaces, enabling multiple agents to work in parallel without file conflicts
Custom agents for organizations — share agents at the org level via .github-private repositories
Sub-agents via run sub agent — delegate tasks to specialized sub-agents with their own context windows to avoid context bloat
Claude skills support — reuse existing Claude Code skills within VS Code agents
Session management improvements — integrated sessions view, compact and side-by-side layouts, and persistent local agent sessions

Live Coding — Custom Agents and Background Agents

Chris demonstrates the new VS Code agent features by continuing work on a tic-tac-toe game with an MCP server backend. He creates a testing specialist agent using a TDD workflow, experiments with background agents running in git worktrees, and explores sub-agent delegation for specialized tasks like code quality review.

Rubber Duck Thursdays - Let's build with custom agents (again!)

Thu, 04 Dec 2025 00:00:00 +0000

Chris continues building custom agents for the SDLC, exploring the awesome-copilot repository for inspiration and live-building a GitHub Actions workflow agent with plan mode.

Topics Covered

GitHub Changelog Roundup — Blocking repo admins from installing GitHub Apps now GA, Copilot Spaces with public spaces and code view support, secret scanning updates for November 2025, GitHub Enterprise Server 3.19 RC, assigning issues to Copilot via GraphQL and REST APIs, and Claude Opus 4.5 availability across more IDEs.
Agent Inspiration from awesome-copilot — Reviewing partner-built agents and the awesome-copilot repository for ideas including test writers, security reviewers, tech debt analyzers, documentation generators, PR review assistants, and onboarding guides.
Agent Consolidation — Discussing whether to keep agents separate or consolidate them based on shared tool access, output formats, and domain overlap.
Building a GitHub Actions Agent — Using plan mode to design a custom agent for authoring and updating GitHub Actions workflows, including monorepo build order awareness and minimal permissions guidance.
GitHub Actions Instructions File — Creating a companion instructions file with repository-specific CI/CD conventions, build order, environment variables, and recommended practices for workflow definitions.
Plan Mode Workflow — Demonstrating the iterative plan-then-implement workflow where Copilot asks clarifying questions before generating code, and switching between plan and agent modes.

Rubber Duck Thursdays - Let's build with custom agents

Thu, 27 Nov 2025 00:00:00 +0000

Chris explores Copilot custom agents and custom instructions, restructuring project context files and creating meta instruction files for a more effective AI-assisted development workflow.

Topics Covered

GitHub Changelog Roundup — Enterprise bring-your-own-key for Copilot, linter integration with Copilot code review (ESLint, PMD), GitHub Actions cache size exceeding 10 GB, Claude Opus 4.5 in public preview, and secret scanning updates.
Custom Instructions Deep Dive — Restructuring copilot-instructions.md to include monorepo tech stack details, build order, service boundaries, security guidelines, and testing conventions using recommended practices from the docs.
Meta Instruction Files — Creating instruction files that teach Copilot how to write better custom instructions and custom agents, pulling in recommended practices from the GitHub and VS Code documentation.
Plan Mode for Agent Design — Using Copilot’s plan mode to iterate on ideas before implementation, demonstrating how follow-up questions help refine requirements like rubber duck debugging.
Context Engineering — Discussion on supplying the right context to Copilot, balancing context window size, and the importance of being requirements-driven for high-quality code generation.
Community Q&A — Topics including sustainable engineering pace, avoiding burnout, handling merge conflicts, and the fundamentals of software quality.

Rubber Duck Thursdays - Let's build

Thu, 20 Nov 2025 00:00:00 +0000

Chris catches up on several weeks of GitHub releases and then returns to the turn-based game MCP server project to fix a dependency upgrade issue.

Topics Covered

GitHub Changelog Roundup — Managing Copilot coding agent tasks in VS Code, new OIDC token claims for GitHub Actions, GPT-5.1 and Codex models, configuring the coding agent as a bypass actor for rulesets, MCP registry and allowlist controls in VS Code Stable, plan mode and isolated sub-agents in public preview, Gemini 3 Pro, and CodeQL updates.
MCP Server for Games — Revisiting the tic-tac-toe MCP server project and demonstrating how tool calls allow natural language game interaction with a backend API.
Fixing Dependency Upgrades with Copilot — Using agent mode across multiple models (Codex, Gemini 3 Pro) to diagnose and resolve a type check failure caused by a Dependabot SDK version bump.

Rubber Duck Thursdays - Copilot agent mode, coding agent and MCP servers

Thu, 10 Jul 2025 00:00:00 +0000

In this episode, we review the latest GitHub changelog including remote MCP server support for coding agent and Copilot code review on mobile. We use the Playwright MCP server with Copilot agent mode to debug and fix UI issues in the Octo Arcade project, discuss the differences between ask, edit, and agent modes in VS Code, and explore MCP server concepts like tools, prompts, and resources.

Topics covered

GitHub changelog recap — Agents page for Copilot coding agent, CodeQL Rust support, improved repository creation experience, dependency auto-submission for Python, Copilot code review on GitHub Mobile, remote MCP server support for coding agent, and delegating tasks via the GitHub MCP server.
Playwright MCP server for UI debugging — Used Copilot agent mode with the Playwright MCP server to debug and fix game sizing issues in the Octo Arcade project, including viewport overflow, header overlap, and mobile responsiveness for pong, brick breaker, and matching games.
Ask vs Edit vs Agent mode — Walked through the practical differences between VS Code Copilot modes: ask for conversational code suggestions that must be manually applied, edit for targeted file changes, and agent mode for autonomous multi-step workflows that can run builds, tests, and use MCP tools.
MCP server concepts — Explored MCP server fundamentals including the three main primitives: tools (executable functions), prompts (predefined conversation templates), and resources (contextual data for the AI).

Rubber Duck Thursdays - Let's build

Thu, 03 Jul 2025 00:00:00 +0000

In this stream, Chris returns from vacation to catch up on weeks of GitHub updates and demonstrates adding internationalization to apps using Copilot coding agent, custom VS Code chat modes, and agent mode in Xcode.

Topics Covered

GitHub Changelog Review — Updates including model evaluations CLI for GitHub Models, remote GitHub MCP server in public preview, Copilot coding agent now available for business users, GitHub Models pay-as-you-go billing, Claude Sonnet 4 and Opus 4 GA, CodeQL updates for Go and Swift, Actions Runner Controller release, and Copilot code review with custom instructions support
Custom Chat Modes in VS Code — Creating a custom planning mode in VS Code Insiders to generate implementation plans and create GitHub issues, integrating the GitHub MCP server as a tool within the chat mode
Remote GitHub MCP Server — Setting up and authenticating with the new remote GitHub MCP server, eliminating the need for local Docker containers and personal access tokens via OAuth
Copilot Coding Agent for Internationalization — Assigning a GitHub issue to Copilot to add English, French, and Spanish language support to the Copilot Airways Next.js web app, reviewing the AI-generated pull request
Xcode Agent Mode — Demonstrating agent mode in Xcode to add internationalization to a Swift iOS version of the Copilot Airways app with a language selector
Issue Creation with Copilot — Using Copilot on github.com to draft well-structured GitHub issues from natural language descriptions

Rubber Duck Thursdays - Copilot coding agent and Copilot agent mode

Thu, 05 Jun 2025 00:00:00 +0000

In this stream, Chris returns after Microsoft Build to dive deep into Copilot coding agent, demonstrating how to assign GitHub issues to Copilot and review the resulting pull requests.

Topics Covered

Microsoft Build Recap — Highlights from the event including Copilot coding agent announcements, agent mode availability in Eclipse, Xcode, and IntelliJ editors, and GitHub Models updates
GitHub Changelog Review — Three weeks of updates including Claude Sonnet 4 and Opus 4 in GitHub Copilot, Copilot Spaces, GPT-4o Copilot model update, coding agent on GitHub Mobile, secret scanning pattern expansions, and GitHub Enterprise Server 3.17
Copilot Coding Agent Deep Dive — Live demo with Copilot Airways app showing how to assign issues to Copilot, review AI-generated pull requests for refactoring and CI/CD deployment, and iterate through code review comments
MCP Integration with Notion — Demonstrating Model Context Protocol by connecting Copilot coding agent to a Notion MCP server to pull requirements from external tools and implement features automatically
Issue Scoping Best Practices — Structuring GitHub issues with overview, problem statement, acceptance criteria, implementation details, and file pointers for optimal Copilot coding agent results
Copilot Code Review — Using automated code review on pull requests with actionable suggestions for code quality

Assigning Copilot ad-hoc tasks through Copilot chat

Thu, 22 May 2025 00:00:00 +0000

The GitHub Copilot coding agent isn’t limited to work assigned from GitHub Issues—you can also delegate tasks directly from a Copilot Chat session in Visual Studio Code while actively working in the codebase.

The video walks through the following workflow on the ‘Copilot Airways’ demo app:

Opening Copilot Chat in ask mode in Visual Studio Code and invoking the @github chat participant
Describing naming inconsistencies found across the codebase and asking Copilot to raise a pull request that standardizes the naming conventions across all implementations
Reviewing Copilot’s proposed plan (including documentation improvements to make conventions explicit) and confirming before it proceeds
Copilot creating the pull request and returning a direct link within the chat session
Viewing the session log to see how Copilot mapped out the refactoring approach
Letting Copilot work asynchronously in the background—running lint and build steps to verify code quality—while continuing with other work
Returning to the pull request, using the ‘Approve and Run’ button to trigger GitHub Actions checks, and progressing to merge once all checks pass

VS Code, Live — Straight from Microsoft Build! 🪐

Mon, 19 May 2025 00:00:00 +0000

Join VS Code, Live! at Microsoft Build. For the first time ever, VS Code, Live! is going on stage—in person—and you’re invited! Get an inside look at what the team’s building, featuring live conversations with devs and creators. Whether you’re deep into VS Code or just curious about what’s next, this is your dev-first, code-forward pass to what’s new.

Rubber Duck Thursdays - Building from requirements with Agent Mode

Thu, 15 May 2025 00:00:00 +0000

In this stream, Chris walks through building a GitHub CLI extension in Go from scratch, taking a spec-driven and test-driven development approach powered by Copilot Agent Mode.

Topics Covered

GitHub Changelog Review — Model updates in GitHub Models (Mistral, Cohere, Llama), GPT-4.1 as the new default Copilot model, updated rate limits for unauthenticated requests, and the VS Code April release with MCP support and prompt files
Microsoft Build Preview — A look ahead at sessions and events for the following week
Building gh-demo from Scratch — Bootstrapping a new Go-based GitHub CLI extension using VS Code’s new workspace creation with Copilot, the Cobra library, and a spec-driven approach starting from a product requirements document
Test-Driven Development with Copilot — Writing tests first for a hydrate subcommand that reads JSON files to create GitHub issues, discussions, and pull requests, with content type filtering and label collection
GitHub Actions CI — Creating a build, test, and lint workflow for the new CLI extension
Custom Instructions — Setting up a copilot-instructions.md file to guide Copilot’s behavior around path handling and project conventions

Rubber Duck Thursdays - Building with Agent Mode and MCP

Thu, 17 Apr 2025 00:00:00 +0000

An especially announcement-heavy week focused on new AI model availability across GitHub Copilot and GitHub Models, plus hands-on experiments with those models in agent mode and GitHub Actions workflows.

The extensive changelog review covers GPT-4.1 rolling out to all Copilot plans, Gemini 2.5 Pro entering public preview, O3 and O4 mini availability, Meta Llama 4 Scout and Maverick models in GitHub Models, macOS 15 and Windows 2025 GA for Actions runners, Windows ARM64 hosted runners in preview, expanded vision support beyond GPT-4o to Claude and Gemini models, CodeQL 2.21.0 with TypeScript 5.8 support, Copilot Chat for Eclipse GA, secret scanning pattern expansions, and the new Codespaces agent mode button on pull requests.

Rubber Duck Thursdays - Building with Agent Mode and MCP

Thu, 10 Apr 2025 00:00:00 +0000

A big announcements week — this episode unpacks Copilot Agent Mode going stable in VS Code and the launch of the official GitHub MCP server, then puts both to work building a real app from scratch.

The GitHub Changelog segment covers the VS Code Copilot March release (agent mode GA, MCP support, next edit suggestions), the GitHub MCP server launch, Copilot Pro Plus tier, Copilot Code Review GA, security campaigns GA with automated issue creation, GitHub Issues and Projects improvements (sub-issues, issue types, 50K item limit), Helm support for Dependabot version updates, and more.

Rubber Duck Thursdays - Lizard, Spock

Thu, 27 Feb 2025 00:00:00 +0000

In this episode, the team extends the Rock Paper Scissors game to include Lizard and Spock using GitHub Copilot Vision — feeding an image of the game’s relationship diagram directly into Copilot, which interprets it and generates the extended game logic without explicitly naming the game. The stream also adds a hidden flag for the extended mode, demonstrating prompt engineering with Copilot’s multimodal capabilities.

The GitHub changelog review covers Copilot autofix expansion for CodeQL alerts, Claude 3.7 Sonnet availability in Copilot, Docker Compose support in Dependabot, Copilot code review in public preview, and Copilot in Windows Terminal Canary. The latter portion demonstrates Dependabot version updates configured for Go modules and GitHub Actions ecosystems, with a live review of a dependency update pull request. A GitHub Codespaces session is used to verify the gh-skyline CLI extension still works after a dependency bump, and repository settings for auto-deleting branches and auto-merging pull requests are configured.

Rubber Duck Thursdays - Rock, Paper, Scissors

Thu, 20 Feb 2025 00:00:00 +0000

In this episode, I add a Rock Paper Scissors game to the gh-game GitHub CLI extension. The stream begins with a comprehensive GitHub changelog review covering the new GPT-4o Copilot code completion model, Copilot availability in Eclipse and Xcode, repository ruleset enhancements, secret scanning improvements, Copilot Workspace updates, and GitHub Issues and Projects feature updates.

The coding session uses GitHub Copilot Agent Mode to build the Rock Paper Scissors game in Go, taking advantage of Next Edit Suggestions and the new GPT-4o code completion model. A significant portion of the stream focuses on improving test coverage using Copilot’s inline chat in the terminal, progressing from 42.6% to 100% statement coverage by generating targeted test cases for uncovered functions. The episode also covers merging the Tic Tac Toe pull request from the previous week and shipping a new release of the CLI extension.

Rubber Duck Thursdays - Tic, Tac, Toe

Thu, 13 Feb 2025 00:00:00 +0000

In this episode, the team continues building the gh-game GitHub CLI extension by adding a Tic Tac Toe game written in Go. The stream kicks off with a demo of GitHub Spark, a GitHub Next experiment for creating micro apps from natural language prompts, followed by a walkthrough of the latest GitHub changelog updates including Gemini 2.0 Flash availability, Copilot Vision, and Agent Mode in VS Code Insiders.

The main coding session uses GitHub Copilot Agent Mode, Copilot Chat, and Copilot Edits to scaffold and iterate on the Tic Tac Toe implementation. Along the way, CodeQL code scanning is enabled on the repository, catching issues with missing workflow permissions and unpinned GitHub Actions versions. The episode also covers the CI/CD pipeline setup with build and test steps in GitHub Actions, and improving code readability through Copilot-assisted refactoring.

Rubber Duck Thursdays - GitHub Skyline

Thu, 23 Jan 2025 00:00:00 +0000

In this inaugural Rubber Duck Thursdays episode, Chris introduces GitHub Skyline — a GitHub CLI extension written in Go that generates 3D STL models and ASCII art visualizations of your GitHub contribution history. The stream demonstrates the gh skyline command, including the --full flag for rendering your entire contribution history across all years as a single 3D model suitable for 3D printing.

The main coding activity focuses on refactoring the Skyline Go codebase using GitHub Copilot. Chris uses Copilot Chat for rubber ducking on code structure, then leverages Copilot Edits to split a monolithic main.go into modular components — separating the root command, browser interface, GitHub client, and skyline generation logic into individual files. The stream also covers GitHub Codespaces and dev containers for setting up a consistent development environment, and discusses community files like CODE_OF_CONDUCT, CONTRIBUTING, and LICENSE for open source projects.

Build Conway's Game of Life with GitHub Copilot Free

Mon, 16 Dec 2024 00:00:00 +0000

This is a demo video showing GitHub Copilot in an end-to-end scenario, by building Conway’s Game of Life. The video covers the following specific topics:

Selecting the Claude Sonnet 3.5 model in the GitHub Copilot Chat model picker in Visual Studio Code
Writing specific, clear prompts: requesting a single-file implementation with a responsive layout and configurable cell size
Tips on effective prompt engineering: keeping prompts simple and specific to reduce ambiguous output
Reviewing generated code before inserting it, then customising the colour scheme to match the GitHub contribution graph
Using the “Apply in Editor” button with speculative decoding to apply targeted diffs across an existing file
Refactoring from a single HTML/CSS/JS file to separate files using Copilot Edits for multi-file changes
Reviewing multi-file diffs in the Copilot Edits view and accepting changes per file
Using drag-and-drop to add files as context to Copilot Chat and Copilot Edits sessions
Improving readability with Copilot Edits: grouping variables, adding a new class, and nesting methods
Using a Copilot instructions file to enforce team coding standards (HTML5 meta tags, JSDoc comments) in subsequent edits
Inline chat slash commands: /doc to generate documentation for a function and /explain to learn about an unfamiliar concept (torus topology)
Using Copilot Extensions to integrate Copilot’s natural language interface with external tools and services
Generating a project README with Copilot Edits, summarising the app, implementation, and contribution guidelines
Writing a GitHub Actions deployment workflow to publish the static site to GitHub Pages
Using Copilot to suggest a commit message, committing, pushing, and verifying the live GitHub Pages deployment

GitHub Copilot Chat and o1-preview: Building a maze generator!

Thu, 03 Oct 2024 00:00:00 +0000

This is a demo video showcasing GitHub Copilot and o1-preview. The video covers the following specific topics:

Accessing the model picker in GitHub Copilot Chat within Visual Studio Code (GPT-4o, o1 mini, o1 preview)
Writing a specific, multi-requirement prompt for o1-preview: a JavaScript maze generator with keyboard navigation, variable maze sizing, and a maze-solve button
Understanding o1-preview’s extended internal reasoning, which produces longer response times but handles complex requirements more reliably
Reviewing the generated code and copying it into the VS Code editor; initial iteration produces a working maze with BFS and DFS visualisation
Iterating with a follow-up prompt to enhance the solution path display (black dot trail, no-path notification)
Testing edge cases with a 50×50 maze and a distant starting position to observe depth-first search behaviour visually
Comparing o1-preview output quality against the expectation for GPT-4o on the same multi-constraint task

ToolUp Days #15

Fri, 21 Oct 2022 00:00:00 +0000

ToolUp Days is all about showing the thought process and decisions made when creating an application from scratch. Episode 15 continues the Codespaces-based development workflow from the previous session, validating the Dapr + Codespaces secrets pattern end-to-end and extending local debugging to a second microservice — before landing in a genuinely puzzling .NET minimal API routing problem.

Quick Context

The episode opens with conference highlights from South Coast Summit and some quick hiring news before getting into the technical work.

ToolUp Days #14

Fri, 07 Oct 2022 00:00:00 +0000

ToolUp Days is all about showing the thought process and decisions made when creating an application from scratch. In this episode, Chris and Matt tackle the messy reality of developer environment drift — different machines, multiple WSL variants, forgotten installs — and make the case for a Codespaces-first workflow backed by a declarative dev container.

The Problem: Environment Drift

After several sessions where progress stalled because neither host could reproduce their earlier setup, the team decides to invest time in a reproducible development environment. Chris has also recently migrated the project’s Azure resources to a new tenant, which becomes an unexpected validation of the earlier OpenID Connect and GitHub Actions work: apart from updating a single OIDC connection, the entire deployment pipeline continued working across a new subscription and tenant.

ToolUp Days #11

Tue, 23 Aug 2022 00:00:00 +0000

This episode marks the official rebrand from ToolUp Tuesday to ToolUp Days — giving Chris and Matt the scheduling flexibility they need to maintain a consistent cadence. After recapping progress (multiple microservices built, GitHub Actions CI/CD in place, container images published, and Infrastructure as Code deployed), the pair set a concrete goal: reach a point where two players can independently make a decision, a “tick” happens, and there is a winner and a loser.

GitHub - More than just a Git repository

Tue, 07 Jun 2022 00:00:00 +0000

Microsoft Build 2022

Wed, 25 May 2022 00:00:00 +0000

Interfaces in Go

Mon, 16 May 2022 00:00:00 +0000

In this post, I’ll be talking about how to use interfaces in Go. This is a continuation of my learning using the Go language. I’ll use interfaces to create an application that interacts with several types of bank accounts.

What is an interface?

Let’s start with defining the concept of an interface. An interface is a set of methods that a type must implement.

In essence, this is a contract that a concrete type must implement. This can be useful when you want to loosely couple your software, so that you’re not depending on a specific implementation (and can then future-proof yourself).

ToolUp Tuesday - #6

Tue, 03 May 2022 00:00:00 +0000

Chris and Matt bring their game application components together in this ToolUp Tuesday session. They start by reviewing the existing services — the Go-based player decisions API and the .NET world event engine — and identify that the player state service may be redundant now that Dapr handles state management. After clarifying their data model through use case documentation in Markdown, they define the game loop: players enroll, world events fire on a tick schedule, players submit decisions, and the engine reconciles state. The bulk of the session focuses on integrating Dapr’s state management API into the .NET player state service, implementing save, get, and delete state operations backed by Azure Table Storage. They also tackle VS Code debugging configuration, setting up launch.json and tasks.json for multi-service debugging with Dapr sidecars. The session ends with inter-service communication via Dapr working, setting up the next episode for cross-service calls between Go and .NET.

Go Pointers - Using the & and * operators

Sun, 01 May 2022 00:00:00 +0000

I’ll be transparent. The purpose of this post is to help with my own understanding of the Go & and * operators. It’s going to be a very short post, and I’m going to try to explain the concepts in a way that I can understand. I’ve used these operators in C previously, but whenever I’m using them - I always end up having to remember the syntax / which operator is which / what they do. For whatever reason, it doesn’t always come intuitively to me.

Set up your Go development environment with Visual Studio Code and Windows Subsystem for Linux (WSL)

Tue, 26 Apr 2022 00:00:00 +0000

Over the past few weeks, I have been working on a new set of pet projects. I’ve wanted to learn Go for a while, so I thought this could be a great opportunity to get hands on and try it out. It’s fair to say that my development environment was ‘functional’, but I wanted to revisit it to make sure that I could get the best out of it. In this blog post, I’m going to walkthrough the process of setting up Go on my machine, and then the experience of using Visual Studio Code and Windows Subsystem for Linux (WSL) with Ubuntu.

ToolUp Tuesday - #5

Thu, 21 Apr 2022 00:00:00 +0000

Chris and Matt return for ToolUp Thursday (a scheduling exception) to refactor their Go player decisions API. Having separately studied Golang between sessions, they revisit the codebase with fresh eyes and immediately identify structural improvements — breaking a monolithic single-file approach into proper Go packages with separate folders for controllers, models, and routes. They compare two popular Go HTTP frameworks, Gorilla Mux and Gin, discussing trade-offs between simplicity and feature richness. Matt demonstrates his own Go project using Mux with Azure Container Apps, showcasing Go interfaces, dependency injection patterns, and the tenant service architecture. The conversation covers Go pointers, reference semantics, struct composition, and how Go’s implicit interface implementation differs from C# and .NET. They also explore unit testing and mocking challenges in Go, noting the ecosystem differences from .NET’s more integrated testing story. The session ends with planning to integrate a file-based data store and start connecting the player decisions API with the world event engine.

ToolUp Tuesday - #4

Tue, 05 Apr 2022 00:00:00 +0000

Chris and Matt take on Go (Golang) for the first time on the ToolUp Tuesday live stream, building a player decisions REST API for their game application. They start with a recap of Go fundamentals — variables, types, structs, and pointers — before diving into HTTP routing with the Gin framework. The pair discuss Go project structure, comparing it to their .NET and C# backgrounds, and explore how Go handles packages, imports, and the module system. They work through setting up controllers, route handlers, and in-memory data structures, frequently mapping Go concepts back to familiar object-oriented patterns. Along the way, they troubleshoot Go environment issues including version upgrades and GOPATH configuration. The session wraps with a working REST endpoint for player decisions, setting the stage for integrating state stores in future episodes.

GitHub - More than a Git repo

Wed, 09 Mar 2022 00:00:00 +0000

ToolUp Tuesday #2

Tue, 22 Feb 2022 00:00:00 +0000

Chris and Matt move from planning to coding, creating the Player State API as a .NET Web API project. They define data models representing player state for the SpaceBar management sim, debating how deep and detailed the models should go. The episode covers practical .NET development decisions, including the trade-offs between minimal API patterns and traditional controller-based approaches, with a preference for controllers for better logical grouping.

The pair also set up their first GitHub Actions CI workflow, walking through YAML syntax for building the .NET project on push to main. They troubleshoot the workflow live — discovering they forgot the checkout step — and iterate until the build succeeds. GitHub Copilot makes a brief appearance as a code suggestion tool during API scaffolding.

Using RegEx and VSCode's Find/Replace capability to add captions to markdown images

Sat, 05 Feb 2022 00:00:00 +0000

If there’s an easy way to achieve something, then I’m all for it! You may have noticed that I’ve been putting a lot of effort into refactoring my site and open sourcing the original Cloud With Chris theme. I’ve now released that as the Hugo Creator theme for Hugo. As part of the refactoring process into a reusable theme, I had to make several breaking changes. This meant that I’d need to update the contents of my site. I want to share a quick tip that I discovered to add captions to my images in Markdown.

Static Web Apps in Azure | DEVREAL.io

Wed, 09 Jun 2021 00:00:00 +0000

Cloud Lunch and Learn Marathon 2021 - How GitHub Actions can help in building and deploying a static site and more

Thu, 13 May 2021 00:00:00 +0000

#LeedsAzure - vMeetup #9 - How GitHub Actions can help in building and deploying a static site and more

Wed, 21 Apr 2021 00:00:00 +0000

Cloud Drops - Introduction to GitHub Codespaces

Tue, 16 Mar 2021 00:00:00 +0000

Have you ever had to setup a development environment from scratch? You have to install a ton of dependencies, probably a few tools along the way as well. It’s not fun, it takes a lot of time and it prevents you from being productive. This is where GitHub Codespaces comes in.

GitHub Codespaces, Visual Studio Code and Remote Containers

Fri, 08 Jan 2021 15:30:00 +0000

Setting up a development environment—installing the right SDK versions, extensions, and tools—wastes hours and creates ‘works on my machine’ problems. VS Code Remote Containers and GitHub Codespaces solve this with containerised, reproducible dev environments.

What You’ll Learn

How the VS Code Remote Containers extension connects your local editor to a Docker container running a full development environment
The role of devcontainer.json as a manifest defining your development container’s configuration, extensions, and port forwarding
How to bootstrap a .NET Core dev container using the microsoft/vscode-dev-containers repository samples
The difference between Remote Containers (local Docker) and GitHub Codespaces (cloud-hosted containers accessible from a browser)
Using the GitHub Codespaces VS Code extension to connect your local IDE to a cloud-hosted Codespace
The dotfiles convention: GitHub Codespaces automatically applies your ~username/dotfiles repository to personalise every Codespace with your aliases, shell configuration, and shortcuts
Live demo: editing, previewing, and committing changes to cloudwithchris.com (Hugo static site) entirely within a GitHub Codespace

Developer Experience Impact

GitHub Codespaces eliminates onboarding friction—any developer with browser access can contribute to a project within minutes, with a pre-configured environment including the correct language runtime, VS Code extensions, and tooling. No local setup required.