• I've installed https://github.com/johncmunson/claude-code-transcripts which is handy for copying formatted content from Claude Code into Obsidian. (I installed this rather than Simon Willison's original version because I don't have python tooling installed.) I've used it a few times if I've wanted to copy something from the transcript and retain the formatting, and it's worked well so far.

• The guy who has taken the lead on AI adoption at work was speaking to the whole company recently and I was really encouraged by some of what he was saying. It seems there is a bottom-up desire for transparency around when AI has been used, which I thought was a good sign of responsible usage. He was also quite positive about having varied adoption rates around the business, and happy for people to use AI as much or as little as they find helpful. I was glad of that attitude, as opposed to trying to push AI on people who don't find it useful. His emphasis was very much on making tools and training available to everyone, but leaving it up to individuals how helpful they find those tools while doing their work.

Things I learnt

• I needed to update some data in a data model I wasn't familiar with. I used AI too much, and it took a long time to verify what AI produced. I ended up changing tack, and just using AI to find the relevant database tables. I then manually verified that no other tables were relevant by checking foreign keys, and manually worked out what the data change should be. It was definitely a case where using AI slowed things down.

Things I've been thinking about

• With the coding agent space moving so quickly, there's always something new to try. It's impossible to keep on top of all the new developments. One impact of this is that the industry holds out the perpetual hope that salvation is just around the corner. Even if you hit frustrations actually using an agent for your work, a week later some new shiny thing will come out with the promise of making everything better. For example, I often vibe code user scripts (pieces of javascript which run in the browser when using a specified website, in order to customise its appearance or functionality). This is very hit–and–miss, presumably at least partly because the LLM agent has no way to verify whether the script is behaving as intended. Now there is a chrome extension for Claude which can be used by Claude Code to interact with the browser. This would probably make Claude better at this sort of work (although it also introduces security risks and I haven't yet read up on the mitigations which are in place, so I currently have no plans to install it). But it's another thing to install, another thing to try. It's yet another implicit message that the good stuff is just around the corner, and that even if you've found AI not to be useful you should try it again — and again, and again, and again, increasing your mental lock–in each time.

Things I've published

• First impressions of Claude Code after using GitHub Copilot

• Powershell script to download Azure DevOps project wiki

Things I haven't published

Most ideas I have for blog posts never see the light of day because I don't find the time to write them. Here's what I didn't get round to.

• Finding undeployed changes

• TIL how PasswordHasher handles salt

• Giving Claude Code readonly access to a database

• TIL why dictionary lookups are O(1)

• Claude Code forking and rewinding

1. Code wikis (Git-backed) - which you can clone

2. Project wikis (non-Git) - stored in Azure DevOps' internal storage

The Azure DevOps UI gives you the URL to clone a code wiki locally, but does not provide a way to download a project wiki. Using Claude, I vibe coded a powershell script to download a project wiki. I’ve tested it only once and although it worked for my wiki, I can’t guarantee it generalises well to all wikis.

It requires a PAT token. You can create these from https://dev.azure.com/{Your_Organization}/_usersSettings/tokens. The only permission necessary is Wiki (Read). When adding a new PAT token, you'll need to click Show All Scopes then scroll to the bottom of the list to find it.

The script

For some reason, Hashnode (the platform which powers this blog) has messed up the formatting of this powershell script and tried to escape lots of characters. There shouldn't be any backslash characters (\) in the script, so if you remove all of them then it should work.

$org = "your-org"
$project = "your-project"
$wikiId = "your-wiki-id"
$pat = "your-personal-access-token"

Write-Host "Starting wiki backup..." -ForegroundColor Green

\(base64AuthInfo = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(":\)pat"))
\(headers = @{Authorization = "Basic \)base64AuthInfo"}

# Get all pages
\(pagesUrl = "https://dev.azure.com/\)org/\(project/_apis/wiki/wikis/\)wikiId/pages?recursionLevel=full&api-version=7.0"
Write-Host "Fetching pages from: $pagesUrl" -ForegroundColor Cyan

try {
    \(result = Invoke-RestMethod -Uri \)pagesUrl -Headers $headers
    Write-Host "Wiki structure retrieved" -ForegroundColor Green
} catch {
    Write-Host "Error fetching pages: $_" -ForegroundColor Red
    exit
}

# Function to recursively process pages
function Process-WikiPage {
    param($page)
    
    # Skip the root page (path = "/")
    if ($page.path -ne "/") {
        Write-Host "Downloading: \((\)page.path)" -ForegroundColor Yellow
        \(pageUrl = "https://dev.azure.com/\)org/\(project/_apis/wiki/wikis/\)wikiId/pages?path=\((\)page.path)&includeContent=true&api-version=7.0"
        
        try {
            \(content = Invoke-RestMethod -Uri \)pageUrl -Headers $headers
            
            # Save to file
            \(filePath = "wiki-backup\)($page.path).md"
            \(directory = Split-Path \)filePath -Parent
            if (\(directory -and !(Test-Path \)directory)) {
                New-Item -Path $directory -ItemType Directory -Force | Out-Null
            }
            \(content.content | Out-File -FilePath \)filePath -Encoding UTF8
            Write-Host "Saved: $filePath" -ForegroundColor Green
        } catch {
            Write-Host "Error downloading \((\)page.path): $_" -ForegroundColor Red
        }
    }
    
    # Process subpages recursively
    if (\(page.subPages -and \)page.subPages.Count -gt 0) {
        foreach (\(subPage in \)page.subPages) {
            Process-WikiPage -page $subPage
        }
    }
}

# Start processing from the root
Process-WikiPage -page $result

Write-Host "Backup complete!" -ForegroundColor Green

I’m a long-time user of GitHub Copilot as a professional programmer, as my employer gave me access when we first started trialling its use in our company. I’ve used it mainly through Rider, which is the IDE I generally prefer, although I have used Copilot in both Visual Studio and VS Code as well to a lesser extent.

A week or two ago I was given access to Claude Code as well, so I’ve been using it fairly heavily for some upgrades I’ve been working on. It’s not a piece of work I’ve chosen to be representative of my normal workflow, it’s just what I’ve happened to be working on, but it’s been interesting to compare and contrast Claude Code with GitHub Copilot.

Here are my initial thoughts (which are, of course, all subject to change over time).

Planning

The single feature which has most impressed me has been Claude Code’s plan mode. Plans are very thorough and clear, and the default behaviour is to clear context before implementing the plan, which makes sense to me. It’s nice to have written plans without the overhead of managing all the markdown files containing the plans, as Claude does it for you. They are just saved to disk, so you can find the plans and copy them elsewhere if you want to.

Claude does take a long time to write plans, so in that sense I suspect it's slower than Copilot. It results in high quality stuff though. This may also be down to a difference in which model is being used, I haven’t really paid attention to the models too much. I tend to default to Claude Sonnet 4.5 in Copilot to try and balance a powerful model with a low quota usage. Claude Code is using Opus 4.5 most of the time, so this difference may well be the model rather than the method of interacting with it. I suppose the more significant difference is how my model selection has been shaped by the defaults built into each product, and the way that usage quotas are determined. Even if this is an unfair comparison when looking narrowly at what each product can do with the same model, I think it’s a fair comparison of how I have actually used the two products while trying to get work done.

I love the commit messages which Claude Code writes. Again this may be because it defaults to using Opus rather than Sonnet, but they’re very clear and contain a lot of detail. I’ve already benefited from this, searching my commit history for 'Google' when a Google maps integration broke, and immediately finding the commit which broke it.

UI

The biggest surprised for me has been how much I enjoy the Claude Code UI. I should prefer Copilot. I like having everything in a single IDE and I generally prefer GUIs to CLIs, yet I still prefer Claude Code to Copilot. Admittedly Copilot doesn’t have the best support in Rider, Microsoft have clearly prioritised adding features to Copilot in VSCode rather than in their Rider plugin, but this has still been a surprise to me. Claude Code somehow seems well thought through in way that Copilot doesn’t. I would struggle to articulate the specific features which have given me this impression, but it’s a surprisingly strong impression. Copilot feels a bit clunky, whereas Claude Code feels enjoyable.

I think one advantage of Claude Code (and presumably the other agentic coding CLI tools) is that they are consistent regardless of what IDE a developer prefers, whereas Copilot is very different in VSCode / VS / Rider (and presumably also other IDEs), depending on where Microsoft are up to with implementing new features in the relevant plugin. I get the impression VSCode leads the pack in terms of getting new copilot features, then other IDEs may or may not get the same features later, whereas a CLI tool gives everyone access to new features at the same time.

When I want to copy the agent’s output and paste it elsewhere, I’ve found that it’s easier to copy from Claude Code than the Copilot plugin in Rider. It seems like very simple functionality, but the formatting always seems to get messed up when copying from Copilot in Rider (and I would like a button to copy a response with a single click, though I appreciate that in agent mode it would be a little ambiguous exactly which messages should be included).

Claude Code is good for working with long prompts. The Copilot UI in Rider struggles with this, and normal keyboard shortcuts for navigating around a long piece of text don’t always work as expected. Claude Code has the shortcut CTRL+G to open the prompt in a separate text editor without disrupting the workflow at all, giving you full access to whatever text editing tooling you’re used to while writing prompts. I have found this very helpful. The same shortcut works when reviewing a plan produced by Claude Code, so you don’t have to read it in the terminal window or manually copy the plan elsewhere.

I prefer Claude Code’s approach to approving file changes and command line tools. Claude Code has 3 modes — plan mode (in which no files can be edited), auto–edit mode (in which all project files can be edited), and default (in which the user is prompted to approve edits to files). There’s a keyboard shortcut to cycle through them, making it very easy to allow Claude to make extensive changes when you want it to. Copilot (in Rider) doesn’t seem to have the option to auto–approve file edits, and the nearest setting I could find is to auto–approve after a short delay. As far as I can tell, you have to open the settings window every time you want to turn this on or off, which introduces much more friction than Claude Code.

Similarly, Copilot (in Rider) manages tool approval via the settings window. To be honest I’m not super confident with how (or if) it works, I’ve set up various approvals but still get asked for approval for those tool calls. Claude Code makes it really easy to approve specific commands without breaking flow, as the approval is done inline with the rest of the conversation. By default this is saved to .claude/settings.local.json in the directory where you are running Claude, but it’s also possible to save these settings to the .claude/settings.json in your user directory if you want them to apply to all directories (e.g. if you’re happy for claude to run git log in one project, you’re probably happy for it to run git log in all projects).

Copilot wants you to approve changes to files, but it’s already made the changes so they may have been picked up by external tools. You might build on top of them but the codebase is in a weird limbo state until you accept/reject the changes. This is disruptive to the workflow, and can cause code to be reverted unexpectedly if the approval/rejection comes a while later. I think it also causes Copilot to get confused when running git add or git commit sometimes. I’ve used auto-approve mode for Claude Code when I’m ready for it to make changes, and this has been a much smoother workflow.

Copilot has a nasty habit of opening multiple terminals in Rider, especially if it’s not getting the results it expects from the commands its running. It seems to like opening a new terminal to ensure it has a clean slate, but it doesn’t tidy up after itself by closing them again. Claude Code, of course, already runs in a terminal, so when it executes commands it doesn’t need to open a terminal elsewhere, keeping everything clean. Ironically, one of the advantages of Claude Code is that, being a CLI tool, it’s easy to run multiple instances in different directories. I’ve found this helpful for asking questions of a codebase without opening it in an IDE, something which Copilot can’t do.

Possibly the only thing (so far) that I’ve found I prefer in the Copilot UI is the ability to add files to the prompt. I find the UI somehow more intuitive than using @ in Claude Code.

Frustrations

As I suspect is common to pretty much all LLM tools, Claude Code is sometimes prone to going off on strange tangents and being useless. My impression is that it does this less than GitHub Copilot, but still more than I’d like. It can waste a lot of time ‘thinking’ before reaching a useless conclusion.

Also, when I use Claude Code via windows command prompt it keeps creating nul files. If that happens to you, there are instructions for deleting them at https://techblog.timhilton.xyz/deleting-nul-files-created-in-error-by-claude-code.

Concerns

These are my main concerns about the impact of using Claude Code:

1. Will I stop learning? This is a broader concern about the use of LLMs generally, but I think it’s even more pronounced for Claude Code. The workflow around planning then implementing is great, but it doesn’t have a space for learning. Of course, you can still use Claude Code in others ways for learning, but it’s not baked into that (otherwise very helpful) workflow. I found that Copilot, lacking an obvious workflow, is easier to ask questions while in the flow of making other changes, blending a mixture of learning and implementing at the same time.

2. Is it too fun? Will I waste time playing around rather than doing useful work? There’s no denying that Claude Code feels to me like magic in a way that GitHub Copilot doesn’t, and I have no idea why that is!

3. As with all LLM tools, I am wary of the danger that the tool will feel fast but actually take longer than doing the work myself.

Conclusion

I am aware that Claude Code isn’t the only CLI for agentic coding, but I’ve not played around with Gemini CLI / Copilot CLI / any others, so I don’t know how much my experiences are related to Claude Code itself, and how much they apply more generally to CLI agents.

I think the fact I’ve been working on upgrades recently has played in favour of Claude Code. AI tools are generally most impressive when working with a topic which is well documented online, but about which you don’t know too much. That gives much more room for them to impress you than a topic in which you are already well–versed. Some of the upgrades I’ve been doing have been in this territory, so I suspect my opinions may change as I use Claude Code for a more diverse set of tasks over time, some of which fall more within my technical comfort zone.

Having said that, so far it’s been a great tool that I’ve enjoyed using, and it has replaced GitHub Copilot as my go–to coding agent. I don’t know how my AI use will evolve, but I may use Claude Code for planning and implementing bigger changes, Claude web view or GitHub Copilot for more general research and learning, and Copilot for quick inline things in my IDE.

If you’ve used Claude Code, how do you experiences fit with what I’ve described above?

• From a technical point of view, the main thing that happened in January is that I got access to Claude Code and have been playing around with that. I hope to write up my thoughts soon.

Things I learnt

• I’ve published a number of short Today I Learnt blog posts. I’ll link to them below so won’t repeat them here.

Things I've read / watched / listened to

These are my own reflections from the content, not necessarily the main point of the content.

• The AI-Ready Software Developer #18 – “Productivity”. You Keep Using That Word. – Codemanship's Blog

  • This points out the misaligned incentives in the software industry, which I've noticed over the course of my career so far, and applies the insights to the impact of AI coding.

• Walking Skeletons, Delivery Pipelines & DevOps Drills – Codemanship's Blog

  • I love the idea of deliberately practicing starting new projects. I'm comfortable with the DevOps aspects of this but have long been aware I have never set up authentication from scratch on a greenfield project (though I have made substantial changes to existing authentication, like changing to a different authentication provider). I can imagine there could be a few things like that which I tend to take for granted, and might take a bit more effort than I'd expect if I were to create something substantial from scratch.

• Giving University Exams in the Age of Chatbots

  • This is a very interesting approach, allowing LLMs but giving clear rules about accountability.

  • Learning was, in this case, inversely correlated with LLM usage. This seems like bad news for me and my career (and other developers who have leaned into using LLM coding agents). I need to think more about this. What's the smart use of LLMs for me to ensure I still learn and stay sharp over the long term?

Things I've published

• TIL installing a .NET SDK can break .NET MAUI builds

• TIL Rider can show a diff of a directory between two branches

• TIL the format for pasting environment variables into a Rider run configuration

• TIL C# property overrides are separate for getters and setters

• Deleting nul files created in error by Claude code

• Finding a bug by checking git history one commit at a time

• TIL about typescript typing as const

Things I haven't published

Most ideas I have for blog posts never see the light of day because I don't find the time to write them. Here's what I didn't get round to.

• First impressions of Claude Code after using GitHub Copilot

• TIL why C# classes sometimes have multiple Dispose methods

• TIL how to get a git diff between 2 branches within a folder

class Foo {
  // prop1 is typed as string
  static prop1 = 'foo';

  // prop2 is typed as 'foo'
  static prop2 = 'foo' as const;

  static func1 = (input: typeof Foo.prop1) => console.log(`Input was ${input}`);
  static func2 = (input: typeof Foo.prop2) => console.log(`Input was ${input}`);
}

Foo.func1('bob'); // works fine
Foo.func2('bob'); // Argument of type '"bob"' is not assignable to parameter of type '"foo"'.

However, calling typeof will still return 'string' rather than 'foo'. That’s because using as const only affects how typescript checks types, not the javascript output which is produced from the typescript source code.

I recently found a styling bug I was confident I’d introduced in the previous few commits, but I wasn’t sure which one. In the past I’ve used git bisect but on this occasion I took a different approach. I knew I wouldn’t have to go back many commits, but I wasn’t sure how far back to go in order to be confident of finding working code (which is necessary for git bisect). I decided to go back through my git history one commit at a time and test each time. The bug was in a vue app and I wasn’t confident whether or not hot reloading would work given the nature of the changes, so I stopped the app each time and served it again.

The approach I took was to simply run the following command repeatedly, testing the app each time:

git checkout HEAD~1; npm run serve

This checks out the previous commit (which is what HEAD~1 means) then runs the serve script from the project’s package.json file. While the bug was still present, I simply stopped the script and reran it which moved me back again to the previous commit.

I don’t often use the HEAD~1 syntax in git but I’m becoming more familiar and confident with it, and finding more occasions where it’s useful to me. I’m also becoming gradually more confident combining commands using ;, and this was a good example of a case when even a short time ago I wouldn’t have been able to do this so simply.

Claude Code sometimes runs commands which contain something along the lines of > ./nul, which I assume does something meaningful in Bash but not in Windows Command Prompt. Windows creates a file instead of whatever the intended behaviour is. Something about the filename nul means the normal Windows operations for deleting a file can’t be used. So how can I get rid of the file?

Happily, once I explained the problem to Claude, it gave me a Windows Command Prompt command to delete the file:

del "\\?\%CD%\nul"

This command needs running in the same directory as the nul file.

Apparently, the \\?\ prefix bypasses Windows' normal checks for reserved filenames, allowing you to directly access and delete the nul file. Admin permissions are not required. I’ve updated Claude’s instructions to try and avoid it creating more of these nul files in the future, but I suppose I’ll need to wait a while to see how that turns out!

MyClass.Foo has a getter but no setter, yet an instantiated MyClass can have the Foo property set! How is that happening, and what does it do?

public class MyClass : LibraryClass
{
    public string OtherProperty { get; set; }

    public override string Foo => OtherProperty; // getter-only, no way to set the value
}

public class MyService
{
    public void DoThing()
    {
        var myClass = new MyClass
        {
            // How does this compile? There is no setter for Foo.
            Foo = "I'm setting this property"
        };
    }
}

It turns out that even though the Foo property only has a getter defined within MyClass, there’s a setter on the Foo property within LibraryClass, and this means it’s valid to write to the property within MyService.

The reason is that the override keyword is only overriding the getter, not the whole property. The setter therefore still exists in its original form, and can be used. What this does it write the set value to the backing field, but it’s not possible to get that value back out and do anything with it. It’s not useful, but it is valid and it does compile.

I was editing a run configuration in Rider and needed to add several environment variables to it. There’s a button in the dialogue to paste them in, but no guidance regarding the format of the data, and no feedback if you paste the wrong format.

What is a run configuration?

Rider allows you to create run configurations, which can be selected from a dropdown and have Run/Debug/Stop buttons next to them. When you open a solution, Rider populates these with several defaults depending on the types of projects in your solution, but you can edit these and add more of your own. It’s this section of the UI:

How to define environment variables

In my case, the relevant project was an Azure function. Editing the run configuration for it, there is a field for Environment Variables. You can type directly into this textbox, but if you click the icon on the right then you can add them as Name/Value pairs, and there’s an icon for pasting the data in.

What format to use

To paste environment variables into the run configuration, you need your variables in this format:

ThingEnabled=true;MySetting=foo;OtherSetting=bar

https://www.jetbrains.com/help/rider/Run_Debug_Configuration.html#envvars-progargs does hint at this format. It says “In the Environment variables field, type the variable name and value: <name>=<value>. If you add several variables, they should be separated with semicolons.” but doesn’t mention pasting so it’s easy to miss. More significantly, there’s no guidance within the IDE so you have to go looking for the documentation to find out the format.

Clicking this opens a new panel containing the list of changed files, and clicking on the files shows the diffs in the same UI as other diffs within Rider.

I always like to find new features and tools which I already have access to. This feature was useful for me today, and I daresay it will be useful again.

As an aside, this is the git command to get a diff of all changes within a specified directory on the current branch since it diverged from develop.

git diff develop...HEAD -- Path/To/Directory

If there’s a lot, you can append | clip to copy the output to your clipboard, or append > diff.txt to put it in a new text file.

I was flummoxed when working with a .NET MAUI app when I opened the application and it wouldn’t build. I had previously worked on it a month or so ago and had set everything up on my laptop so it would build, yet without any code changes there were suddenly 5 build errors.

After a lot of time wasted trying to fix the problem, I eventually realised the key piece of information I hadn’t considered — the previous day, I had installed the .NET 10 SDK on my laptop for the first time. This broke the build for my .NET MAUI app, and this blog post explains why that happened. At the end, I reflect on my use of AI in solving this problem, and how it both helped and hindered.

Build errors

I got 5 build errors, two of which were basically the same (NETSDK1202 for two different workloads).

9>Microsoft.NET.EolTargetFrameworks.targets(38,5): Error NETSDK1202 : The workload 'net8.0-android' is out of support and will not receive security updates in the future. Please refer to https://aka.ms/maui-support-policy for more information about the support policy.
9>ProjectName.App.csproj: Error NU1012 : Platform version is not present for one or more target frameworks, even though they have specified a platform: net8.0-android, net8.0-ios
9>ProjectName.App.csproj: Error NU1015 : The following PackageReference item(s) do not have a version specified: Microsoft.Maui.Controls, Microsoft.Maui.Controls.Compatibility
9>Microsoft.NET.EolTargetFrameworks.targets(38,5): Error NETSDK1202 : The workload 'net8.0-ios' is out of support and will not receive security updates in the future. Please refer to https://aka.ms/maui-support-policy for more information about the support policy.
9>Microsoft.NET.TargetFrameworkInference.targets(252,5): Error NETSDK1135 : SupportedOSPlatformVersion 11.0 cannot be higher than TargetPlatformVersion 1.0.

Explanation

At the root of my solution was a global.json file which looked like this:

{
  "sdk": {
    "version": "8.0.0",
    "rollForward": "latestMajor",
    "allowPrerelease": false
  }
}

The application was using .NET MAUI 8, which is why version is set to 8.0.0. However, it uses "rollForward": "latestMajor". This means it uses the latest .NET SDK which is installed. Installing the .NET 10 SDK effectively changed what version the application is using. Using the later version, the dotnet workloads which the MAUI project used weren’t compatible.

Running dotnet workload restore installed workloads which were compatible with .NET 10, but that broke things in the project because it’s not yet upgraded to .NET 10.

Solution

Once I understood this problem, the fix was a simple change to the json. I used "rollForward": "latestFeature" instead, which means it uses the latest version of v8, but doesn’t upgrade to later major versions. Once I’d cleaned the output directories, the build then ran as it had before I’d installed the .NET 10 SDK and passed.

Lessons about using AI

I used AI tools in trying to fix this problem, because to begin with I had no idea what was wrong. AI was both a help and a hindrance, but definitely more of a hindrance overall. Because I was out of my comfort zone, I was too slow to abandon the use of AI even though I could see it wasn’t making any progress.

I started by trying to get GitHub Copilot to fix the build errors. Unfortunately it dug itself into a hole making unsuitable changes, and couldn’t get out of it. It ran the build repeatedly, seemingly unable to believe the build was still broken, and determined to think that it could fix them by clearing package caches one more time. With hindsight, I wonder if GitHub Copilot, as a coding agent, has been biased toward action too much for this problem. It failed to do any diagnosis, and because I didn’t realise what had caused the problem I wasn’t able to provide that information.

I had much more success asking Claude (via the web chat interface) about the errors. It’s hard to say how much the difference was caused by using Claude rather than Copilot, as by this point I’d realised the possibility that the .NET SDK installation was the root cause, and this was critical information. Either way, it was able to explain the root cause and how to fix it, and was much more useful.

Things that happened

• I launched my website — https://www.timhilton.xyz/. It's vibe–coded slop, but it gives me a dumping ground for random bits and bobs. It's mostly technical at the moment, though I may find time for putting other things on it in the future.

Things I've read / watched / listened to

These are my own reflections from the content, not necessarily the main point of the content.

• Stealing your Telegram account in 10 seconds flat Ʊ lyra's epic blog

  • It feels magical that there are no images on this blog post, even though there are (what appear to be) screenshots. Each one is actually handcrafted HTML & CSS, which is mindblowing! As Teller (of Penn and Teller fame) said, “Sometimes magic is just someone spending more time on something than anyone else might reasonably expect.”

• Where's the Shovelware? Why AI Coding Claims Don't Add Up

  • I thought this was a helpfully evidence–based analysis of LLM coding. It's inspired me to try and track a little more objectively what impact using an LLM has on my own productivity. I've often thought it's unclear if the overall impact is positive or negative for me, though there are definitely some tasks which are far faster with an LLM. I don't expect to completely abandon using LLMs, but it's possible I may use them for fewer tasks or only specific tasks.

• The Future of Software Development is Software Developers – Codemanship's Blog

  • I can't remember what struck me about this, but I'm sharing it anyway 😅

Things I've published

• Nothing this month.

Things I haven't published

Most ideas I have for blog posts never see the light of day because I don't find the time to write them. Here's what I didn't get round to.

• Claude fixing an image

  • This was an interesting case of Claude fixing a problem which I would have had no idea how to approach.

• Sharing github copilot prompts across multiple IDEs

• What keyboard shortcuts I use as a professional programmer

  • I'm hoping to publish this at some point, but have only just started analysing what shortcuts I use most.

• I was working on an intermittent bug, trying to find the precise conditions which cause it by reading through code. I make notes in Obsidian as I go. I think I need to get better at creating summaries and headlines which clearly communicate things I'm learning from the code. At the moment I'm good at recording all the details, and I'm good at creating overall summaries, but I don't do anything to create summaries in the middle. For example, perhaps the high level summary is that a piece of code uses a particular setting, and the detailed version lists all the method calls which the execution path takes. I could do with summaries of those code paths, saying things like 'this code gets this setting from the database' without spelling out how that works.

• I've removed a few apps from running on Windows startup, and have instead written a batch script to open them. I run that script manually from a desktop shortcut and it opens the apps much faster than the Windows startup routine did. It was previously slow enough that I would sometimes be waiting 5–10 minutes for apps to open. Now they open in seconds.

• I've started trying to consolidate my Keyboard Shortcuts across the different apps I commonly use.

• My company has started holding in-person engineering discussions, and this month is the first time I was able to go to one. It was a good discussion, though I'll wait to see some concrete changes come out of the discussion before giving it an unqualified thumbs–up.

Things I learnt

• I was surprised how badly Claude did trying to summarise 2 documents for me in preparation for a meeting. The process of going through the documents and creating my own summary was invaluable in preparing for the meeting, but until I'd done that I didn't know what information I wanted in the summary. Claude wasn't able to work it out, and also added (incorrect) information which wasn't in the documents.

• I've twice asked GitHub Copilot to find the exact bit of code which did something, using Claude Sonnet 4.5 both times. I've been very impressed by the output — it has provided a markdown document with a lot of useful detail and code snippets, even though I hadn't specified any of this. I've not yet verified the accuracy of these documents, although (as always) they look plausible.

• My company has started using Dependency Track for keeping on top of the libraries we depend on. I think it's a great idea, and it's a while since it was first suggested, so it's nice seeing it come to fruition. I knew nothing about it beyond the basic concept, but I was asked to set it up for one of our projects, so I had the chance to learn more about how it works.

• A colleague wrote a SQL script using OPENJSON which I wasn't familiar with. It was interesting to see how this could be used to convert some JSON data into a table.

• Azure DevOps pipelines can run based on a definition hosted in GitHub.

• EF Core includes Filtered Includes. This has been available functionality for a while, but I wasn't aware of it. I sounds like a very useful performance improvement, and is definitely something I want to be mindful of when writing EF queries.

Things I've read / watched / listened to

These are my own reflections from the content, not necessarily the main point of the content.

• Why I’m not letting the juniors use GenAI for coding - lukeplant.me.uk

• Diátaxis — A systematic approach to technical documentation authoring.

  • I like this concept and the categories it creates.

  • I'm not keen on the use of Action, Cognition, Acquisition and Application. I find those terms too cerebral to be intuitive without more context. I think I prefer the ideas of 'working' vs 'learning', and 'understanding' vs 'doing'.

  • I'll definitely want to give this more thought in my professional life.

  • See also: documentation-writer.prompt.md · github/awesome-copilot (which is where I came across this framework).

Things other people said

Quote of the month

"My basic rule of thumb for LLMs is that I use them only in contexts where:

• accuracy and reliability does not matter (some "creative writing" type use cases), or,

• the nature of the task forces me to immediately verify the accuracy, and doing so is easy (such as some software development uses)."

Should we use AI and LLMs for Christian Apologetics? - lukeplant.me.uk

Things I've published

• TIL: Rider can show SQL Results inline within query

Things I haven't published

Most ideas I have for blog posts never see the light of day because I don't find the time to write them. Here's what I didn't get round to.

• How to manage email templates in Outlook

• Asking GitHub copilot to explain code and comparing different models

• Opening my startup applications faster on Windows 11

Today I learnt that Rider contains an option to display the results of a query inline within the SQL window. I don’t think this will be my default way of viewing SQL results, I think I’ll stick with a table of data at the bottom of the window, but I can definitely see this being useful for debugging long queries by checking the results at each step of a lengthy process. I always like to know what tools are available even if I don’t have imminent plans to use them, because it opens up more possibilities for the future.

Details of how to enable this (either per–file or for all queries) are in the official documentation.

Things that happened

• I've spent the last few months doing some technical upgrades for a client. I've come to the end of that work and started working in our support department.

Things I learnt

• I read a lot about the Domain and SameSite properties on cookies, as part of planning some work to change what subdomain an application is hosted on. Cookies are used between multiple applications which are all currently on the same domain, so I was reading up on the details of how browsers treat these cookies to ensure we don't break anything. I think I came away with a good understanding in the end, but I regret that I used an LLM for some of the research as it ended up being quite misleading. Happily I checked what it told me with human-written sources and found its errors, but I probably ended up spending longer clarifying my understanding than I would have needed to if I'd skipped the LLM and just done my research manually in the first place.

Things other people said

Quote of the month

“It’s also become clear to me that LLMs actively reward existing top tier software engineering practices
…
If you’re going to really exploit the capabilities of these new tools, you need to be operating at the top of your game.”
Vibe engineering

Things I've published

• Installing a .crt file as a Trusted Root Certificate in Windows 11 while Kleopatra is installed

Things I haven't published

Most ideas I have for blog posts never see the light of day because I don't find the time to write them. Here's what I didn't get round to.

• Code reviewing out loud

• Claude style for writing code review comments

The workaround I found was as follows:

1. Search the start menu for “Manage User Certificates” and select the option with that name.

2. Expand the “Trusted Root Certification Authorities” folder.

3. Right-click “Certificates”, hover over “All Tasks” then click “Import”.

This opens a wizard which I followed to install the .crt file.

According to Claude (so I have no idea if this is true or not 😅):

Kleopatra associates .crt files with GnuPG operations, which removes the "Install Certificate" context menu option.

• I installed Linux Mint on my personal laptop. I know nothing about Linux but it's an old Windows 10 laptop which isn't capable of running Windows 11, and Windows 10 support of coming to an end. The installation was more effort than I hoped and I had to troubleshoot quite a bit, but I got there without an unreasonable effort. Performance is much better so I'm sticking with it for now.

• I've used GitHub issues and Jules to create and update some of my user scripts. Jules has high enough usage limits on its free tier then it's effectively free at the moment. If you give it access to a GitHub repository, you can tag an issue jules and it will try to fix the issue and create a PR. The quality isn't great but it's an asynchronous workflow that I can trigger from mobile just as easily as desktop, so it's handy for ideas I have on the go.

  • I plan to publish my user scripts at some point, but they're not currently publicly accessible.

• I've improved how I use Obsidian for work notes.

  • I'm getting better at using meaningful headings within my work item notes so the document outline becomes more helpful.

  • I'm trying to get in the habit of adding a timestamped progress summary to my work item notes whenever I stop work on one of them (e.g. at the end of the day, or when switching to a different task) in the hopes of making it easier to pick them back up.

  • I'm also going to try and add callouts at the top of work item notes with key details like how to run an app, repro steps for a bug, etc. when this sort of information is relevant.

  • I'm making heavy use of callouts. Callout Manager is a very handy extension for this. I've added several new callout types of my own. I'm also using the auto-collapse feature a lot for error messages so they're searchable but not in the way.

  • I'm also linking between my notes more, linking to specific headings, and modifying the display text for the links.

• It was interesting using Claude to try and debug an issue with Application Insights telemetry not being sent to Azure. Claude made loads of useless suggestions and kept repeating suggestions that I had already told it didn’t work. It also tried to gaslight me into believing that everything was already working. Having said that, it also gave me some code snippets for getting diagnostic logs which were helpful, and the eventual fix was suggested by Claude and not by the Microsoft help articles about diagnosing Application Insights problems. It didn’t feel atypical that Claude was a mixture of useless, frustrating, and useful.

• Claude has also been helpful for investigating obscure issues. I've investigated hosting problems in a .NET app which had no server side code, but used a web.config file to configure serving an angular app. I've also asked highly-specific questions about nuances of .NET Framework and .NET Core for individual pieces of code. Discussions with Claude were more fruitful for these obscure issues than they often were for more conventional requests — perhaps because my own knowledge was more lacking so I found lower quality answers helpful in a way that I wouldn't have done for subject areas where I was more knowledgeable.

• My company has started training all employees in how to make the most of LLMs. As you might expect, the tone was enthusiastic about their use, but I appreciated that the advice was quite pragmatic. It was also emphasised that we humans are the experts, not the LLM.

  • Two pieces of advice that struck me as very sensible:

    • Timebox your prompting, and be disciplined to give up trying to use AI if it's not giving you what you want. Don't waste lots of time playing around with your prompts only to end up doing the task without AI.

    • If the LLM can get you 80% of what you want, it's often not worth the effort of using the LLM for the remaining 20%. Just make the required changes yourself.

  • I also appreciated the reminder to commit small and often, to limit the damage that an LLM will realistically do if it messes up the code.

Things I learnt

• How did I not know about git grep? 🤯 I used it to search a very large git repository and it was super-fast.

  • I imagine this is largely because it knows to ignore everything covered by the .gitignore, which is what I wanted. If I was using any other tool (e.g. command prompt findstr, or notepad++ directory search, or a powershell script) then a lot of time would have been wasted searching node_modules and other irrelevant folders.

  • I've already used this many times since finding out about it. It's been especially helpful because I'm working in a repository containing about a dozen solutions which share some common code, so finding code usages isn't always straightforward.

  • Because I typically run git commands from windows command prompt, I've sometimes forwarded the output to a file (using git grep foo > file.txt to replace the file, or git grep foo >> file.txt to append to it) to keep a record of the results or perform further text manipulation on them.

  • The search term is treated as regex, but it's also possible to use git grep -F "search term" to search for an exact string without having to escape any regex special characters.

  • I also learnt about git ls-files which is the equivalent for searching files based on their names rather than their contents.

    • e.g. git ls-files "*package.json" to find all package.json files across the whole repository.

• I'm becoming more familiar and comfortable with KQL for querying app insights telemetry. I'm still far from an expert, but I can find what I'm looking for a lot quicker than I previously could.

• I now know how to type an em-dash in windows (it's ALT + 0151) and android (when using gboard — you have to switch to the symbol keyboard then long press the hyphen). I've read one or two blog posts lamenting the decline of the em-dash now that it's become associated with AI-generated text, and I'd never known before what the purpose of the em-dash is. I've never been a great writer and I barely even edit what I write on my blog, but I've realised that the way I write I often need an em-dash. Not knowing how to type them, I've never used them before — until now!

  • I think this was the blog post which first made me think about this: AI is right about em-dashes • Joel Dueck

  • This is the article that most helped me understand the differing purposes of hyphens and dashes: Hyphens and dashes | Butterick’s Practical Typography

Things I've been thinking about

• My company recently did its annual employee survey and one of the questions asked what area of my role I find most challenging. As I reflected on this, I think it's probably working with a new technology that I'm not familiar with — especially one which has a substantial learning curve and which I need to get up to speed with quickly. I get intimidated by large complex pieces of technology, or black boxes which require learning a lot of concepts in order to understand what they do (authentication libraries are a prime example of this). It seems to me that the way to become less intimidated is probably to broaden my experience.

  • I like the stability of a long-term project. I like getting to know the project well — which includes getting to know stakeholders, colleagues, the codebase and usually some project-specific processes. However, this does narrow the breadth of experience which I gain over time.

  • How much is this a problem? I'm not sure. It's not causing me any problems right now, but I hope to be in this industry for another few decades and I imagine that breadth of experience makes it easier to adapt to changes.

  • Would I mind working with the same technologies for the rest of my career? Honestly, I think it wouldn't be my preference, but I don't think I'd massively object to it if I knew that those technologies would carry me through to the end of my career. I don't feel any great need to be cutting edge, but I don't want to become obsolete.

Things I'm grateful for

• As I was in July, I'm again grateful for the IT team at work. I raised a ticket that my laptop couldn't use the monitors on one of our hotdesks. It was investigated the next day and about a week later it had been replaced and the desk was useable again. I dread to think how long that would have taken in a large bureaucratic organisation.

Things I've read / watched / listened to

These are my own reflections from the content, not necessarily the main point of the content.

• I've only recently come across the concept of interactive blog posts, and I've found them to be a really enjoyable way to learn a topic.

  • A Friendly Introduction to SVG • Josh W. Comeau inspired me to learn about SVGs even though I have no

    • https://svg-tutorial.com/

    • https://www.svgviewer.dev/

  • The first one I came across was about using LLMs to process an email inbox and how that was a better use of AI than writing or summarising emails. I didn't make a note of the link though and can't find it now.

  • https://samwho.dev/big-o/ is another example

• No, AI is not Making Engineers 10x as Productive

  One thing I've noticed about all these characters in AI coding hype pieces is there is almost always a degree of separation from the writer to the actual productivity benefits. The poster is a founder, or a manager, or an investor, making grandiose claims about someone else's productivity. There's nothing wrong with secondary sources but if you can't find a primary source, you might start questioning the reliability of the information.

  Presentations from actual engineers demonstrating how they achieve more productivity with AI are much more varied and much more muted in their praise. These demos show largely AI as the same technology you and I were familiar with before we got so anxious: a neat text generator that sometimes does magic but often requires you to take the wheel.

• Obsidian Search: Five Hidden Features - Obsidian Rocks

  • I noticed the "Explain search terms" toggle in the obsidian search and wondered what it was for, as my searches didn't have anything worthy of explanation. This article was very helpful for understanding the built in functionality for searching within obsidian.

• Why using Bun in production (maybe) isn't the best idea - DEV Community

  Production depends on sustainability, predictability, and trust.

  • This is a great summary of my concerns about using LLMs too.

• AI-Generated “Workslop” Is Destroying Productivity

  AI generated work content that masquerades as good work, but lacks the substance to meaningfully advance a given task.

  The insidious effect of workslop is that it shifts the burden of the work downstream, requiring the receiver to interpret, correct, or redo the work. In other words, it transfers the effort from creator to receiver.

  When coworkers receive workslop, they are often required to take on the burden of decoding the content, inferring missed or false context. A cascade of effortful and complex decision-making processes may follow, including rework and uncomfortable exchanges with colleagues.

  Approximately half of the people we surveyed viewed colleagues who sent workslop as less creative, capable, and reliable than they did before receiving the output.

  • The point is that this is not merely doing bad work, but requiring others to fix the problems which it creates.

Things other people said

Quote of the month

• "Keyframe animations are meant to be general and reusable. We can apply them to specific selectors with the animation property"
  An Interactive Guide to CSS Keyframe Animations with @keyframes • Josh W. Comeau

  • I don't do a lot of front end work and I've always been confused about how to use keyframes and animations. Knowing that the keyframe is meant to be reusable and the animation property is meant to use it somewhere made it all click together much better for me.

Things I've published

• TIL: The UK has 20,000 fake phone numbers

Things I haven't published

Most ideas I have for blog posts never see the light of day because I don't find the time to write them. Here's what I didn't get round to.

• Claude at work: what worked and what didn't

• My experience of installing Linux mint

• Diagnosing why Application Insights telemetry wasn't sent to Azure

• No, AI is not like a junior developer

• Authenticating Augment extension in VSCode web

• Extracting simple HTML tools from Lovable

• Overriding Access-Control-Allow-Origin headers in chrome

• First impressions of using claude.ai at work

• Using collapsible callouts in Obsidian to prevent error messages disrupting flow

• New Outlook quick steps and templates

I found that Ofcom (the UK’s communications regulator) maintains a list of 20,000 fake phone numbers which are intended for use in films, TV, etc. These seem like excellent candidates for creating fake phone numbers in software testing too!

There are 20 ranges of reserved phone numbers which won’t be assigned to anyone, and each range contains 1,000 numbers. The full details are at https://www.ofcom.org.uk/phones-and-broadband/phone-numbers/numbers-for-drama.

If you just want a single fake phone number, you can use these:

Mobile: 07700 900000

UK-wide landline: 03069 990000

• I had my appraisal. It pushed me to think more seriously about how I can most effectively share evergreen knowledge with the wider company. Others have suggested this before but I've always resisted giving talks, etc. because of the time commitment (and the fact that talks at my company typically happen during our lunch breaks). I've started to give more serious thought to ways I could share knowledge and skills without it taking too much time away from development. I've also set this as a formal Objective within our HR system so I will be prompted on this again in the future.

• I was going to bookmark this handy list of emojis supported by Azure DevOps, right up until the moment I realised I'd already got it bookmarked 🤦

  • Similar (or possibly identical) list in a slightly different format.

Things I learnt

• ASP.NET Data Protection

  • I had never heard of this, but needed to use it and explain some technical choices to a client. I researched this from the Microsoft documentation and felt afterwards that I had a solid understanding of it. I'm certainly no expert, but I knew enough to be able to articulate the technical options we had, make a recommendation, and implement the final decision.

  • I also learnt a bit more about Key Vault permissions while working out what permissions I needed to ask our IT department for in order to test this work.

• fuslogvw.exe (Assembly Binding Log Viewer)

  • This is a tool which I've never heard of, even though it comes built into Visual Studio. In the end, it wasn't useful for me so I never really dug into what it does and how it works. It was still interesting to find out about it and run it.

  • You can run it within Visual Studio by opening either Developer PowerShell or Developer Command Prompt, then running the command fuslogvw.

  • Official documentation: https://learn.microsoft.com/en-us/dotnet/framework/tools/fuslogvw-exe-assembly-binding-log-viewer

• SQL Server indexes can include data from non-indexed columns.

  • I learnt this from a recommendation within Azure. It provided the SQL for adding an index which it recommended.

  • I assume this means that if a query only needs those columns, the entire query can be resolved from the index without needing to actually read the database table. I haven't read up on this or experimented with it, so I may have misunderstood this.

• Git aliases can use the current date, by invoking a powershell script.

  • I made use of this within one of the aliases for Managing local changes which should not be committed using only git stashes.

• I can pin part of my screen using ShareX.

Things I've been thinking about

• • My job title is currently Senior Software Engineer. My company is planning to split the Senior grade into two, but hasn't yet published the details of how the two new grades will be defined. I'm looking forward to finding out how the two new grades are defined, and which grade I will be given.

    • My company is currently hosting workshops for people to see a draft of the relevant document and provide feedback. That gave me a good feel for where I instinctively place myself, but I am still keen to look through the published document in detail and give it some proper thought.

    • Best ways to use GitHub Copilot, and whether I should try other AI tools professionally.

      • For a while my company has been paying for a Copilot license for me, and I could choose to give that up and get a licence for Claude or ChatGPT instead. They would only pay for one AI tool per person (which I think is completely reasonable) so I can't easily play around with different tools from day to day.

      • This policy has recently changed to give everyone a licence for Copilot and an extra AI licence if requested. I'm hoping this will help me explore other AI developer tools more.

      • I'm working in VS at the moment, and I suspect the Copilot tooling is far from the best available. For example, you can't drag and drop files from outside your codebase into the Copilot context. (VS Code and Rider both support this functionality.)

Things I'm grateful for

• I received very speedy responses from my company's IT department when I needed them to make changes to Azure resources and update my permissions for various functionality. I really appreciate that they accept the priority we assign to our own requests, trusting us not to take the mickey.

• I've had a number of opportunities recently to encourage colleagues with specific feedback, and I've also received some specific encouragements from colleagues.

  • I have realised that the level of encouragement I get from a compliment is directly proportional to how specific it is.

• My company is also planning some AI training for all staff, broken down by role. Knowing the person who is heading up the training, I am expecting this to be genuinely helpful, but I assume this will be delivered after the summer holidays when staff have more availability.

Things I've read / watched / listened to

These are my own reflections from the content, not necessarily the main point of the content.

• Simon Willison on the Generationship podcast. I've not come across the podcast before, but Simon Willison keeps on top of the current state of LLMs and AI tools from a software development perspective so I like to hear his views from time to time to know what (in his opinion) is the current state of play. I took 4 things away from the podcast:

  • It's important to teach & model that we all make mistakes, and how to recover from them.

  • Senior developers ask stupid questions.

    • Psychological safety - senior developers already have a reputation for competence, so asking a stupid question won't damage their reputation.

    • Learning - senior developers have become senior by learning, and they have learnt by asking questions. They may have become senior by becoming comfortable asking about things they don't understand.

  • Publish your notes so that others can benefit from them.

    • I imagine my notes could be a useful reference for others at times. People do occasionally ask me about work I did in the past, or if I've ever seen a particular error before, etc. I tend to search my notes, but perhaps there would be value to others being able to do that.

    • I'm not sure how this would work on a commercial project, as it may not be appropriate to share notes with people who are uninvolved with the project (even within a single company).

  • Gen AI lowers the cost of generating little tools and side projects which might not otherwise have been worth it.

• From Memo to Movement: The non-obvious insights, tactics and workflows Shopify used to bring an ambitious memo to life

  • Perhaps the best use for AI as a dev may not be writing production code but creating useful tools.

  • “Most people will tell you the ideal UX for both internal and user-facing products is for you to ask a question and receive the answer, not the messy details,” says Thawar. “But if your goal is to teach people how to master something, showing them those details is better.”

Things other people said

Quote of the month

• "The client is not interested in building good software, they just want to have it. They have no interest in the process." (A colleague)

  • This was said to me as a frustration on a particular project where this reality was causing problems, but I think it probably has a broad applicability to how software professionals liaise with clients.

  • I think this is a double-edged sword - it's positive to relate well to clients and understand their point of view, but can also be frustrating because they may not care about something we are passionate about.

Things I've published

• Using Visual Studio after being used to Rider

• Managing local changes which should not be committed using only git stashes

• TIL: Pin screen using ShareX

Things I haven't published

Most ideas I have for blog posts never see the light of day because I don't find the time to write them. Here's what I didn't get round to.

• Further thoughts on Visual Studio vs Rider (following on from Using Visual Studio after being used to Rider).

  • It's still not good news for Visual Studio.

• Instructions for using fuslogvw.

  • It turned out that this tool doesn't do what I wanted, so I ended up without a concrete use case to blog about.

  • I also didn't publish a write-up of how I did end up trying to find all binding errors within an ASP.NET MVC app.

• Thoughts on Simon Willison's appearance on the Generationship podcast.

  • Brief thoughts are included above within this blog post.

  • I wondered about writing something a bit more reflective to follow these ideas a bit more.

• How I use todoist as a professional programmer

  • I'll probably write this up one day but didn't get round to it this month.

• Writing a user script with AI and getting it (nearly) right first time

  • I might wait until I find out how much effort it is to get the user script working fully before I blog about this.

• Why I'm keen to vibe code useful tools

  • Includes some thoughts about the future of AI development tools. I hope to write this at some point.

The idea is that I can select a portion of the screen, then that image will stay in place as I work on other things. The image can also be easily dragged around, made partially transparent, or zoomed in/out.

Since stumbling across this functionality I’ve used it a few times to create a temporary on-screen reference for myself.

• A namespace from one code file stayed on my screen while I was navigating my codebase.

• A list of package version numbers from some instructions I’d written myself in Obsidian stayed on my screen while I switched note within Obsidian to make notes about some problems I was encountering.

• I wanted to compare two object instantiations within a long code file containing many similar object instantiations. I pinned one of them then scrolled down to the other.

This is what the functionality looks like:

How to use

1. Right click the ShareX icon in the windows taskbar.

2. Hover over Tools.

3. In the Tools sub-menu, click Pin to screen. This will open a dialog box with different options for what you pin to your screen.

4. I’ve been using ‘Pin to screen from screen’ which is admittedly a mouthful.

5. Select the area you want to keep on-screen. A coloured box will appear round it.

6. Drag the box elsewhere if you want to move it. Hover over the box with your cursor then scroll up/down with your mousewheel to zoom in/out. Hold down CTRL while scrolling to change the opacity.

   1. Hovering over the box also gives an icon for copying the image to your clipboard, and for opening other settings.

7. Right click the box to dismiss the image. (It isn’t saved anywhere by default, though you could create a custom Workflow within ShareX if you want them to be routinely kept.)

If you want to create a custom keyboard shortcut for this, you can do so from Hotkey Settings within the ShareX menu (opened by right-clicking the icon in the Windows taskbar).