Questadon

AI Rule Reference Tool for Nimble TTRPG

2025-04-23T00:00:00Z

The Final (for now) Result

I built a hosted searchable web app that uses Python and Flask to:

Ingest and chunk PDFs
Run fast keyword and fuzzy searches
Display results in an easy-to-read web UI
Highlight relevant matches
Provide citation-style links back to the original PDF section

It’s not a full chatbot or vector-powered retrieval system—it's deliberately simpler and faster. I wanted something my group could use on the fly during sessions, with no money down.

Hosted on Render: Nimble Rules Search

Give it a bit to spin up! Then use password: Hopscotch

Poke through my build here, too, if you'd like: Nimble Rules - GitHub

What I Set Out to Build

So with my long-running online TTRPG group, we play using a game system that's pretty new called Nimble. Unlike other Table-Top Role Playing Games like Dungeons and Dragons, there aren't many tools or references made for this one. Since we are all learning the system together, I wanted an easy way to look up specific rules from the Nimble rules PDFs during gameplay—without constantly flipping through 100-page rulebooks or opening the different files and wondering which ones my answer would be in. I also wanted to make it lightweight, private for just my group's use, and hostable for free, without needing to train an expensive AI model or rely on external APIs.

Options I Explored (and Why I Didn’t Use Them)

Tool/Option	Why I Looked at It	Why I Didn’t Use It
ChatGPT API	Natural language support	$$$ and not self-hosted
GPT4All	Local LLM inference	Too heavy for this use case
Pinecone/Weaviate	Vector DB for semantic search	Overkill for keyword-based queries
LangChain	Full retrieval pipeline	Added too much complexity
ChatPDF / PDF.ai	Fast for individuals	Not private or customizable or free

I realized I didn't actually need natural language processing—keyword and fuzzy matching was enough. The goal wasn’t “conversational,” just fast, accurate rule recall. I might expand on this in the future, but as a starting tool, I wanted to simplify my goal here.

Tools and Tech Used

Python (core script + backend logic)
Flask (lightweight web server)
PyMuPDF (fitz) for PDF parsing
FuzzyWuzzy (for fuzzy matching)
HTML/CSS (basic templating)
VS Code for development
Render.com (free tier deployment)
ChatGPT for vibe coding and learning

What I Learned

This was one of my first practical experiments applying lightweight AI techniques for personal use. I learned a ton about:

Keeping scope tight
Deploying apps (I had never uploaded to GitHub before!)
Creating a front-end interface
Chunking and adjusting weighting
NLPs in general, what's out there and what they can do

Updates I'm Considering

I might like to update this project with features like:

Natural Language Processing for search
A streamlined way to upload new PDF versions
A "clear search" option
A front-end that's actually designed
Obviously Nimble won't be happy to give their PDFs away for free via my search tool; I wonder if I can figure out a way to make it a searchable tool anyone beyond my group can use but not put their IP at risk?

Have you built something similar? How did you do it differently? Whether it's another PDF reference tool or just another tool for a TTRPG like Nimble, I'd be super curious to take a peek and learn what worked for you!

Planting the first seed

2025-04-23T00:00:00Z

Welcome to the beginning of Questadon, my little plot of cloud-soil where I’ll be documenting what I learn, make, and experiment with. A place where I can try things out, document the weird and wonderful bits of the process, and hopefully connect with others doing the same.

My goal is simple: use this site as a no-budget learning project where I house my other learning and creative projects—and maybe some random thoughts along the way! I'm hoping to build things that are thoughtful, fast, and sustainable. And end up with stuff that I actually personally use!

Why I’m doing this

So, I'm primarily a designer and marketer; I’ve been creating websites for years (2008, yikes) using platforms like Webflow. I had never been really interested in the nuts and bolts of programming, but hello 2025 and crazy-times-in-the-world, suddenly I find myself feeling a lot more digital-DIY-inclined.

I want the things I make to reflect how I work and what I value. That means:

Keeping things lean and performant (small page sizes, optimized images, reasonable JS, eventually light/dark mode)
Building on other people's work—no need to reinvent the wheel for the sake of it, use what's already out there and put it together in new ways that work for me
Crediting the amazing people, tools, and small companies I learn from along the way

The core constraints:

No/minimal money down
Environmentally mindful
Learning-focused above all
Make stuff I want!

Y'all, I don't know what I'm doing here. If you're doing something similar, say hi! Seeing people working on stuff that makes the digital world safer, more environmentally-sustainable, more accessible to all, and better for humans in general—that stuff gives me hope.

My starting point

