Category: technology

A week with Linux

29 December 2025
As with every year, we hear that it’s the “Year of the Linux desktop.”

Linux has been growing with popularity, in December breaking the 3% mark for the first time in the Steam hardware survey (it had previously languished at 1%).

When I last tried Linux was… let’s see… 19 years ago? Definitely around my Uni days. But the primary driver for me to stick with Windows was everything “just worked.” You never had a problem with it. Right?

However Windows 11 has just been presenting me with small cuts that are just building up to frustration,
- I feel like I’m frequently asked to back up to OneDrive, to upgrade to Microsoft 365.
- Whenever I start my computer I’m presented with GamePass ads on my lock screen, or being told to consider subscribing to another service.
- I try to search my computer and goes through Bing (why?)
(To me it’s no big deal that Copilot comes with Windows 11, as I just ignore it).

It’s the Holiday season, and with time on my hands, I considered “Why not?” I finally dipped my toes into the Linux waters.

What do I do with my PC anyway?

There are really only three things I do with my PC these days.
1. Coding – yes, I do still code from time to time, but on Windows I do it all through the Ubuntu subsystem (ie. Windows Subsystem for Linux).
2. Gaming – I love to game and my PC is primarily for my city builder and strategy games, with the occasional full on 3D game. I do stream games from this to my Apple TV to play comfortably in the lounge, but I do have an Xbox controller to play around with.
3. Internet bumming around – what else am I going to do with all these tabs?
The internet has no problems running on Linux, of course. All the distros come with Firefox pre-installed, or you can have Chrome. So that is no problem.

With my coding mostly being done in Linux anyway, even through Windows, it felt like I could just go straight to the source (or learn devcontainers at last?). Visual Studio Code is Linux friendly, and with Linux being Docker-native, I don’t need to do much to get containers or other things working.

Gaming, however. Well that was going to be an interesting one. The Steam Deck famously runs SteamOS, a Linux distribution. Valve have also built a library/system called Proton, based on WINE, that adds a compatibility layer for Windows games. How will it fare? There’s only one way to find out.

Flavours and Spins

First though, which one to choose? There’s so many different variants of Linux. I had four options in mind…
1. Linux Mint. This one is very popular with the new-to-Linux crowd, and had a moment earlier this year. It uses Cinnamon as its Desktop Environment.
2. Bazzite. Also popular with the new-to-Linux crowd, since it prides itself on being the closest thing to SteamOS that’s not SteamOS. It’s built on top of Fedora however, and the commentary I saw around it earlier in the year was it wasn’t the best for nVidia.
3. Ubuntu. We’ve all heard of Ubuntu, it probably powers most of the web by now. The primary distribution to reach to, making Linux easier.
4. Fedora. Based on Red Hat, a more community oriented flavour. Probably more “pure” to the Linux and Gnome philosophy than Ubuntu.
At first I tried Linux Mint, downloading the ISO and giving it a bit of a stretch on my machine. I gave it a partition on my primary SDD, and fired it up.

Immediately I was presented with a very Windows-like desktop environment. Start menu (or just, Menu), in the lower left. Clock in the lower right. I was impressed that the Driver Manager tool can just find my nVidia graphics card and get it working with a couple of button clicks.

Eventually, I felt I was in “tinker overload.” Cinnamon is based on Gnome, but has its own ideas about how it works. You can configure absolutely everything, such as have multiple panels, put the Menu where ever you want, move buttons, the lot.

This became a bit overwhelming. Couple this with a UI that was like I was a mishmash of experiences that were between Cinnamon and Gnome, I felt like I needed something a bit more aesthetically pleasing and less configurable (I get the irony here).

After scanning the web, and reading about distributions, I settled on Fedora. The primary reason being that I do like the Gnome experience, and has the strong backing of Red Hat.

I stumbled on this video from YouTuber Switch and Click which explained it all, and its fate was sealed.

However I didn’t read enough about Fedora’s philosophy on third-party or proprietary software. To get my Nvidia graphics card working, I had to find out what command I had to call. Fortunately it was straightforward, but it definitely was not a “terminal-less” experience getting started.

Gnome

But why am I stuck on the idea of using Gnome in the first place?

I actually first encountered new-Gnome a number of years ago in a hostel where it was running Ubuntu on an old machine. I quite liked its charm, and felt it was trying to do something different, something new.

KDE is unfortunately the main Desktop Environment I tried in my initial experiments when I was a teen, but did not like it. It felt like it was trying to be too much like Windows, while not solving the problems it had. Maybe, one day, I’ll try KDE Plasma.

