Abubakar's Blog

I Procrastinated My Website Redesign for Years, Claude Fixed It in 30 Minutes

Abubakar Riaz — Thu, 12 Mar 2026 06:38:12 GMT

I’d been putting off a redesign of my personal site for years. It worked—Jekyll + GitHub Pages, Markdown content—but visually it was flat. Every time I considered a UI refresh, I imagined hours of wrestling with layouts and CSS.

Then I tried something different: I opened Claude Code. Thirty minutes later, my site had a proper UI/UX layout, new templates, and a cleaner structure—all built in a feature branch and deployed automatically.

Here’s exactly how it happened, what surprised me about AI usage limits, and why this workflow matters for any developer.

The Stack & The Goal

Jekyll + GitHub Pages
Content in Markdown

Great for simplicity and static hosting, but without deliberate design work you end up with a blog, not a polished site.
Goal: Transform the Markdown-driven site into a structured UI/UX layout without changing the underlying architecture.

The Workflow (Step by Step)

1. Initialize Claude in the Repo

Inside my GitHub Pages repo, I initialized Claude Code. It generated a claude.md file—a context contract describing structure, guidelines, and boundaries.

2. Create a Safe Workspace

Before any edits, I switched to a feature branch:

git checkout -b feature/ui-upgrade

Branch isolation is mandatory when an AI agent can modify many files.

3. The Prompt: “Upgrade the UI/UX”

I kept it simple. No long design specs. Claude responded by generating new layout templates, improved navigation, and structured HTML—transforming the site from basic Markdown pages into a real layout.

before

after

4. Test Locally (with AI‑Assisted Debugging)

I asked Claude how to test locally. It gave the Jekyll commands. When my environment threw missing dependency errors, I fed them back to Claude—it diagnosed and provided the exact install steps.

Once dependencies were installed:

bundle exec jekyll serve

The upgraded UI rendered perfectly.

5. Expand the Changes

With confidence high, I asked Claude to apply the new UI structure to other pages and update related templates. It modified multiple files in minutes—multi-file refactoring at AI speed.

6. Create the Pull Request & Deploy

Claude prepared the PR from the feature branch to main. After a quick visual review, I merged it. GitHub Pages automatically rebuilt and deployed the site.

The Result

In under 30 minutes, I finally had the UI-driven site I’d delayed for years.

Live site: abubakarriaz.com.pk
Repo: mabubakarriaz/mabubakarriaz.github.io

A Critical Observation: Token Consumption

This entire workflow consumed 92% of my daily Claude Pro usage—with only three prompts and one UI transformation. Why? Because each prompt involved massive context: reading files, generating code, updating multiple components.

Takeaway: AI-assisted development isn’t about prompt count; it’s about context size. Be aware of token limits when doing large-scale refactoring.

The Bigger Realization

The bottleneck is no longer the code—it’s whether you’ve integrated AI into your workflow. Casual experimentation won’t move the needle. The real productivity shift happens when AI becomes part of your actual development process: repos, CI, documentation, refactoring.

My advice: Pick one tool (Claude Code, Copilot, Cursor, etc.) and start using it on real work. The learning curve only happens inside your projects.

Final Thought

What felt like a multi-hour task became a 30-minute workflow. That’s the shift we’re entering: software development moving from manual construction to AI-augmented engineering. Engineers who adapt will build faster and ship more. The rest will still be thinking about redesigning their website.

Check out the live site and repo above—and if you have questions about the workflow, feel free to open an issue or reach out.

Enjoyed this post? Here's how to stay connected:

Subscribe to my LinkedIn newsletter Think you know DevOps? for curated insights on cloud & DevOps
Check out my full portfolio at abubakarriaz.com.pk
Connect with me on LinkedIn or GitHub

Got questions or thoughts? Drop a comment below — I read and reply to every one.

Stop Hand-Crafting Test Data — Automate It With Bogus in C#

Abubakar Riaz — Tue, 24 Feb 2026 11:13:45 GMT

If you’ve ever spent more time writing fake users, orders, or sample records than building features — you’re not alone. Generating reliable, realistic dummy data manually is tedious, error-prone, and gets in the way of shipping software. Enter Bogus — a .NET native fake data generator inspired by faker.js that lets you declaratively define data rules and spin up thousands of realistic records in seconds. (GitHub)

🧪 Why Bogus Is the Best Choice for Dummy Data in .NET

Bogus is one of the most popular dummy data libraries in the .NET ecosystem:
✔️ C#, F#, and VB.NET support — integrates seamlessly with .NET apps and test projects. (GitHub)
✔️ Fluent rule configuration — define per-property generation logic with expressive RuleFor calls. (GitHub)
✔️ Locale-aware realistic data — names, cities, addresses, emails, GUIDs and more in many locales. (GitHub)
✔️ Repeatability — deterministic seed support makes tests reliably reproducible. (GitHub)