Where am I starting from? I'm relatively familiar with HTML and CSS, and I’ve just taken my first dip into Python and JavaScript. My learning will be assisted by AI, I'm gonna vibe-code my way through a lot of this (yep, really inviting the hate from that comment), but as I immerse myself in these projects I'll be looking to learn from other sources as well.

I'm starting with just building this website, though I have a couple other projects already in progress. What I've done so far:

Picked Obsidian to track my learning and outline content
Chose 11ty as my static site generator for this website
Planned a Digital Garden (posts like this, built as a learn-in-public journal)
Consolidated some Projects I've already been working on—builds, experiments, useful tools

This is only the beginning—but I’m already learning a lot. And that’s kind of the whole point.

Let’s see where this takes me.

Ye Ole Youtube GA Tracking (According to Bards from 2013)

2025-05-09T00:00:00Z

Okay, one of my favourite things lately is crawling under the hoods of websites to find jewels like this, which was written back in 2013 (and therefore might be super outdated but entertaining nonetheless).

It's a bit like geocaching, eh? Devs leave fun little treasures somewhere, and someone finds it 13 years later and is just delighted. Humans can be great.

Looks like Lunametrics belongs to a different company now, but props to Sayf Sharif and whoever else may have crafted yon rousing ditty. Thy notes hath mightily informed me of the mad reasonings behind thy creation.

//To Track Thy Youtube Upon Google Analytics
//Regardless the number of Players upon thy stage
//Performed by LunaMetrics http://www.lunametrics.com @lunametrics 
//and Sayf Sharif @sayfsharif
//Who beg thy forgiveness for the lack of the regular expression
//Forget thou not to subscribeth to our bloge: http://www.lunametrics.com/blog/
//CURTAIN
//
//Forsooth here doth we instantiate thy youtube player api 
//as it was written by the Google
var tag = document.createElement('script');
tag.src = "//www.youtube.com/iframe_api";
var firstScriptTag = document.getElementsByTagName('script')[0];
firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);
//Then as a drop of rain we create two heavenly arrays
//who may hold in thy endless bossom our value
var videoArray = new Array();
var playerArray = new Array();
//twixt the jquery we fly to watch as the eagle does the mouse
//for the wanderous devil known as the iframe