With one press of a keyboard key (the Windows or Super key), you are taken to the Overview, which is like a cross between MacOS’s expose, Spotlight, and dock. From here you can click on an open window, open a new app, or search from something. Amazing!

Gnome apps are also simple, and clearly thought out. Simple options, clear screens, not trying to overwhelm you with choices.

But if you do want to get under the hood, you can get Extension Manager. From here you can make tweaks you think are worthwhile for you. I installed the AppIndicator support, Media Controls, and Dash to Dock so that the “dock” that appears in the Overview appears on my primary screen (unless I have a maximised window).

All in all, Gnome presents a nice middle ground with reasonable and beautiful defaults, with the option to dig deeper if you so wish.

Gaming

I use an Xbox One controller on my PC. On Linux I was surprised that when I started to play Forza Horizon 4 that the triggers started rumbling.

Consider me shocked to discover a feature in a Microsoft developed device in a non-MS environment.

To get my Xbox controller working fully, I installed xpadneo (it’s very simple to follow). I then paired my controller via Bluetooth and it rumbled awake.

Next was to install Steam. This can be (and is preferably done through) the Software app. You might first need to enable the repository that Fedora does have set up just for Steam.

Steam largely “just works.” From the Steam setting, you go to Compatibility to select your preferred Proton runtime (I haven’t bothered changing it). If I recall there was something else that needed enabling, but Steam is very upfront about that.

Another thing you can turn on while in Settings is under Library enable “Show Steam Deck compatibility information in library,” as this will give you a good indicator if a game will work however in my experience even the games that don’t claim support do work well.

Another way to see if games will work is to check out ProtonDB. Click on the profile icon in the upper right, and you can connect it to your Steam account to get a view of what apps are broken or not. It’s not the easiest to see what is broken, but there’s also a “Linux” filter in Steam that hides any game that is verified to not work (of which it was mostly some very old games or system utilities for Windows, so nothing lost here).

It does seem that if it is popular, Proton can handle it.

I loaded up Forza Horzion 4 as my “test” game, and came upon my first challenge – getting through the login to Xbox screen. I have a passkey, so it was trying to connect to the Windows system to work. In the end, I had to connect my Microsoft account up through Microsoft Authenticator and then I could verify my sign in through there.

Will the experiment continue?

So I was going to give it a week and see how I go.

For now I’m pretty happy with how I’ve got Fedora set up and working. I have a couple of other experiments I need to try first though before I can say I’m fully going to stick with it, but for now I’m going to give it another week or two of experimenting and playing around.

Not quite a Linux convert yet, but definitely on the cusp of it.

Feature image: Pixabay stock image
Building AI agents and bots with AWS Bedrock and Pydantic AI

2 November 2025
Like many Product Managers, I’ve been diving deep into AI agents and bots to understand how they shape new products. However, my role requires more than just understanding what they are, I also need to know the technical how so we can build the systems our engineering teams will build with.

As I started to dig into how to build an agent, I realised that with the libraries and support out there, in reality there is not much to them. Pydantic AI for example only requires a prompt to create an “agent”.

For the purpose of this post, we’ll use the term ‘agent’ to align with Pydantic AI library’s definition which is as an LLM interface, the end result is what Google would define as a “bot”.

I’d also say that with a personal project, using AWS Bedrock is a bit overkill. It’s a complex system designed for organisations. You are better off going directly to the LLM provider of choice. So why am I explaining it here? Because we use Bedrock at work and I wanted to learn how it worked so I could understand its systems in play for the ecosystem our teams work in. This is a learning experiment, but there’s easier ways to get this done.

There is a perk with using AWS – you get six months to take advantage of US$100 of free credits, and as you use more features you can get another US$100. This means you can play around with this without spending a cent.

Prepping your dev environment

First, let’s set up the desktop. I’m using Windows 11 with WSL 2.0 running Ubuntu.

The Python ecosystem has become even easier of late with the introduction of UV. It combines a number of individual Python dev tools into a single command line tool. No more fighting with venv.

I’m not going into too much detail on how to set each of these things up, but I recommend checking out UV and installing that.

Getting those AWS credits

Go to the AWS homepage and create an account. Follow the instructions and make sure you add a payment method (it’s the only way to get the free credits, and it won’t be charged until you run out).

Now you would have created a “root account” that you use to sign in.

AWS features are broken up by region, and when logged in you’ll find what region you are signed in to in the upper right. Generally the default should be fine, I’m playing around in us-east-1 (the famous one).

The good news is that since I started this post AWS have gone ahead and just activated all the models with no manual intervention. It used to be you had to go through a bit of a process to enable each model you wanted.

However Anthropic models still need some details. In the left hand nav go to “Chat / Text playground”, click “Select model”, choose Anthropic and then your model of choice (for this I’ll just play with Claude Haiku 4.5). Anthropic models need an Inference region, just select one.

