The MVP program has been a huge part of my life and I credit it with having the greatest impact on my career. It opened doors, it enabled conversations, it taught me so much, and it introduced me to some amazing people. It’s been an absolute blast, and I feel very lucky to have been a part of it.

But 10 years is a long time. Many things have changed and both the MVP program and me are different to what we were a decade ago. That’s not a bad thing or a good thing, but it is a truth.

Over the past 6 months or so, I’ve decided that I need a new challenge. I tend to thrive on the exploration, understanding and application of new ideas, new technologies, new ways of doing things. Sometimes, the comfy chair can become a little too comfy. It’s time for me to throw myself into something I don’t know as well.

I’m staying in the communications world but I’m broadening out from just Microsoft UC. It’s no secret that the company that I work for now – CloudInteract – are an AWS partner. I’ve been spending time understanding their CCaaS platform, Amazon Connect, and so that’s where you can expect me to be concentrating my efforts moving forward. 

I’ll still be blogging and I’ll still be on LinkedIn. My blog has never just been about Microsoft technology – very long time readers will recall it started off being about nANT and CruiseControl – instead it tends to follow my interests. All the existing content remains, for free, and will do for as long as I’m in charge of it.

There’s another reason that I feel comfortable making this jump. When I first started blogging and speaking about developing solutions on Microsoft UC (at the time it was Office Communicator, then Microsoft Lync), I was the ONLY developer at a conference of IT Pros. In fact, apart from my manager (shout out to Paul Nearney who got me started on my MVP journey) I only knew of one other person building UC-based solutions – Michael Greenlee who had, quite literally, written the book on the subject.

Today, the community is rich with developers, both low and pro code, bringing their talents and experiences to help people build solutions. With such great talent I don’t feel at all bad about stepping away, and it’s a testament to the community that I feel reassured that should I ever decide to return in the future I will find a kind and supportive environment waiting for me. I know this because I’ve seen first hand how the Microsoft 365 MVP community welcomes new members and treats everyone with respect and love. It really is one of the best communities in tech, and I feel very proud that I played my own small part in building that.

There are so many people I would like to say thank you to, and I’ve done my best over the past few weeks to do so in person where I can. I’m resisting trying to make a list, as invariably I will miss someone out. But I do want to reserve a special mention for my wife Emma, for the support you’ve given me over the last 11 years. Being an MVP means yielding to an over-achiever type desire to perform, which takes time away from other things, and I’m very grateful for the countless evenings and weekends you’ve given me as I’ve selfishly chosen to spend time blogging, filming or travelling. I can’t promise it’s going to end, but hey, it might at least be different! xx

It’s a classic cliche, often said when changing jobs, but it’s the people that I will miss the most. Realistically, I know that I will probably drift apart from many of you, but there are also some firm friendships that have developed over the years that I hope will continue. You know where I am, I’ll still be on LinkedIn – if you ever need anything from me, please ask.

I understand if you want to use this announcement as a reason to stop following my content, as it’s clearly going to be less Microsoft-focused going forward. But, if you’re in the UC or CCaaS world, if you’re into technology or are curious, sometimes considering alternative ways of doing things, alternative technologies and approaches, can make you a more rounded individual. The technology world is small and, particularly amongst the big firms, there is a lot of movement of talent. This is just another one of those – no biggie

I’ll be taking a social media break over Easter, and I’ll be back after that with a new focus. It’s a new chapter, and I’m excited. The way that AI is impacting contact centres right now is massive and I have a long list of things I want to talk about!

PS – I had been thinking about how to structure this post for a few days, and was killing time in an airport lounge procrastinating instead of writing a draft when I read something from Microsoft employee and ex-MVP Fabian Willians, someone that I really respect as a technology visionary, and it really resonated with me in that moment. “Qui non proficit deficit“ – thanks Fabs, that’s exactly what I needed to hear.

Handling Legacy User Settings in SharePoint Framework

M365 Copilot and the case of the broken license

Is the craft dead?

You can also listen to the audio-only version: Thoughtstuff Podcast – Tom Morgan on Teams Dev: Weekly Update 16 February 2026.

Find all my videos at thoughtstuff.co.uk/videos. You can also subscribe to the audio-only version of these videos, either via iTunes, Spotify or your own podcasting tool.

Transcript (AI-Generated)

Hello and welcome to another weekly update. I hope you’re doing well.

Okay, I take it back what I said a couple of weeks ago about the pace of change of news being back to normal for Microsoft 365. It has been another really quiet week and I think this is interesting – maybe even a little concerning. There’s really been very little posted to the usual places: developer blogs and other Microsoft 365 channels.

I don’t really know why this is. I can speculate – it’s probably a mixture of a few things. One: fewer people may be working at Microsoft now and that’s impacting marketing and developer advocacy. Two: those who remain may be busy working on exciting things, so they don’t have time to post blog updates. Or maybe there’s just genuinely less happening, possibly due to enhanced focus on Copilot core development, which might mean fewer changes on the extensibility layer – where I typically focus.

Whatever the reason, there’s definitely a noticeable change in the level of output. For lots of admins and devs, it may actually be welcome because the pace has been so fast recently.