(function($) {
	function trackYouTube()
	{
		//What am i, but nothing?
		var i = 0;
		//Harken to the iframes of the page
		//thy loathesome demon gallavanting upon
		//our innocent sweet html
		jQuery('iframe').each(function() {
			//but what is this?
			//an iframe! Avast!
			var video = $(this);
			//it has a source!
			//Lo we can see it's innards
			//as Han was wont to slice the tauntaun
			var vidSrc = "";
			vidSrc = video.attr('src');
			//We shall check the source
			//there are but two responses
			//lo ere the response incorrect
			//we shall ignore it.
			if(vidSrc.length>29){
				if(vidSrc.substr(0,29)=="http://www.youtube.com/embed/"){
					//It is a YouTube video!
					//Rip apart it's source to obtain it's
					//vile beating heart, the youtube id
					var youtubeid = vidSrc.substr(29);
					if(youtubeid.substr(-6)=="?rel=0"){
						//cut off last 6 digits as hannibal did to atreides
						//and offer them to your gods
						cutlength = youtubeid.length - 6;
						youtubeid = youtubeid.substr(0,cutlength);
					}
					//we now place the beating heart of the youtube id
					//in our first heavenly array
					videoArray[i] = youtubeid;
					//and then mark the vile iframe beast
					//with the id of this video so that all
					//may know it, and reference it
					$(this).attr('id', youtubeid);
					//And for this, I am no longer nothing, I am more
					i++;			
				}else if(vidSrc.substr(0,30)=="https://www.youtube.com/embed/"){
					//Again! But this time it is wearing armor
					//Lo, the beast video may think it is 
					//protected, but not from our might
					//rip out it's heart again
					var youtubeid = vidSrc.substr(30);
					if(youtubeid.substr(-6)=="?rel=0"){
						//again cut off last 6 digits as hannibal did to atreides
						//but this time burn them as an offering to the four winds
						cutlength = youtubeid.length - 6;
						youtubeid = youtubeid.substr(0,cutlength);
					}
					//and once again place this demonic youtube id
					//into the possession of the array where it shall hold
					videoArray[i] = youtubeid;
					//and again mark the vile id onto the iframe
					//so all may know it.
					$(this).attr('id', youtubeid);
					//once more my worth increases, i am again incremented
					i++;					
				}else{
					//An iframe, but not one we see as that containing
					//a source of the youtube. These we shall let pass
				}
			}
		});	
	}
	//The beginning!
	//Sometimes buried deep within the story
	//but here we start our tale in earnest
	$(document).ready(function() {
		//begin our quest to find the foul iframes
		//so infected with the source of the youtube
		trackYouTube();
	});
})(jQuery);
//When the API of YouTube doth load, it will call
//as if by magic
//this function or code. 
//be ready
function onYouTubeIframeAPIReady() {
	//Now the battle is engaged
	//we sweep through our array and reference the
	//beating hearts of the youtube id's
	//We then create a new holy object into our
	//second array, by referencing each beating
	//youtube id heart, and tell it wence it
	//shall act upon events
	for (var i = 0; i < videoArray.length; i++) {
		playerArray[i] = new YT.Player(videoArray[i], {
			events: {
			'onReady': onPlayerReady,
			'onStateChange': onPlayerStateChange
			}
		});		
	}
}
//Should one wish our monstrous video to play upon load
//we could set that here. But for us. We shall let it
//sleep. Sleep video. Await thy time.
function onPlayerReady(event) {
	//event.target.playVideo();
}
//When our caged monster wishes to act
//we are ready to hold it's chains
//and enslave it to our will.
function onPlayerStateChange(event) { 
	//it tries to trick us with a number one greater than
	//that of our arrays. But we outsmart it.
	//with math.
	videoarraynum = event.target.id - 1;
	//Should the video rear it's head
	if (event.data ==YT.PlayerState.PLAYING){
		_gaq.push(['_trackEvent', 'Videos', 'Play', videoArray[videoarraynum] ]); 
	} 
	//should the video tire out and cease
	if (event.data ==YT.PlayerState.ENDED){
		_gaq.push(['_trackEvent', 'Videos', 'Watch to End', videoArray[videoarraynum] ]); 
	} 
	//and should we tell it to halt, cease, heal.
	if (event.data ==YT.PlayerState.PAUSED){
		_gaq.push(['_trackEvent', 'Videos', 'Pause', videoArray[videoarraynum] ]); 
	}
	//and should the monster think, before it doth play
	//after we command it to move
	if (event.data ==YT.PlayerState.BUFFERING){
		_gaq.push(['_trackEvent', 'Videos', 'Buffering', videoArray[videoarraynum] ]); 
	}
	//and should it cue
	//for why not track this as well.
	if (event.data ==YT.PlayerState.CUED){
		_gaq.push(['_trackEvent', 'Videos', 'Cueing', videoArray[videoarraynum] ]); 
	} 
} 





Note: This tracks multiple videos on a web page by their id

Random Project Idea Generator

2025-05-16T00:00:00Z

The Final Result

My very first JavaScript learning project started as a quote generator with a button. But then I turned it into something more fun and "me"—a random project idea machine that combines three elements to generate prompts like:

“An alarm system for small business owners preparing for the end times.”

Each time you click the button, a new combination is generated from three curated lists. I also integrated it cleanly into my Eleventy site, styled it, and added logic to avoid repeat results.

You can see it live at the bottom of my homepage! Give it a whirl!

What I Set Out to Build

Initially I just wanted to practice:

Writing basic JavaScript functions
Selecting elements with getElementById
Using event listeners
Randomizing items from an array

So I started by creating a basic quote generator that displayed a random inspirational quote from an array.

I used this article tutorial for a random quote generator to get me started, because it was recent and uses vanilla javascript. Thanks Lucia Nambi! 🙌

I went through all the code and had AI walk me through the concepts used (and it assigned me a bunch of practices for converting traditional functions to arrow functions, because I was really getting stuck on that.)

Once I understood how this separate little app worked on its own, I wanted to integrate it into my site and make it more "me".

I'm not much of a quote person. So I was like, what if instead it was an idea generator?

And I figured from what I had learned about Math.floor(Math.random() * quotes.length) there had to be a way to do this for three sets of information and then just display them all as a single string.

There was. Yay!

How I Built It

I created three separate arrays (ideas1, ideas2, ideas3)
I used a single function (getRandomItem) to select a random item from each
I displayed the full result using innerHTML
I added a reusable function to avoid repeating the same value twice in a row

Once it worked in a standalone folder, I:

Created a Nunjucks partial (quote-box.njk)
Inserted it as an include on my Eleventy homepage
Moved the script into /assets/quote.js
Styled it using scoped class names (.quote-section, .quote-output, etc.)
Tweaked line widths with max-width: 30ch for better multi-line balance

What I Learned About JavaScript

This project taught me a lot about:

DOM manipulation (document.getElementById, innerHTML)
Array use cases (especially selecting random items)
Arrow functions vs. traditional functions
Anonymous functions and callbacks
The difference between console.log() (for developers) vs. DOM updates (for users)
How to avoid immediate repeats with index tracking
Writing helper functions

I also got more comfortable with:

Structuring reusable components for static sites
Separating concerns: logic in JS, layout in HTML, style in CSS

Code Snippets

Here's what I ended up using, in case anyone cares for the quick look!

quote-box.njk

<section class="quote-section">
  <h2 class="quote-h2">What to build? Find your next idea below!</h2>
  <div class="quote-container">
    <div class="quote-output" id="quote-output">A scheduling app for calisthenics trainers who don't have thumbs.</div>
    <button class="quote-button" id="quote-button">Fresh Idea</button>
  </div>
</section>

quote.js

let button = document.getElementById('quote-button');
let output = document.getElementById('quote-output');
let ideas1 = [
  "A baby name generator", 
  "A haunted calendar", 
  "A crowdsourced treasure map", 
  "A vintage meme archive", 
  "A judgmental productivity app", 
  "A calorie calculator", 
  "A smartwatch app", 
  "A platformer game", 
  "A financial dashboard", 
  "A customer support chatbot", 
  "A dating simulator", 
  "A personality test", 
  "A virtual pet", 
  "An alarm system", 
  "A to-do list"
];
let ideas2 = [
  "for marine biologists", 
  "for Walmart greeters", 
  "for small business owners",
  "for high school teachers",
  "for nice folks",
  "for romantasy authors", 
  "for competitive knitters", 
  "for astronauts", 
  "for introverted teens", 
  "for dragons",
  "for food bloggers", 
  "for UX designers", 
  "for conspiracy theorists", 
  "for lost souls"
];
let ideas3 = [
  "trying not to fall asleep in a Zoom call.", 
  "renting out their backyard tree fort.", 
  "preparing for the end times.", 
  "trying to impress their cat.", 
  "who overthink everything.", 
  "looking for love.", 
  "who want to learn to play ukulele.", 
  "with trust issues.", 
  "obsessed with soup.", 
  "training for American Ninja Warrior.", 
  "learning to meditate.", 
  "building community.", 
  "fleeing the algorithm.", 
  "planning a vacation.", 
  "organizing their neopet collection."
];

function getRandomItem(arr, lastIndex) {
  let index;
  do {
    index = Math.floor(Math.random() * arr.length);
  } while (index === lastIndex);
  return [arr[index], index];
}

let last1, last2, last3;

button.addEventListener('click', () => {
  const [part1, i1] = getRandomItem(ideas1, last1);
  const [part2, i2] = getRandomItem(ideas2, last2);
  const [part3, i3] = getRandomItem(ideas3, last3);

  last1 = i1;
  last2 = i2;
  last3 = i3;

  const fullIdea = `${part1} ${part2} ${part3}`;
  output.innerHTML = fullIdea;
});

styles.css

/* Quote Box */

.quote-section {
  padding: 2rem;
  text-align: center;
}

.quote-container {
  margin: 0 auto;
  padding-bottom: 1rem;
  background-color: var(--color-bg);
}

.quote-h2 {
  font-size: 1.25rem;
  font-weight: 600;
  color: var(--color-secondary);
}

.quote-output {
  margin: 2rem auto;
  font-size: 1.6rem;
  font-weight: 600;
  color: var(--color-text);
  max-width: 30ch; /* sets a readable line length */
  text-align: center;
  line-height: 1.4;
}

.quote-button {
  background-color: var(--color-primary);
  color: var(--color-text);
  border: none;
  padding: 0.75rem 1.5rem;
  font-size: 1rem;
  border-radius: 30px;
  cursor: pointer;
  transition: background-color 0.2s ease-in-out;
}

.quote-button:hover {
  background-color: var(--color-accent-dark);
}

Article Rebrand Tool (Python + .docx Parsing)

2025-05-24T00:00:00Z

The Final (for now) Result

I built a Python batch conversion tool that:

Parses .docx Word articles with old branding
Extracts and preserves paragraph styles, headings, tables, hyperlinks, bold/italic/underline formatting
Rewrites each document into a new branded Word template
Outputs fully restructured, consistently formatted .docx files

It’s not fancy, but it’s functional—no Word macros, no manual editing, no open/save/reopen/reformat/repeat. You drop files into a folder, run the script, and boom: clean new versions ready to go!

Here’s the repo: Article Rebrand - GitHub