You should be able to play around with the model easily in here. In classic AWS fashion, it doesn’t explain how activating these Anthropic models works and I’ve already done it once. If you do get asked for company information, I just said it was for personal projects and it gave me access nearly right away.

While you’re here, let’s set up your API key. These let you access Bedrock models much easier than managing it through AWS IAM roles. Go to “API keys” in the left hand nav, choose “Long-term API keys” and select “Generate long-term API keys”. Select an appropriate expiry date, then hit “Generate”. Copy this API key immediately.

Coding your first agent

Right, time to do some coding. First, I open up Terminal into my Ubuntu instance and create a new folder.

First we initialise our project,
```
$ uv init
```
It will set the project up for us. Then we add some dependencies
```
$ uv add pydantic-ai python-dotenv
```
The two dependencies are:
- Pydantic AI, which we will use to build our agents
- python-dotenv, which is used to set up our environment variables through a .env file
Now let’s open this folder in our code editor. I’m going to use VSCode for this, so I just type code . to open a VSCode editor in this folder.

We’ll just keep everything in one file for our purposes. Open up the main.py file in this folder.
```
# Import the dotenv library to load environment variables from a .env file
import dotenv
dotenv.load_dotenv()

# Import os module to access environment variables, and asyncio for async support
import os
import asyncio

# Import the Agent class from Pydantic, which is the core component for creating AI agents
from pydantic_ai import Agent


# Retrieve the model name from environment variables
model_name = os.environ["MODEL_NAME"]


# Create an AI agent instance with a specific behavior and personality
helpful_agent = Agent(
  # Specify which AI model to use for responses, this will be the environment variable we set earlier
  model=model_name,
  # Define the agent's role and behavior through a system prompt
  system_prompt="You are an expert translator that helps translate from English to Spanish. You always respond to the user with the Spanish translation only."
)


# Define the main async function that will run the agent
async def main():
  # Start an interactive command-line interface for the agent
  # This allows users to chat with the agent in the terminal
  await helpful_agent.to_cli()


# Standard Python entry point - runs when the script is executed directly
if __name__ == "__main__":
  asyncio.run(main())
```
By using the await helpful_agent.to_cli() we just set up a simple chat interface, it will wait for us to input a prompt and give us the response from the server. We don’t need to do anything else.

Finally, create another file, called .env in the root directory, we will have two variables in here,
- AWS_BEARER_TOKEN_BEDROCK, paste in your key from earlier as it’s used for authentication (if you lost it, you’ll have to create a new one)
- MODEL_NAME, the ID of the model we’re using, for Anthropic models this must be an inference profile. You can find this by going to the AWS Bedrock console and selecting “Cross-region inference” in the left hand nav and copy the value in the “Inference profile ID”. Prefix the word “bedrock:” like below in your .env file first
The file should look like this,
```
AWS_BEARER_TOKEN_BEDROCK="{key}"
MODEL_NAME="bedrock:global.anthropic.claude-haiku-4-5-20251001-v1:0"
```
So to overview what we’ve done so far,
1. Created an initialised an AWS account to use the LLM models available through AWS Bedrock
2. We initialised a new Python project with uv, and imported dependencies
3. Created a simple agent (this one translates text into Spanish), and told it to just run as a CLI
4. Finally we set up the configuration parameters so it works
With all this, we should just be able to run
```
uv run main.py
```
And you should just be greeted with,
```
pydantic-ai ➤ 
```
Type in your prompt and hit Enter.
```
(first-agent) $ uv run main.py
pydantic-ai ➤ Hello, how are you?
Hola, ¿cómo estás?                                                                                          
pydantic-ai ➤
```
If you want to change its name by the way, you can just set the prog_name value in the to_cli call like below,
```
await helpful_agent.to_cli(prog_name="Spanish Translator")
```
Congratulations! You’ve made an AI bot!

What next?

This is a very simple example of a bot. The Pydantic AI API is quite rich and I recommend reading through it, especially its agent concept primer.

It’s honestly been surprising how small the gap has become from concept to execution. The interface to build agents/bots has come a long way, since we’ve just built a translation bot in minutes.

But it only scratches the surface of what agents and bots can really do. You can get them to talk to other agents, call other tools, and even return data in a format other API’s can understand.

So, what would you do with the agents you create?

Category: technology

A week with Linux

What do I do with my PC anyway?

Flavours and Spins

Gnome

Gaming

Will the experiment continue?

Building AI agents and bots with AWS Bedrock and Pydantic AI

Prepping your dev environment

Getting those AWS credits

Coding your first agent

What next?