Even with the slowdown, we’ve got a couple of things to talk about. Paolo Pialorsi, who I mentioned last week for his SharePoint Framework (SPFx) blog on user settings, has followed up with another one, this time discussing legacy user settings in SPFx. I’m not an expert in this area, but the post is really good. It goes through the legacy application model, the new model, and explains why the change matters. There are clear migration guidelines and well-written content – including sample code and a detailed table of contents.

To underscore the point about decreased activity, I checked the official Microsoft 365 Developer Blog – there’s been nothing posted since last week except Paolo’s article. This is unusual; a year ago we would easily have seen multiple posts weekly.

But this slowdown lets us feature other great community content. Loryan Strant, another Microsoft MVP, has a humorous piece titled “Copilot and the Case of the Broken License.” While I usually speak to developers, more developers are now being looked to as AI experts. Loryan’s post discusses edge cases in license management and Copilot behavior that can impact devs and admins alike. It’s worth reading simply because he’s already been through the pain and has useful insights to share.

Lastly, I want to highlight a short but potent blog from Scott Hanselman titled “Is the Craft Dead?” It dives into the existential debate about software development in the age of AI. Scott has been in development for over 35 years, and his thoughts are worth considering. His answer: No, development isn’t dead – but it’s also not unaffected.

If you want my opinion: if you’re a developer and haven’t used AI to make your dev work better or faster, that’s probably a missed opportunity. And if you think your job will vanish because AI can code – that’s not right either. If you don’t believe you bring additional value over what AI can generate, maybe it’s time to improve your skills. Most developers, I think, will find that they can combine their strengths with AI to be even more valuable – whether that’s enhancing AI-generated solutions, ensuring compliance with internal systems, or simply maintaining and improving codebases headed for production.

There’s more and more code, which means we need more and more people who truly understand it.

That’s it from me this week. Let’s see what next week brings. Keep an eye on the news cycle – it could be a temporary lull, or something deeper. I don’t want to overreact or guess at motives. All I can do is point out the change I’ve noticed in publication frequency.

Thanks for watching — have a great week!

Deprecation notice: Teams Live Events meeting creation via Microsoft Graph

Mastering User Settings in SharePoint Framework

Navigating Microsoft Teams Docs: A Developer Survival Guide

You can also listen to the audio-only podcast: Thoughtstuff Podcast – Tom Morgan on Teams Dev: Weekly Update 9 February 2026

Find all my videos at thoughtstuff.co.uk/videos. You can also subscribe to the audio-only version of these videos, either via iTunes, Spotify or your own podcasting tool.

Transcript (AI-Generated)

Hello and welcome to another weekly update. I hope you’re doing well and had a great week. A couple of things to talk through this time.

Microsoft Graph Deprecation: Live Events

I’m going to spend some time on this first item. It’s a deprecation notice about creating Microsoft Teams Live Events meetings via Microsoft Graph. This functionality has been around for a few years — enabling the creation of live meetings through the API. However, it’s changing because Live Events are being retired in favor of virtual events.

Specifically, the isBroadcast property used when creating an online meeting is being deprecated. Going forward, setting this property to true won’t be allowed. Instead, users should look to use webinars or town halls, both of which now have API support.

On the surface, this change seems manageable. But my concern is about the short window in which this update is occurring. Microsoft announced this change via a blog post on February 3rd. The beta endpoint will stop supporting the property at the end of March — which is fair given beta is inherently unstable. But more concerning is that the V1 endpoint will see the same change by the end of June — just five months later, and only three months after the beta cut-off.

This feels very short notice considering v1 APIs are supposed to be stable. There are clauses in the terms that mention a two-year window for changes — something we’ve not seen honored consistently. While Microsoft likely has the telemetry to understand usage patterns, from a developer perspective, this kind of short-notice change is disruptive, especially when running production services or software that depends on it.

Storing User Settings via Microsoft Graph

On a more positive note, Paolo Pialorsi — an ex-MVP now at Microsoft — has written an excellent blog post on mastering user settings in the SharePoint Framework (SPFX).

He proposes an approach that makes use of Microsoft Graph and OneDrive for Business to persist application-specific settings per user. This was new to me — I would typically have reached for my own data store or a configuration file. But for SPFX or Teams-based solutions, storing this in app-specific folders via Graph is elegant and scalable.

Every user gets an app-specific folder structure as part of their OneDrive, and app developers can use this space to write and retrieve settings. It also ensures per-application isolation, aligns well with Azure AD registered applications, and behaves much like managing settings on local drives.

Paolo’s post walks through the exact steps to implement this setup, how to handle permissions, and how to structure and retrieve settings. The approach is robust and applicable beyond SPFX — definitely worth a read if you’re building anything accessing Microsoft Graph.

Navigating Teams Documentation: A Developer’s Survival Guide

Lastly, a pick that made me smile — Andrew Connell’s blog post titled “Navigating Microsoft Teams Docs: A Developer Survival Guide.”

He discusses the various challenges developers face finding accurate information in Microsoft documentation. While everything is somewhere in the docs — finding it can feel like an archaeological dig. You almost need to know the age of the Teams feature to figure out where to start looking.

He highlights problems like outdated recommendations, overlapping SDKs, and fragmented documentation across platforms — with some hosted on Learn, others as GitHub entries or blog posts.