It’s not polished to perfection (yet), but it did help me crank through 160 documents, which feels p-rettyyyy dang satisfying. In its current version, I definitely did need to give them the manual review, but I figure maybe it can be improved for something in the future!

What I Set Out to Build

I had a batch of old Word articles that needed to be rebranded to match a new template—complete with updated paragraph styles, cleaner layout, and no weird formatting artifacts from the early 2000s.

Some had tables. Some had merged cells. Some had hyperlinks. Some used bullet lists. This is one of those tasks I've done or assigned to people and it's just super tedious. So I tried making Python do it for me instead.

Tools and Tech Used

Python 3
python-docx (for reading and writing .docx files)
docx2python (for reading Word textboxes)
lxml / XML tags (for formatting hyperlinks and table borders)
VS Code (for building it)
GitHub (first time posting a doc tool!)

What It Can Do (Current State)

✅ Automatically:

Extracts and rewrites:
- Titles
- Headings
- Paragraphs
- Bold / italic / underline styles
- Tables (with basic formatting)
- Hyperlinks
- Unordered lists (bullets)

❌ Still needs manual help with:

Ordered lists (numbered steps don’t auto-detect, so currently I've got them outputting to unordered lists)
Complex table formatting (merged cells, varied column widths, etc)
Mixed formatting inside hyperlinks
No image support

It’s good enough to clean up a big pile of documents quickly, but not perfect.

What I Learned

Honestly? A TON, cuz this was way out of my depth. I think this is one I'll come back to later on and have lots of "ohhhhh, THAT's why that worked" moments.

How Word documents are built under the hood (hello XML rabbit hole)
How to process structured text using python-docx
That hyperlinks in Word are surprisingly complicated

Future Improvements

Things I’d like to tackle next:

Proper support for numbered lists
Smarter handling of tables
Maybe image support?
Add a third step (or separate program?) to batch convert the .docx to .pdf to round out the process after manual review
Real error handling and logs perhaps?

If you’ve done something similar—maybe rebranding Word docs, building document processing pipelines, or working with styled exports—I’d love to hear how you handled the hard parts. And if you have suggestions on how to fix any of the stuff I couldn't figure out, PLEASE BE MY HERO AND SAY SOMETHING.

Okay, that's a wrap for now.

Rebranding Word Documents to Use a New Branded Template (A First Attempt at python-docx and docx2python)

2025-05-24T00:00:00Z

I made this because I had 160 articles to rebrand for work, and figured I'd make a personal project of it. But gosh, this pushed way beyond what I've worked with before.

The goal was to reformat old .docx articles into a clean new branded style using a Word template, all as a batch.

I learned about the python-docx library, low-level XML manipulation, and building structured content transformation pipelines... this was all super new for me and probably more advanced than I SHOULD have gone at my current level. But hey, pretty in character for me to throw myself into the deep end and try not to drown. ;)

I've got a parser.py to detect elements of the old docs and a writer.py to create the new docs, and a convert.py for single file tests and convert_batch.py for all 160 (no limit I'm aware of?).

Here's the GitHub folder

Libraries and Tools I Used

python-docx

Documentation - Many thanks to Scanny!

I used this library to read and write Word .docx files. Most of the document structure work happened with this.

Key things I worked with:

Document(...) – to create or load a .docx
.add_paragraph() and .add_run() – to insert styled text
.add_table() – to generate and format tables
.paragraphs[0]._element.getparent().remove(...) – this was used to delete placeholder content from my Word template

There were a few things I wanted to do that python-docx can’t handle out of the box—like clickable hyperlinks, table cell borders, and padding. So I dropped down into the WordprocessingML XML layer, which I still don't think I quite understand yet, to be honest.

Key functions and objects:

OxmlElement(...) – to create custom XML tags like <w:hyperlink>, <w:r>, <w:tcBorders>
parse_xml(...) – to convert a raw XML string into an element
qn(...) – to apply the correct namespace prefix to tags

docx2python

Documentation - Many thanks to ShayHill!

Used only for extracting the title text from textboxes, since python-docx can’t read headers or textboxes very well.

This was a good learning stretch for me and helped me understand how Word documents are really structured under the hood.