Compared to hand-rolled randomization or basic loops, Bogus gives:

Consistent, human-looking values (not just random characters),
Structured object graph generation,
Plug-and-play usage with EF Core seeders and test fixtures,
Support for constraints (e.g., emails tied to names, or enums randomly assigned).

🚀 Core Concepts — Bogus in a Nutshell

At its heart, Bogus uses a fluent API to define fake data rules per property on your POCO model. You then ask it to Generate instances — either singly or in bulk.

Basic components:

Faker – core generator for model T
RuleFor() – define how each property should be populated
Optional global or local Randomizer.Seed to make outputs repeatable

📌 Example: Fake Orders

Here’s a simple example that creates fake Order objects:

public class Order {
    public int OrderId { get; set; }
    public string Item { get; set; }
    public int Quantity { get; set; }
}

Randomizer.Seed = new Random(8675309);

var fruit = new[] { "apple", "banana", "orange" };

var orderFaker = new Faker()
    .StrictMode(true)
    .RuleFor(o => o.OrderId, f => f.IndexFaker++)  
    .RuleFor(o => o.Item, f => f.PickRandom(fruit))
    .RuleFor(o => o.Quantity, f => f.Random.Number(1, 10));

var orders = orderFaker.Generate(5);

Output will look like real, structured data instead of gibberish — and all in a few lines. (GitHub)

🧑‍💻 Example: Fake Users With Relationships

Bogus shines when fake object graphs matter — for example, users with nested orders:

public class User {
    public int Id { get; set; }
    public string Email { get; set; }
    public string FullName { get; set; }
    public List Orders { get; set; }
}

var userFaker = new Faker()
    .RuleFor(u => u.Id, f => f.IndexFaker++)
    .RuleFor(u => u.FullName, f => f.Name.FullName())
    .RuleFor(u => u.Email, (f, u) => f.Internet.Email(u.FullName))
    .RuleFor(u => u.Orders, f => orderFaker.Generate(3).ToList());

var user = userFaker.Generate();

Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(user, Formatting.Indented));

This generates a user and three associated orders, all realistic and test-ready. (GitHub)

🏁 Best Practices

Use strict mode (.StrictMode(true)) to ensure every property has a rule. (GitHub)
Local seed per faker for deterministic outputs in unit tests. (GitHub)
Nest faker rules for object graphs (lists, child objects). (GitHub)
Use extensions like AutoBogus if you want automatic rule inference without enumerating every property. (GitHub)

📦 Get Started

Add the package via NuGet:

Install-Package Bogus

Minimum .NET Standard 1.3 support means it works from .NET Framework 4.x up through modern .NET 8+ apps. (GitHub)

🧠 Conclusion

For C# developers who need realistic dummy data — for UI mockups, integration tests, or database seeds — Bogus is your best choice. Its fluent API, rich dataset generators, locale support, and deterministic options make it far superior to ad-hoc random data or simple Faker implementations. Whether you’re a beginner writing your first API or a seasoned architect designing EF Core seeders or automated tests, Bogus will save time and produce better quality data — consistently.

Stop Re-Burning ISOs: The Multi-Boot USB Trick Every Admin Should Use

Abubakar Riaz — Sun, 07 Dec 2025 19:13:46 GMT

Bootable USB drives are indispensable for system administrators, DevOps engineers, and homelab enthusiasts. Whether you're provisioning bare-metal servers, rebuilding lab nodes, or maintaining a fleet of workstations, having a single USB stick capable of booting multiple operating systems significantly improves efficiency.

Ventoy is a modern, open-source bootloader that eliminates the traditional “burn ISO → reformat → burn again” workflow. With Ventoy, you install the bootloader once, then simply copy ISO files to the USB drive like regular files. When you boot from the USB stick, Ventoy automatically displays a menu of all available ISOs.

This guide explains how to set up Ventoy on a 128 GB USB drive using a Windows ThinkPad, copy Ubuntu Server and CentOS Stream ISOs to it, and finally boot and install an operating system on a Dell machine using Ventoy’s multi-boot interface.

1. Prerequisites

Before you begin, ensure you have:

A 128 GB USB thumb drive (Ventoy will reformat it)
A Windows ThinkPad (for downloading Ventoy and OS images)
A Dell system (where the installations will take place)
Internet access for downloading Ventoy and the ISOs

2. Downloading Ventoy on Windows

Ventoy provides a Windows GUI tool, making the setup process straightforward.