Andrew lays out the issues clearly and provides useful strategies for navigating the mess. It’s a good reminder that this struggle is shared and that there are ways to get better at coping with it — trial, error, and experience go a long way in building your own toolkit for success.

That’s it from me this week. Whatever you’re working on — have a great week, and I’ll speak to you again next time.

SharePoint Framework (SPFx) roadmap update – January 2026

Introducing the Microsoft Graph User Configuration API (preview)

Apps for shared and private channels

Dev Proxy v2.1 with configuration hot reload and stdio proxying

You can also listen to the audio-only podcast version: Thoughtstuff Podcast – Tom Morgan on Teams Dev: Weekly Update 2 February 2026.

Find all my videos at thoughtstuff.co.uk/videos. You can also subscribe to the audio-only version of these videos, either via iTunes, Spotify or your own podcasting tool.

Transcript (AI-Generated)

Hello and welcome to another weekly update. I hope you’re doing well. A couple more things to talk about this week.

It might be that the Microsoft engine is finally getting off the ground – just a slow start. It does seem a bit slower than usual, but we’re returning to a more normal cadence of posting. It’s nice to start seeing posts appear consistently in the places you’d expect them.

First up, on the Microsoft 365 Developer Blog, there’s an update to the SharePoint Framework (SPFx) courtesy of a blog post from Vesa Juvonen. It’s similar to last month’s update, but focused on January delivery. The standout for me is how the team actually delivered what they said they would. That consistency gives me confidence, not just in the team, but for everyone relying on SPFx. There’s evidence of ongoing investment and momentum behind the technology.

The main point of the January update is the new debug toolbar, which the December roadmap said would be delivered. It’s now part of the January blog post, confirming that work has been completed. The roadmap itself hasn’t significantly changed—so everything seems to be on track.

This kind of transparency isn’t for pointing fingers if delays happen, it’s really about communication. And Microsoft is showing they’re still committed to SPFx and haven’t moved on from it. The team is clearly funded and supported. Overall, that’s a really positive outcome.

Now, another interesting development – Microsoft Graph has new beta endpoints for user configuration, specifically focused on Exchange Online items. This effort is clearly part of the transition away from Exchange Web Access (EWA), which has been prolonged. Despite initial plans, Microsoft is now firm about deprecating it, even setting a hard stop date and warning tenants accordingly.

One difficulty with transitioning off EWA was that Graph didn’t previously offer comparable functionality. That gap made it impossible for developers to switch over. These new APIs aim to fix that. The Microsoft Graph userConfiguration API (in beta for now) allows storing configuration data per mail folder, which includes read, write, update, and delete operations.

It’s meant to do what it says: store metadata alongside mailbox context. I haven’t used it yet, but it looks like a straightforward CRUD interface. For those holding off migration due to missing features, this could be the green light you were waiting on. Yes, it’s in beta, but I expect a speedy general availability (GA) rollout to match the EWA deprecation deadline. If you try it and run into issues—report them. Microsoft wants feedback since this directly affects the deprecation timeline.

Moving on – another important update in Microsoft Teams: support for apps in shared and private channels. This has long been a pain point. For a while, apps were only supported in public and group scopes, but Microsoft has been closing those feature gaps. As of now, apps in shared channels are GA. Apps in private channels are in public developer preview—a big step forward!

There are still a few gotchas outlined in the updated blog post, so take the time to read through the capability matrix. Pay special attention to any highlighted limitations, especially if you’re building complex scenarios.

Lastly, Dev Proxy is reaching new heights with version 2.1.0. Quality-of-life improvements like configuration hot reload are great, but the headliner is STDIO proxying—that’s standard input/output. This means Dev Proxy can be used with MCP servers too, not just web traffic. It greatly expands its usefulness, especially as many developers shift towards MCP-based infrastructure.

The release includes the ability to wrap executables with the proxy and surface traffic in the network tab. You can also run multiple Dev Proxy instances and configure different ports. These updates demonstrate that the Dev Proxy team is being proactive, keeping the tool relevant and highly useful for developers. High marks all around.

That’s all from me this week. Have a great week ahead, and I’ll catch you next time!

Microsoft Agent Framework: Using Background Responses to Create an AI Researcher and Newsletter Publisher

Empowering.Cloud Community Update – January 2026

Build an agent into any app with the GitHub Copilot SDK

Announcing winapp, the Windows App Development CLI

You can also listen to the audio-only version: Thoughtstuff Podcast – Tom Morgan on Teams Dev: Weekly Update 26 January 2026.

Find all my videos at thoughtstuff.co.uk/videos. You can also subscribe to the audio-only version of these videos, either via iTunes, Spotify or your own podcasting tool.

Transcript (AI-Generated)

Hello and welcome to another weekly update. I hope you’re doing well and had a good week.

A few interesting things to talk through this week. I still think something is going on with the Microsoft 365 developer blog in terms of its cadence. I’ve mentioned this before, and what seemed like a slow post-Christmas period continues. It could be staffing changes, deprioritization, or just a genuine lack of news. Either way, there are still fascinating developments happening elsewhere.

The first is a blog from fellow MVP Jamie Maguire about the Microsoft Agent Framework. He walks through how to use background responses with the framework—essentially letting an agent go off, do some work, and then come back asynchronously. Jamie’s example? Building an AI researcher and newsletter publisher. It’s an excellent application of long-running agent workflows using polling and background execution. He includes the full setup in his blog post, and I’d love to see this content presented at a talk in future.