Design Elements My Article Rebrander Can (and Can't) Handle

Paragraph Types

The parser detects these block types:

heading2, heading3
paragraph
list_item (used for both bulleted and numbered lists for now)
table

Each type is output with the correct style name from my template (like “Body Text”, “List Paragraph”, etc). This gave me full control over the final formatting.

Lists

Unordered and ordered list detection was trickier than expected. I spent like 2 hours trying things that kept not working for the ordered lists.

For now, I settled on treating all list items as list_item, and styled them uniformly as unordered lists. Hyperlinked text inside list items is also supported.

Partial win here.

Tables

Tables are generated row by row, and for each cell:

Borders are added (light grey)
Internal margins/padding are applied
Text formatting (bold, italic, underline) is preserved

This only works for simple tables. For example merged cells, column widths, and specific table formatting isn't preserved.

Another partial win!

Things I'm Learning as a Programming Noob

This project helped me:

Understand how to use python-docx for both reading and writing Word content
Dive into XML-based formatting using OxmlElement
Improve my ability to modularize code and handle complex document structures
Debug layout issues that didn’t come from syntax errors but from subtle Word styling quirks

I encountered some small pieces for the first time as well:

Wrote my first README.md file
Learned what a .gitignore is and used one
I didn't realize you can't comment in a JSON file, but now I know!
I tested out GitHub Copilots and to be honest, it wasn't a win for me. It misunderstood my instructions and gave incorrect responses for almost all the things I wanted it to do, so I fell back on my good faithful non-optimal ChatGPT. Which sent me in circles on the ordered list issue for a long time but helped me find the libraries, figure out how to implement them, and get to where I got with this!

This was a stretch project for me and a rewarding one—I built something genuinely useful, and got much better at handling real-world Python code in the process.

I don't know if I SAVED myself time on converting those articles, ha, but I learned a heck of a lot more than I would have by monotonously doing them all manually one by one.

Ice-Fishing Mini Game (5e Compatible, Rules-Light)

2026-01-28T00:00:00Z

A two-part winter festival mini-game for your table: an ice fishing competition followed by a creature battle royale. Perfect for a holiday one-shot or a fun side activity in your campaign.

Every year, my online group holds a special event called Fishapalooza, where each of us "hosts" a stall or runs a one-shot taking place at a festival all about FISH. Sometimes it's on a tropical island, sometimes it's in a cute bustling port town, and one year we did it in December so we set it in the polar north at Christmas. This is a very silly mini-game anyone can slide into their party's adventure for some fierce yet nonviolent festival fun.

What's included: This post contains all the rules you need to run this event. While we were playing using Nimble, this is just as compatible with D&D and easily tweaked for other systems. I also made digital creature cards and tokens this—download links are at the bottom. ++ Skip to downloads

Part 1: Ice Fishing Race

Setting the Scene

Out on the frozen ocean, holes have been cut into the ice. Hefty fishing rods with odd-shaped hooks wait nearby—upon closer inspection, the hooks seem to have some kind of paralytic catch-and-release system installed.

A crowd of spectators is gathering to watch the competition. The holes are surprisingly big... what could be lurking below the ice?

How It Works

This is a timed event: how many fish can you catch in 4 rounds?

Each round, players:

Describe their approach. Ask them: "What stat is your character rolling with? How are you trying to catch fish?" The stranger the better, really—let that RP shine.
Roll the dice. The result determines which creature they catch (see table below).
Record the catch. Track what each player catches—they'll need these creatures for Part 2.

Catch Table

Roll	Creature
1–5	Nothing!
6–8	Tohohoad
9–11	Pirhanukka
12–15	Chrab
16–19	Snanta
20+	Octomas

We played with low-level characters. Adjust the ranges to suit your party!

Running the Event

Make it dramatic! When someone catches a new creature for the first time, describe it with flair. The teeth are gnashing! The tentacles are tentacle-ing!
Track catches on a shared table. Here's an example:

Player	Tohohoad	Pirhanukka	Chrab	Snanta	Octomas
Bash	—	—	1	3	—
Verinya	1	1	—	1	1
Zid	1	1	—	—	2
Hank	—	—	1	1	1

Speed things up after Round 1. Have each player roll their remaining 3 rounds at once, and go through them one person at a time. Just make sure anyone who pulls up a new creature gets the full fanfare.
Accidents happen. If a stray NPC gets snapped up by something with teeth... well, it's a dangerous place.

After everyone's caught (and released) their catches, have the spectators cheer and usher them into a nearby tent.

Part 2: Creature Battle Royale

Setting the Scene

Inside the large tent, it's dark except for a small pedestal illuminated at the centre of the room. Magic wisps around it. As you approach, you recognize the pedestal as a recreation of the shoreline outside, but less frozen over, with tiny icebergs floating in the water.

Leaning in closer, little shapes wiggle around in the water—you recognize miniature conjurations of the creatures you caught outside.

The spectators around you, hushed as you entered, now begin to slowly chant: "Fight! Fight! Fight!"

Fish Fight!

Players use the creatures they caught in Part 1 to battle it out in a tiny magical arena. The player with the last creature standing wins!

Setup

Share the creature cards so everyone can see each creature's stats and abilities.
I drew up a very simple map the day of, with mostly water but some icebergs and shoreline.
Populate your arena with tokens for each player's catches. (I used Owlbear Rodeo with my online group, and put coloured rings around tokens to show which player owns each creature. To each their own for choice of VTT!)
Give your players a verbal rundown of the simplified combat rules below, then roll initiative!
Use the initiative order to have each player choose where their fish begin in the arena. (I just assigned corners since I had 4 players.)
FIGHT TO THE (magically simulated) DEATH!

Simplified Combat Rules

Three action points per round. On your turn, you can use an action point to have a creature move or attack, in any combination. You can spend all your Action Points on 1 creature or use them on different creatures. If you take a reaction (Octomas) while it's someone else's turn, you have one less Action Point the next time you take your turn.
No attack rolls. If you're in reach, just roll damage.
Movement: All creatures can swim. Some can also move on land/ice (check their stat card for "speed" vs "swim").
Abilities: Each creature has special actions noted on their card.

We were using Nimble not D&D at the time; the action point system above is based on how combat works in Nimble!

The Prize

What does the winner get? It could be a pile of gold. It could be a cake shaped like one of their creatures. In our game, it was...

Pink Pufflepill Gillfish

Wondrous Item, Requires Attunement

A pink fish the size of a fingernail floats demurely in the water before you—possibly the cutest fish you have ever seen. When swallowed alive, the Pink Pufflepill Gillfish grants its power to the swallower.

Attunement: A creature attunes to this item by swallowing it alive, gaining the following benefits:

Charisma Boost. Your Charisma score becomes 19 while you have the fish in your body. This has no effect if your Charisma is already 19 or higher.
Aquatic Charm. You have advantage on Charisma checks when interacting with underwater creatures.
Spellcasting. You can use an action to cast one of the following spells: Entangle, Invisibility, or Polymorph. Once used, each spell can't be cast again until the next dawn. Charisma is your spellcasting ability for these spells.
Gills. You grow a pair of gills that allow you to breathe underwater.

Cursed. When a creature swallows the fish, they are cursed. They automatically attune to the fish and cannot remove it from their body. While attuned, the creature gains the following flaw: "You cannot resist cute things."

Downloads

Download the creature stat cards and tokens for use in your VTT or for printing below. Files are PNGs, downloaded as a zipped folder.

Creature Cards — Stats and abilities for all five creatures
Creature Tokens — For use in Owlbear Rodeo, Foundry, Roll20, etc.

Disclaimer: I ran this one time, and we had fun! Has not been playtested beyond that—but if you give it a spin and have some thoughts, let me know! ++ hello@questadon.com

On AI, Grief, and Restabilizing Society

2026-02-02T00:00:00Z

I’ve been noticing something in the way people talk about AI.

"I used to like my job, now all I do is review what AI spits out."
"...AI has sucked the creative energy out of my soul."
"Nobody is going to pay for this now that they can just have AI do it."

There's a lot to be said about the fear and anger surrounding the AI conversation. But today what was landing for me is the grief.

And I think grief matters more than we’re admitting.

Because half of us don't even realize we're grieving, and when people mention AI, we don’t actually end up in dialogue. We end up talking past each other—or talking at each other—while assuming the problem is about opinions, ethics, or policy, or education. There ARE problems there to tackle. But it's very difficult to get to real dialogue without first acknowledging grief.

Grief Doesn’t Always Look Like Sadness

When people say they’re afraid of AI, or angry about it, or dismissive of it, or overly euphoric about it, I do think a lot of them are responding to a sense that something familiar is slipping.

For some, it’s grief over:

The loss of a craft they worked years to master
Their work not being valued in the same way and how that has affected their financial situation
The destabilization of identity tied to skill, peer-standing, or valued expertise

For others, it’s grief over:

A world that already feels too fast and less humane
The erosion of clear boundaries between human and machine
The feeling that they didn’t choose this acceleration
The future they pictured that they felt more confident about understanding

And for still others, it may be grief mixed with relief... which is often even harder to talk about honestly.

People exhibit grief differently: anger, aggression, withdrawal, anxiety, tribalism, denial, extreme life changes, erratic behaviour, depression.

And what I'm thinking on today is how hard it is to talk at a topical level with people who are clearly affected on a personal level. Which... and we all need to be more realistic about this... is everyone now. Because this is a global change that has either affected the person you're talking to or friends/family of the person you're talking to in significant ways.

Why the AI Debate Keeps Breaking Down

Most AI discourse is framed as a debate about outcomes:

Is this good or bad?
Should this be regulated or embraced?
Is this ethical or dangerous?

But grief doesn’t really respond well to debate.

When someone is grieving, and we respond with counterarguments, what we communicate—unintentionally!—is that the feeling itself is illegitimate. That the problem is their reasoning, not their loss.

That’s often when conversations harden:

Curiosity turns into defensiveness
Questions turn into moral positioning
People stop listening, because they no longer feel seen

And then we’re surprised that “dialogue” doesn’t lead anywhere.

Most people don't know how to talk with people who are grieving. A lot of people avoid it entirely. It's complicated!

Recognizing Grief Doesn’t Mean Stopping Progress

But we're not in a situation where we can avoid talking about it either. This is a real change that is happening to us and around us, and we have to find a way to engage in it.

So I'm not saying we should just walk on eggshells around this topic.

Recognizing grief doesn’t mean stopping progress, rejecting technology, or even agreeing on what comes next.

I think it's just about changing the posture of the conversations we have with people.

When grief is named, a different kind of question becomes possible:

What are you afraid of losing?
What part of this feels destabilizing to you?
What do you wish people would acknowledge before trying to convince you?

And these questions are NOT just for people who seem obviously angry or depressed. Someone who's excited about the possibilities AI is opening up for them may also be grieving the loss of close relationship with people who see this topic really differently.

Those kinds of questions don’t solve anything on their own, of course. But they do something really important: they create the conditions where people can actually think together.

The Piece We Need to Move Forward Together

There’s a temptation—especially among people excited by AI—to treat hesitation or resistance as ignorance, or a failure to adapt. And there’s an equal temptation among critics to treat adoption as moral failure or thoughtlessness.

Both can miss the reality in the middle.

The world has changed around us in massive ways. Like the global pandemic, or World War 1 or 2, no one has totally escaped the effects of these irreversible changes.

And if that’s true, then the work in front of us isn’t just technical, ethical, or economic. It’s also relational. And not just in a "hold my hand" kind of way—I mean that the relational work we have to do is an ESSENTIAL part of stabilizing our future together.

When We Minimize Loss, We Widen the Divide

One of the easiest traps to fall into, especially in moments of rapid change, is scoffing at people who seem to have plenty and yet feel destabilized by losing something.

A software developer was making big money, but got laid off and hasn't been able to find work again, or had to take a much lower paying job.

It’s tempting to say: "Why are you complaining? Try working two jobs like I have had to for 10 years!" Or, "They kinda had it coming, real life isn't that easy." We often reflexively mock grief over loss that looks comparatively small (or even seems fair).

But that reflex doesn’t create equality or achieve justice. It just creates more distance.

It doesn't help us or them when we harden the lines between “us” and “them.” If we turn grief into a competition, we ensure no one really feels safe naming what they’re losing. And that's unhelpful for all of us.

Grief isn’t proportional in the way we want it to be. It’s relational. People grieve what their lives have been built around—identity, meaning, stability—even when those lives appear privileged or secure by other measures.

Acknowledging that doesn’t excuse systems of inequality. It doesn’t erase real disparities in power, safety, or opportunity.

Acknowledging that actually creates an opportunity to close the gaps effectively. I feel pain. You feel pain. If we stop measuring pain and pointing fingers for a moment, we give people on both sides a chance to process how to embrace a new identity and their current reality.

If we were facing this with fewer enemies, with more of a sense of shared ownership—not in "getting things back to the way they were" but in embracing reality as it is, we might find ourselves in a different kind of conversation.

Finding Solid Footing in the AI-Era Together

That doesn't mean people will agree, and it doesn't solve the very real ethical, economic, and ecological issues we're trying to untangle surrounding AI.

But I'd wager it's a better starting point for those conversations. Strong viewpoints make a lot more sense with context that goes beyond statistics.

We've got enough divisive issues we're facing today—and these are incredibly destabilizing.

Becoming more self-aware about our grief and curious (not as a thought-experiment; genuinely curious) about how the rapid changes around AI are affecting people feels like a pretty important part of restoring stability and energy to the world—and honestly, to ourselves as well.

I'm not at all claiming this is stuff other people haven't thought about. I am actually curious about what people who HAVE thought about this are noticing. Are there practical steps we could be taking (in communities, in work teams, in boardrooms, in schools) to set a different tone for the dialogue around AI adoption and the impact it's having? What has been working? What hasn't?