Visit the official Ventoy download page: https://www.ventoy.net/en/download.html
Download the latest Ventoy Windows ZIP package.
Extract the ZIP file to a folder of your choice.
In the extracted directory, right-click Ventoy2Disk.exe and select Run as Administrator.

You should now see the Ventoy installation window with your available USB devices listed.

3. Installing Ventoy on the 128 GB USB Drive

Once Ventoy is running:

Insert your 128 GB USB drive into the ThinkPad.
Ventoy should automatically detect the device.
Verify that the correct USB disk is selected.
Click Install.
Confirm the prompts—Ventoy will format the USB and install its bootloader.

When finished, your USB drive will include Ventoy’s bootloader structure along with a large exFAT partition for storing ISOs.

You won’t need to reinstall Ventoy unless you choose to upgrade it later.

4. Downloading OS ISO Files (Ubuntu Server & CentOS Stream)

Next, download the required operating system images.

Ubuntu Server ISO

Download from the official LTS release page: https://ubuntu.com/download/server

CentOS Stream ISO

Download from the CentOS mirror list: https://www.centos.org/download/

Save both .iso files to your system’s Downloads folder or another preferred directory.

5. Copying ISO Files to the Ventoy USB

Ventoy requires no ISO conversion or special preparation.

To copy your ISOs:

Open File Explorer.
Navigate to the Ventoy USB drive.
Drag and drop the ISO files (e.g., ubuntu-24.04-live-server-amd64.iso, CentOS-Stream-9-latest-dvd1.iso) onto the USB.

Ventoy can display and boot dozens of ISOs as long as storage space allows. There is no limit to how many operating systems you can add.

6. Booting a Dell System Using Ventoy

With your USB ready, you can now use it on the target Dell machine.

Insert the Ventoy USB drive into the Dell system.
Power on the system.
Press F12 repeatedly to open the Dell boot menu.
Select your USB device (typically listed as UEFI: Ventoy).
Ventoy’s boot menu will appear with all available ISOs.
Use the arrow keys to select either:
- Ubuntu Server
- CentOS Stream
Press Enter to begin the installation process.

Ventoy loads the ISO directly and hands off control to the OS installer.

7. Updating Ventoy Later (Optional)

Ventoy receives frequent updates. To upgrade:

Launch Ventoy2Disk.exe again on your ThinkPad.
Insert your USB drive.
Ventoy will detect if it’s running an older version.
Click Update — the process is non-destructive, and your ISOs remain intact.

Keeping Ventoy updated ensures compatibility with new OS installers and boot methods.

8. Why Ventoy Is Ideal for Homelab Environments

Ventoy is especially useful in environments where systems are regularly reinstalled or tested, including:

Kubernetes homelabs
Hypervisor installations (Proxmox, ESXi)
Bare-metal server provisioning
Windows/Linux multi-boot experimentation
Cloud-native hardware and firmware testing

With Ventoy, there is no need for repeated reformatting or “reburning” USB sticks. Just copy ISOs and boot.

Final Thoughts

Using Ventoy with a 128 GB USB drive provides a flexible, portable multi-boot solution ideal for DevOps workflows, homelab setups, and repeated OS deployments. With a quick setup on your Windows ThinkPad, you can easily boot and install Ubuntu Server, CentOS Stream, or virtually any other operating system on your Dell machines.

This setup becomes a valuable addition to any engineer’s toolkit, especially when working across diverse operating systems and hardware platforms.

Effortless Windows Package Management: Getting Started with WinGet

Abubakar Riaz — Fri, 29 Dec 2023 11:40:21 GMT

Introduction

The Windows Package Manager (winget) is a robust utility from Microsoft, designed as an equivalent to Linux's apt-get. This powerful tool enables users to automate software installations and upgrades directly through the command line interface (CLI), streamlining the process of managing applications on Windows.

💡

The winget command line tool is exclusively supported on Windows 10, version 1709 or later. Please note, Windows Server users may not be compatible with this tool.

Enhanced Installation Guide

I've outlined five potential methods for installing this utility. After attempting each one, verify the installation by running winget --version to check if it's successfully installed.

Feeling Lucky? Begin your adventure by opening PowerShell. Verify the installed version with a quick spell:
```
 winget -v
```
Still Riding Your Luck? Let's get straight to business. Register the package with this magical incantation:
```
 Add-AppxPackage -RegisterByFamilyName -MainPackage Microsoft.DesktopAppInstaller_8wekyb3d8bbwe
```