Next, a quick mention of a video I recorded last year with Sean Keegan, a developer evangelist from Microsoft focusing on Azure Communication Services. We talked about communication APIs, Microsoft Teams integration, and building AI-powered voice solutions. It’s available now on Empowering.Cloud, and we went deep into helping developers understand the current state and exciting future of AI-first voice interaction.

Another area I’ve blogged about is the GitHub Copilot CLI. It’s Copilot for the command line—helping you interact with code without needing to be in a specific IDE. I use it mostly for less critical projects—where I don’t need to scrutinize every line but still want structure in my development. Even more interesting is the recent SDK release, which lets you bring CLI-level code generation and reasoning into your own apps or workflows. It’s in technical preview, and there’s a blog post on GitHub detailing how you can start using it.

If you’re already using the CLI manually and find you’re repeating the same workflows, the SDK could be the next step. I think it’s a great move in the space of automating repetitive coding with intelligent agents.

We’re at an interesting inflection point where AI tools are starting to differentiate by modality. Some tools are becoming better at code, others at images—and we’re starting to see people settle into stacks and preferences. This is good—it helps establish consistent benchmarks in an otherwise chaotic space.

Lastly, I want to discuss WinApp—a new CLI from the Windows app dev team. While it might not generate sensational news, it’s important. It’s a unified CLI to scaffold, package, and build native Windows applications—whether Electron-based, .NET, Rust, or others. Why is that exciting? Because AI agents work best with CLIs. Imagine using large language models to build Windows apps without needing prior platform knowledge. This CLI could enable that by abstracting away complexity and giving toolchains AI-friendly interfaces.

I’ll be watching to see how this develops, and whether it encourages more app creation for Windows. At the very least, it shows the team is laying smart foundations for AI involvement in app development.

That’s everything from me this week. Aside from the slow Microsoft 365 news cycle, there’s still lots to explore. I’m going to dig through past update notes to see if January is usually this calm. I’ll let you know what I find.

Have a great week whatever you’re working on, and I’ll talk to you again soon.

Copilot Memories

Copilot Studio Extension for Visual Studio Code Is Now Generally Available

Announcing Open to Work: How to Get Ahead in the Age of AI

Microsoft AI Power Days

You can also listen to the audio-only version: Thoughtstuff Podcast – Tom Morgan on Teams Dev: Weekly Update 19 January 2026.

Find all my videos at thoughtstuff.co.uk/videos. You can also subscribe to the audio-only version of these videos, either via iTunes, Spotify or your own podcasting tool.

Transcript (AI-Generated)

Hello and welcome to another weekly update. Oh, there we go. That’s what I meant to do. I hope you’re well.

It’s been a couple of weeks. We did one last week, but there wasn’t much to talk about. This week, there’s more to cover—though not loads. It’s kind of surprising and not what I expected, but that’s okay. We’ll get through it. There are some interesting developments happening.

Copilot Memory in Visual Studio

The first thing I want to talk about is Copilot Memory, now coming to Visual Studio. This is documented on the Visual Studio blog by Jessie Houghton. It addresses a familiar pain point—constantly re-entering system prompts like coding standards or commit message formats. What you really want is Copilot to remember some of that context.

For example, when we commit to Git, if it’s tied to a specific bug or task, we start with a code. That helps track changes later—but it’s easy to forget. Copilot now has a memory feature where instructions can be stored in a file called copilot-instructions.mmd. This file can exist at the user profile or the repo level, and Copilot merges it in to remember preferences.

While it’s not exactly an AI memory in the fullest sense, it’s a powerful extension of prompt augmentation. From enforcing consistent commit messages to defining code generation behaviors and explaining business logic—this feature can be incredibly helpful when used smartly.

Copilot Studio in Visual Studio Code

Another exciting update is a Visual Studio Code extension for working with Copilot Studio. If you’re a pro-level developer who prefers code to UI, this is for you. It brings a full code-first development experience to Copilot Studio projects, letting you work on topics, workflows, triggers, and agent information—all from within VS Code.

This integration is fantastic because it allows for full Git and GitHub workflow compatibility, including source control, versioning, and builds. Whether you’re productionizing a prototype or extending functionality, it’s now easier to Govern, secure, and audit your AI agents in enterprise settings with Copilot Studio.

Book Alert – Open to Work

LinkedIn has a new book coming out titled Open to Work, co-authored by CEO Ryan Roslansky and Chief Economic Opportunity Officer Aneesh Raman. It’s about adapting how we work in the age of AI. While it may not deliver groundbreaking new insights, it’s still worthwhile; especially coming from two of LinkedIn’s top executives. It’s available for pre-order now, with a release date of March 31st.

Microsoft AI Power Days

Microsoft is also running a series of AI Power Days: three-day online events aimed at enabling business leaders to build frontier firms for the agentic AI era. It’s likely to feature a lot of Ignite-level content and resources from Azure, Microsoft 365, Foundry, Windows 365 and more.

You don’t have to commit to the full three days; sessions are modular and must be registered for individually. This makes you think more intentionally about what you want to attend. Most times seem friendly for UK and Europe-based folks, but you can likely watch recordings after the fact. Day three appears more hands-on, and there’s even a data center tour to look forward to.

All right, that’s all from me. Have a great week, whatever you’re working on. I’ll speak to you again next week.

Where are all the news stories?! (A discussion about a quiet start to 2026)

How to build the organizational muscle needed to scale AI beyond PoCs

Microsoft and PayPal’s Copilot Checkout allows users to make purchases without leaving the AI chatbot

You can also listen to the audio-only version: Thoughtstuff Podcast – Tom Morgan on Teams Dev: Weekly Update 12 January 2026.

Find all my videos at thoughtstuff.co.uk/videos. You can also subscribe to the audio-only version of these videos, either via iTunes, Spotify or your own podcasting tool.

Transcript (AI-Generated)

Hello and welcome to another weekly update. I hope you’re doing well. Welcome to 2026 – this is the first one of the new year!

I didn’t do one last week, and I’ll explain why in a bit. I want to begin where I intended to start, and then take a slightly different path.

Developers Staying Busy Over The Holidays

The first blog post that caught my eye was from the Visual Studio team. It was their “Welcome to 2026” post, and what struck me was the tone. You’d think people slow down coming into Christmas, but according to their watch statistics—from sessions at VS Live Orlando—it looks like developers kept going strong. Lots of interest in learning Visual Studio, AI tools, and what’s coming in 2026.

The top six ranked sessions were deeply technical, not just overviews, which suggests developers are really leaning in and being intentional with their time. That mirrors what I felt too—no slowing down, just keeping up and catching up.

The blog’s main purpose was also to highlight upcoming in-person Visual Studio Live events in 2026, so check those out if you’re interested.

Radio Silence from Microsoft 365 Dev

I was surprised, however, when preparing this week’s update. I regularly go through a set of RSS feeds and key web pages related to Microsoft 365 dev, extensibility, and Co-pilot updates. Usually, there’s plenty to talk about, even if I step slightly outside the core M365 dev scope.

This time? Silence. Since mid-December, just before Christmas, there’s been almost nothing. RSS feeds were empty. That’s actually why I didn’t release an update last week.

I don’t think it’s because there’s nothing to do—far from it. My guess is a combination of internal changes, budget calendar impacts, or teams needing time to reboot communications after planning through to year-end. That said, I’ve done a bunch of Christmases now, and I don’t recall ever having a content drought quite this long into the new year.

Scaling AI Within Organizations – A ThoughtWorks Perspective

The quiet push me to look elsewhere, and I landed on a ThoughtWorks article: “How to build the organizational muscle needed to scale AI beyond POCs”. It’s exactly the right conversation a lot of us need to have.

If you’ve done any AI development, you know the pattern: you build a proof of concept, people are interested… and then things fizzle. This piece explores how to keep momentum—how to get organizations to internalize and embed AI into their workflows. It’s a comprehensive read, full of references, diagrams, and practical suggestions. Highly recommended.

Copilot Checkout with PayPal

Another headline I almost missed: Microsoft is working on “Copilot Checkout” via PayPal, now in public preview. This one flew under the radar—I found it on a Windows Central blog.

While details are sparse, it seems we’ll see native “buy buttons” inside the Copilot chat experience (probably the web-based version). It won’t make purchases for you, but it will present buying options and redirect to PayPal for completion.

What’s really intriguing is the potential for developer extensibility. Will this be open to ISVs, or limited to select partners? Will there be an equivalent for Microsoft 365 Copilot that also handles enterprise procurement use cases through internal workflows? Lots of possibilities if they get the model right.

And it ties back to the ThoughtWorks piece: shaping organizational adoption habits. Embedding purchasing flows into chat may help normalize AI-driven decisions and actions inside businesses too.

Wrapping Up

So, even in a relatively quiet week for Microsoft news, there are still valuable threads to pull—from developer learning trends, to organizational AI adoption, and the quiet beginnings of commerce integrations inside Copilot.

Let’s see what the next week brings. Have a good one—whatever you’re working on. I’ll see you again next week!

Copilot AI Insights (meeting recap) API is now generally available!

Get AI-generated meeting summaries with Meeting AI Insights API

Debugging, but Without the Drama (A Visual Studio 2026 Story)

You can also listen to the audio-only version: https://thoughtstuff.libsyn.com/weekly-update-22-december-2025

Find all my videos at thoughtstuff.co.uk/videos. You can also subscribe to the audio-only version of these videos, either via iTunes, Spotify or your own podcasting tool.

Transcript (AI-generated)

Hello and welcome to another weekly update. I hope you’re doing well. We’re in the final couple of weeks of the year. Not loads and loads of news flying around, but there are still some interesting things coming out — and from some unusual places. We’ll talk about that in a moment.

AI Context Provider for Microsoft Agents

First up, I want to highlight a blog post by fellow MVP Jamie Maguire. He’s been publishing a lot of high-quality content recently, especially on the pro-code side of building bots using the Microsoft Agent Framework.

This latest post is about using the AI Context Provider to give your bots contextual memory. It’s a follow-up to a demo he included in an earlier blog. Really useful stuff if you’re working with agent frameworks and want to let your bots remember what users tell them. All the code is included in the post, making it a fantastic resource.