Full Gear Method Ready for a bit more of a challenge? Brace yourself and follow these commands to add all necessary dependencies and the winget itself.

 $progressPreference = 'silentlyContinue'
 Write-Information "Commencing download of WinGet and its mystical dependencies..."
 Invoke-WebRequest -Uri https://aka.ms/getwinget -OutFile Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle
 Invoke-WebRequest -Uri https://aka.ms/Microsoft.VCLibs.x64.14.00.Desktop.appx -OutFile Microsoft.VCLibs.x64.14.00.Desktop.appx
 Invoke-WebRequest -Uri https://github.com/microsoft/microsoft-ui-xaml/releases/download/v2.7.3/Microsoft.UI.Xaml.2.7.x64.appx -OutFile Microsoft.UI.Xaml.2.7.x64.appx
 Add-AppxPackage Microsoft.VCLibs.x64.14.00.Desktop.appx
 Add-AppxPackage Microsoft.UI.Xaml.2.7.x64.appx
 Add-AppxPackage Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle

Colleague's Envy: Noticed a colleague with a working version? Sneak a peek and grab it here: microsoft/winget-cli.
Plan C (The Last Resort): If all else fails, consider this your nudge towards a clean slate. Sometimes a fresh and latest copy of Windows is the way to go. In the meantime, Microsoft suggests a simpler step: head over to the MS Store and install the App Installer by Microsoft. Doing so should also install the winget CLI. Find your digital lifeline apps.microsoft.com.

Basic commands overview

WinGet operates through a command-line interface (CLI), allowing you to search, install, upgrade, and manage packages directly from your shell.

💡

Please confirm admin access to update, add, or remove items; a User Access Control popup will appear for security verification.

winget find  # To find the package.
winget add  # Once you've located the package you want to install.
winget ls # To see what's already installed on your system.
winget update  # To upgrade an installed package.
winget remove  # To uninstall an installed package.

Basic Usage of WinGet

Winget Find Command: Use this command to search for specific packages. It's the first step in identifying the software or tool you need.
Winget Add Command: Ready to install a package? This command allows you to add it to your system swiftly and efficiently.
Winget List Command: Curious about what's already installed on your system? Use this command to display a list of all installed packages, helping you manage your installations.
Winget Update Command: Keep your software up-to-date with the update command. It's essential for security and accessing the latest features.
Winget Remove Command: Need to declutter or free up space? This command allows you to remove unwanted or obsolete packages from your system.

Advanced Features

WinGet now facilitates not only the fundamental requirements of software management but also complex scenarios tailored to advanced users. These features include the ability to install specific versions of software, maintain consistent versions across updates, and streamline the setup of new machines by exporting and importing a list of software.

Version Locking
- winget pin: This command prevents unwanted updates by locking a package to its current version, ensuring stability and consistency in your software suite.

Exporting and Importing Packages: Streamline the replication of your environment on another machine by exporting and importing a comprehensive list of your installed packages.

Export Packages: Seamlessly create a file listing all your installed packages, complete with version details. This file can then be used to duplicate your setup elsewhere.
```
  winget export --include-versions -o winget-packages.json
```

Sample winget-packages.json

  {
      "$schema" : "https://aka.ms/winget-packages.schema.2.0.json",
      "CreationDate" : "2023-12-28T13:36:42.574-00:00",
      "Sources" : 
      [
          {
              "Packages" : 
              [
                  {
                      "PackageIdentifier" : "Postman.Postman",
                      "Version" : "10.21.0"
                  },
                  {
                      "PackageIdentifier" : "Spotify.Spotify",
                      "Version" : "1.2.14"
                  },
                  {
                      "PackageIdentifier" : "RARLab.WinRAR",
                      "Version" : "6.22.0"
                  }
              ],
              "SourceDetails" : 
              {
                  "Argument" : "https://cdn.winget.microsoft.com/cache",
                  "Identifier" : "Microsoft.Winget.Source_8wekyb3d8bbwe",
                  "Name" : "winget",
                  "Type" : "Microsoft.PreIndexed.Package"
              }
          }
      ],
      "WinGetVersion" : "1.6.3482"
  }

Import Packages: Effortlessly set up a new machine or restore your setup by importing the package list you've exported.
```
  winget import -i winget-packages.json
```

Conclusion

Windows Package Manager (winget) is a robust tool that significantly simplifies the process of managing software on Windows systems. By automating the mundane tasks of software management, it frees up time and reduces the complexities involved in maintaining your system. As you become more familiar with its commands and features, you'll find it an indispensable tool in your Windows environment, whether you're a DevOps Engineer, system administrator, or just a developer looking to streamline your setup.

Next Steps:

Windows Command Line Blogs Regularly visit 'commandline' section to remain informed about the latest updates, features, and community insights concerning the winget CLI.
Package Manager - Microsoft Learn By diving into the available resources, you'll uncover a multitude of ways WinGet can streamline and enhance your software management practices. Start exploring now to unlock the full potential of WinGet in your development workflow!