This reminds me of when I was doing similar pro-code work, especially around UCMA. At the time, you had to document everything yourself or risk forgetting it entirely. It’s great that Jamie is putting this knowledge out there publicly.

CoPilot AI Insights API Goes GA

Microsoft’s Copilot AI Insights API (formerly known as the meeting recap API) has reached General Availability. This API gives you access to AI-generated summaries of meetings via API after those meetings have finished.

Now that it’s GA, it has better support, a longer life cycle, and more stability. Microsoft typically gives two years’ notice before deprecating GA endpoints, unlike beta ones which can disappear at any time and aren’t supported. This is a solid step forward.

Oddly, the announcement came in a GitHub Discussion instead of an official blog post. Maybe marketing will catch up in the new year.

Important to note: this API only works for users with a Microsoft 365 Copilot license and currently requires user-delegated permissions — not ideal for headless or large-scale implementations. We’ll need to see if that changes over time.

Also, there are limits: meeting summaries may take up to four hours post-meeting to become available. No real-time data here — developers will need to build around that delay, perhaps with polling logic.

Visual Studio 2026 Debugging Enhancements

Visual Studio 2026 is still on my radar, and a great blog post caught my attention. It’s a kind of narrative walkthrough — like a story — focusing on debugging without the drama. It highlights some genuinely helpful features like enhanced exception analysis, inline values, and better unit testing tools.

If you’re like me, your debugging techniques may be stuck in the past from when you first learned. Tools like conditional breakpoints were life-changing for me when they first came out. Every developer should know about them — but often, they don’t! This blog is a good reminder to revisit and update your knowledge.

Wrapping Up the Year

As the year ends, I’ve been reflecting on what a big twelve months it’s been for AI – particularly Copilot and its developer extensibility. Progress may have been slower than in early hype years, but it’s been steady, with important milestones reached. I’m looking forward to seeing what 2026 brings.

No weekly update from me next week – I’ll see you in the new year. Whatever you’re up to, have a great time. Merry Christmas if that’s your thing!

General Availability of SharePoint Framework 1.22 – A Major Refresh of the Build & Tooling Experience

SharePoint Framework v1.22: What’s in the Latest SPFx Update

Streamlining your Git workflow with Visual Studio 2026

How to: build a runner’s training and progress dashboard

How to install and configure Claude Code, step by step

You can also listen to the audio-only version of this podcast: Thoughtstuff Podcast – Tom Morgan on Teams Dev: Weekly Update 15 December 2025.

Find all my videos at thoughtstuff.co.uk/videos. You can also subscribe to the audio-only version of these videos, either via iTunes, Spotify or your own podcasting tool.

Transcript (AI-generated)

Hello and welcome to another weekly update. I hope you’re doing well.

We’re heading into the quiet slide toward Christmas, but there’s still some important updates to talk through. This week’s highlight is a major release for SharePoint Framework (SPFx) version 1.22.

SPFx 1.22 Build Tooling Shift: Gulp → Heft

The biggest news is that SPFx has moved from Gulp to a new build tool – Heft. It’s worth paying attention, especially if you have projects still in development. Heft is a drop-in replacement with some key differences, and migrating early could help you avoid breaking changes down the line.

If you’re already in production, consider this update during your next version bump.

To explore this further, I’m referencing two blog posts—one is the official Microsoft announcement, and the other is by Andrew Connell, who has detailed insights including how to create custom Heft plugins.

Security Enhancements

Another big plus with v1.22 is the significant reduction in security audit warnings from npm packages. The SPFx team has worked to ensure the default scaffolding is now clean of those warnings, making it much easier to pass client audits and get into production.

Git Workflows in Visual Studio 2026

Mads Kristensen’s blog post revisits Git integration in VS 2026. It’s a “day in the life” style walkthrough, covering workflows like stashing, popping, and even AI-assisted commit messages. If you’re like me and don’t stash often enough, it’s a great reminder to use these capabilities more thoroughly.

The generate commit message button is especially game-changing – I don’t write any commit messages myself anymore!

Vibe Coding with GitHub Copilot and Claude Sonnet 4.5

Over the weekend, I built a running training dashboard using nothing but AI – specifically GitHub Copilot CLI and Claude Sonnet 4.5. The result? Data from Strava and a weather API presented on a terminal display. I didn’t manually write a single line of code. Perfect for those “someday” projects that usually never get built.

I shared a full blog post about it if you’re curious about using AI to build functional, minimal-code projects.

Reminder: Claude Code Integration Guide

Finally, I dropped in a high-level but useful ZDNet post on getting started with Claude Code. Sometimes a walkthrough is all you need to get a tool into your workflow. I’ll be playing with it over the holidays – we’ll see how it stacks up compared to Copilot.

That’s everything from me this week – have a great one, stay stress-free as we head toward year-end, and I’ll speak to you again soon.

I chose to use GitHub Copilot CLI, which is the same GitHub Copilot that’s in Visual Studio and Visual Studio Code but just through Windows Terminal. As a developer, I’m finding that building entire ‘vibe’ projects this way to be strangely pleasing – because I’m not in a code editor it’s a mental shift away from more traditional development and I don’t feel the karmic weight of the code that’s being generated because I can’t see it. It also means I can switch focus away to some other task, coming back periodically to issue new requests or clarifications. For this, GitHub Copilot used Claude Sonnet 4.5.

I recently had success using this to create another vibe-coded project: Winter for Windows.

The Problem

I tend to train best when I’m aiming at some future event, so I try and make sure I’m signed up to something most of the time. This time around I signed up to a half-marathon with about 3 months notice and so I decided to look for a training plan to see if I could improve my time. In the past I’ve used ChatGPT to create training plans, and it’s done a good job, but this time I used one from Ben Parkes, mostly because I think he has the nicest running tops.

The training plan came as a PDF. I don’t have a printer but I can view it on my phone. However, on Sunday nights, when I needed to plan what I was going to do when (because in the real world we can’t always run exactly when it says to on the training plan!) I found that I was writing down the plan for the week, and then constantly referring to it throughout the week. Was tomorrow the Easy 3, or the one with the Strides, or what?

I already had a TRMNL device, which I’ve variously used as a task list and to count down to my next speaking event, plus we have another one in the kitchen with the family calendar and house battery stats, and I thought this would be the perfect device to show the training plan, somehow.

I also needed something to give me that extra bit of motivation throughout the winter months, and the idea of always being able to see how many miles I’d run that week against my goal, would be a good way to keep me on the waggon.

Overnight Success 20 years in the making, or Prerequisites to ‘just vibing it’

There’s an interesting thing about vibe coding, which might explain the wild differences in how people talk about it. I think that, for a certain type of developer, it can 10x your productivity. However, for others, it can actually slow you down – AI Drag is a thing. Scott and Mark talk about this better than I can. Luckily, I’m in the 10x camp.

I also know what Microsoft Azure is and have an account there, and I understand the client/API model. I know what JSON is. I understand (mostly) how OAuth works when dealing with third party APIs and where to avoid putting sensitive data. I know the language of CSS. Note that I say I know the language. I’m bad at CSS and could not be relied on to produce the output of this project, but I understand the language enough to use the right words when describing what I want.

All of these things (I think) mean that I can have a very productive interaction with a coding AI and come away with some great results. I’ve put all my generated code into 2 public repositories so that if you want to, you’re welcome to use the (excellent) auto-generated README files to create your own.

What I “built”

There are 2 projects – the API and the front-end. They are separate from each other, in the sense that you could consume the API elsewhere and not use the plugin, but the plugin assumes an API that works in the way that this one does.

Part 1 – The API

The API is built in python and I chose to deploy it to an Azure function, but you could host it elsewhere if you’re more comfortable doing that. The API conveys:

• Your next event, and how many weeks away it is
• Your total miles run so far this week, and your target for the week
• The training plan for the week
• The weather for each day
• A record of your recorded runs so far, from Strava

There are two external API calls to make this happen – Strava and OpenWeather. You’ll need an account on each, and there are instructions for what to do on each in the README.

All the other data is stored as environment variables, so that it’s easy to update over time.

Each weekend, I’ll update the training plan for the week. It’s JSON, and looks something like this:

[
  {"day": "Monday", "workout": "Rest day"},
  {"day": "Tuesday", "workout": "Easy 5 miles"},
  {"day": "Wednesday", "workout": "Tempo 6 miles"},
  {"day": "Thursday", "workout": "Easy 4 miles"},
  {"day": "Friday", "workout": "Rest day"},
  {"day": "Saturday", "workout": "Long run 10 miles"},
  {"day": "Sunday", "workout": "Recovery 3 miles"}
]

When I want to change the running event I’m training for there is an environment variable for the name of the event and the date. There is also a JSON array for the weekly goals:

[
  {"weeks_until": 16, "target_miles": 15},
  {"weeks_until": 12, "target_miles": 20},
  {"weeks_until": 8, "target_miles": 25},
  {"weeks_until": 6, "target_miles": 28},
  {"weeks_until": 4, "target_miles": 30},
  {"weeks_until": 2, "target_miles": 20},
  {"weeks_until": 1, "target_miles": 10}
]

Based on this information, the API seems to be* smart enough to figure out what day it is, how many weeks to go, what the weekly goal should be, what the training plan is, and what running activities I’ve done that match those dates. It also picks from a selection of vaguely motivational quotes:

{
  "weekly_miles": 14.1,
  "target_miles": 28.0,
  "weeks_until_event": 9,
  "event_name": "Marriott's Way Half Marathon",
  "quote": "Every morning in Africa, a gazelle wakes up. It knows it must run faster than the fastest lion or it will be killed. Whether you are a lion or a gazelle, when the sun comes up, you better be running.",
  "weekly_plan": [
    {
      "day": "Monday",
      "day_short": "Mon",
      "workout": "50 min Progression Run",
      "completed": true,
      "distance_miles": 5.7,
      "duration_minutes": 50,
      "pace_per_mile": "8:48"
    },
    {
      "day": "Tuesday",
      "day_short": "Tue",
      "workout": "Easy 5 miles & strength",
      "completed": true,
      "distance_miles": 5.1,
      "duration_minutes": 44,
      "pace_per_mile": "8:37"
    },
    {
      "day": "Wednesday",
      "day_short": "Wed",
      "workout": "Easy 3 & strength",
      "completed": true,
      "distance_miles": 3.3,
      "duration_minutes": 27,
      "pace_per_mile": "8:05",
      "weather": {
        "temp_morning": 10.2,
        "feels_like_morning": 9.6,
        "precipitation_prob": 0,
        "description": "broken clouds"
      }
    },
    {
      "day": "Thursday",
      "day_short": "Thu",
      "workout": "Easy 4 & strides (5x20s)",
      "completed": false,
      "weather": {
        "temp_morning": 7.1,
        "feels_like_morning": 3.7,
        "precipitation_prob": 0,
        "description": "sky is clear"
      }
    },
    {
      "day": "Friday",
      "day_short": "Fri",
      "workout": "Strength",
      "completed": false,
      "weather": {
        "temp_morning": 9.3,
        "feels_like_morning": 7.2,
        "precipitation_prob": 5,
        "description": "overcast clouds"
      }
    },
    {
      "day": "Saturday",
      "day_short": "Sat",
      "workout": "Rest Day",
      "completed": false,
      "weather": {
        "temp_morning": 6.5,
        "feels_like_morning": 4.0,
        "precipitation_prob": 0,
        "description": "broken clouds"
      }
    },
    {
      "day": "Sunday",
      "day_short": "Sun",
      "workout": "Long 11 miles",
      "completed": false,
      "weather": {
        "temp_morning": 10.9,
        "feels_like_morning": 10.3,
        "precipitation_prob": 100,
        "description": "light rain"
      }
    }
  ],
  "has_weekly_plan": true,
  "progress_percentage": 50
}

The GitHub repo for this API is: https://github.com/tomorgan/trmnl-running-dashboard-api. You could either use it by itself as part of some other project, or with the TRMNL plugin project below. All the instructions should be in the README, but you’ll need to create an application in Strava and get a Client ID, and then do a little auth dance with the provided python script to get your tokens. You’ll also need an account with Open Weather (mine was free, but it was a long time ago so YMMV), and to know your lat/long for where you want the weather forecast.

*I say “seems to be” because I haven’t actually looked at the code for this. I’m deliberately experimenting with NOT getting involved with the code that gets produced, to see what happens. So far, it’s been working out OK.

Part 2 – The Plugin

TRMNL uses a specific design language for its plugins – the Liquid templating language. I think it’s fairly popular (Shopify created it I believe) but it’s not something I’d previously come across. I’d summarise it as HTML & CSS, with maybe some additional rules and restrictions around CSS, and the ability to insert variables using handlebar syntax, and do some basic conditional formatting and control flow stuff. For basic layouts, it’s pretty good, and fast to get something working.

The biggest limitation I found with TRMNL is that, because it’s a relatively low-quality monochrome e-ink display you can’t always display what you want to. Emojis especially, it seems to really struggle with. I understand why (mostly) and I’m more than happy with the trade for a device that is a lot less intrusive in my life (it doesn’t draw the eye like a regular screen does) and lasts 6 months between charges.

It’s also a little hard to work out whether stuff will fit on the screen or not without some trial and error. There is a sort of software emulator but it’s not instant and each change takes around 30 seconds of messing around to see how it renders. Usually this isn’t really a problem because most plugins take up a portion of the screen and can use built in components to display one or two keys pieces of information. However, I wanted a full-screen dashboard with a few different sections, and needed to be able to convey quite a bit of data. I got there in the end, it just took a few different attempts.

For what it is, there’s quite a bit of additional stuff in this project. The actual work of calling the API on a schedule and then inserting the values into the placeholders in the HTML is all done by TRMNL, so the only really needed file here is plugin.html. However the rest of the code lets you run it locally without needing a TRMNL or having an API to call, should you want to. Honestly, I think the AI got a little carried away on this one, but it’s fine.

You can find this repo here: https://github.com/tomorgan/trmnl-running-dashboard/tree/main

Docs: the unexpected win of the AI age

When it comes to AI generated coding, I’m almost more impressed with the quality of the documentation than I am with the code. This might be because I mostly know how to write the code, whereas I was never going to write the docs so I see this output as the bigger win. The quality of the docs is also a reason I’m putting all this stuff public rather than keeping it private as I would normally do – I don’t need to go to the effort to write up everything you need to know to get it deployed, as it’s all been nicely documented. Also, of course, if something isn’t clear you can load it into your AI tool of choice and have it explained to you there.

Conclusion

I’m loving having the mashup of accountability, motivation and organisation. It makes laying out my clothes the night before easier as I don’t have to check what sort of run I’m doing, and I think it really reduces the risk of my falling off the training plan and not hitting my weekly targets. I’m pleased with it and it makes me happy because it’s one of those little projects that I never would have got around to writing otherwise and it doesn’t make sense to expend any money to solve, but thanks to advancements in AI I was able to make for myself.

In a world where everyone is grumpy that AI is taking away creative jobs, I’ve taken an idea I had and made it a reality. As a developer, shouldn’t I be worried that this is going to take away my job? No! Firstly, this project was never going to be written anyway, no developer jobs were impacted as a result of AI doing most of the work here. Secondly, whilst I know our jobs will evolve as these tools change how we work, I’m confident in the value and knowledge we bring here to do all the other things that are not just typing syntactically correct machine code. It’s a fun time to be a developer!