from llm_api_of_your_choice import setup_llm_api

llm = setup_llm_api(API_KEY)

def llm_sort(words):
    prompt = f"Given these words: {' '.join(words)}, sort them alphabetically. Reply only with the words separated by spaces."
    reply = llm(prompt)
    return reply.split()

No sane person would ever use this, right? Even bubble sort would outperform an LLM on this task in speed, accuracy and reliability. It’s quite simple to see why. An LLM burns through a massive amount of compute to do something a first-year algorithms course solved decades ago. Worse: it might even get the answer wrong! Even worse: the API might be down! Not to mention if you are not self-hosting your model your data is now being transmitted to a random third party with a vague clause in their privacy policy.

Now tell me: WHY REACH FOR AN LLM FOR EVERY DATA PROBLEM, YOU BOZO!?!

The sort function above is a joke. Don’t turn your production system into the same joke with a higher AWS bill just because your data is slightly messy.

Okay. Rant over.

The Rot

In the age of LLMs, a wicked temptation has taken hold. Instead of reaching for proper engineering judgment, the default has become reaching for an LLM. A dataset needs cleaning? Ask the model. Two records need matching? Ask the model. Some text needs extracting? Ask the model. Something needs validating, routing, deduplicating, normalising, clustering or searching?

Ask the model.

Have you considered that maybe, perhaps, perchance, the magical text box is not the right tool for every job?

LLMs are not useless, quite the contrary. They are amazing pieces of technology when applied to the right problems. What happens though is that they are flexible enough to look like the right solution in places where they are the slow, unpredictable, hard-to-debug option. Likewise, they make bad solutions look sophisticated because they are great at making demos look good.

But production systems do not care about your demo in your AI-generated notebook on five cherry-picked examples that only needs to work once in your presentation to the CIO.

They care about cost, latency, throughput, repeatability, inspectability, observability, reliability, edge cases, failure modes, and if the same input gives the same output tomorrow morning.

LLMs do not understand your business logic, edge-cases, your taxonomy, your customers. You do. You might say: “Just fine-tune it, bro.” Sure, “bro”, but if the plan starts and ends at “fine-tune it,” and nobody in the room can explain what data you need, what labels actually mean, what a loss function is, and what failure modes you are willing to tolerate, then you do not have a solution. You have an even more expensive demo.

The What Before the How

Next time you are faced with a choice, don’t ask: How can we use an LLM for this? Rather, try to understand your problem deeply and ask:

What’s the smallest, most reliable tool that solves this problem?

You will end up with something that outperforms an LLM in speed and accuracy, is more inspectable and reliable, and can be built on a laptop in a week.

Sometimes that tool is a regular expression. Sometimes it’s a lookup table or a join. Sometimes it’s a text-distance algorithm, a sparse retrieval model, a dense embedding model, a search index, classifier, rules engine, parser or better data. Sometimes it is doing it by hand.

And yes, sometimes it is an LLM.

Knowing which of these to reach for is the job. That judgment is what separates engineering from autocomplete. Please just don’t let LLMs become a default.

Sure, nobody is raising money by saying: “we used a join.” Have you considered that boring and correct might be enough? You work for an insurance company. Don’t turn it into Big Data Startup Enterprises Incorporated Limited.

Don’t use a sledgehammer when tweezers will do.

After my computer broke, I was devastated. But the devastation did not last that long. In 2014, for my 10th birthday, I received a small Android tablet as part of a bundle deal my parents got. Unlike my previous computer, this one came with a SIM card and a small monthly data allowance.

With that access, I almost immediately got my parents to purchase and install the original Minecraft Pocket Edition for me.

Initially I was content with just playing it, but soon my friends started talking about “mods”. While they played computer minecraft, I wanted in on the action. I soon discovered Block Launcher, and MCPE Universe, and I played with mods for the first time.

I was not content with just that, though, and soon curiosity took over. Realizing that the files I downloaded were .zip files I could extract was my catalyst.

Soon I was decompressing every mod I could find, trying to make sense of the code, and Frankensteining it together to make my own mods.

My first mod took months to create, but I was incredibly proud of it. The idea was to create a mod that made TNT more powerful, but I only knew how to make blocks that did nothing. It was a simple mod, adding a new block that looks exactly like TNT, but is not. I thought it would be the perfect prank, placing TNT in front of your friend, lighting it and nothing happens. In late 2014, I posted it on MCPE Universe with a screenshot of myself holding flint and steel next to a burning TNT block.

Soon thereafter, someone reached out. Another young coder asked in the comment section of my TNT mod if I’d be interested in working together.

What I find fascinating is that our security mechanism was that he would email me the name of my mod, “so I know it’s him.” Someone could just as easily impersonate him reading the exchange… If only I knew about Diffie-Hellman Key exchange back then!

We started communicating via email, and started making mods together. The pinnacle of our modding career had us making a mod called CrAZy MoD. Here is the full original code, preserved as-is in its entirety for your enjoyment!

(I have changed the name of the other person to Wolf42 to preserve their privacy, the rest of the code remains as-is.)

//Mod By Wolf42 and Louis999
//Do Not Distribute Without Wolf42's and Louis999's Permistion
//Have Fun and be Crazy!

/*Mod History:
V1-The "megga", "lol", and "dumie" blocks were added by Louis999!

V2-Louis999 added Wolf42 to the mod helper list and they became friends!

Also Wolf42 added "The Stick Of Truth" item and the Beggining Chat when you enter a world, also he added the commands!

V3-Louis999 added the "Cow" command!
   Also Wolf42 Did a full mod Rewrite! and added a load more commands!*/
   
//Variables
var PX = Player.getX();
var PY = Player.getY();
var PZ = Player.getZ();
   
//newLevel
function newLevel(){
clientMessage("Welcome Its Time to be CrAzY!");
clientMessage("Type /help for help!");
clientMessage("or Type /creator for The Crazy Mod Creators Information!");
}
   
//Blocks
//megga
Block.defineBlock(252, "megga ",[["gold_block", 0], ["gold_block", 0], ["iron_block", 0], ["iron_block", 0], ["iron_block", 0], ["iron_block", 0]]);
Block.setDestroyTime(252, 1.0);
Item.addCraftRecipe(252, 1, 0, [1, 1, 1,  1, 1, 1, 1, 1, 46]);

//lol
Block.defineBlock(254,  "lol",[["cauldron_inner", 0], ["piston_inner", 0], ["mob_spawner", 0], ["piston_top_normal", 0], ["destroy", 9], ["cauldron_top", 0]]);
Block.setDestroyTime(254, 1.0);
Item.addCraftRecipe(254, 1, 0, [1, 1, 1,  1, 1, 1, 1, 1, 1]);

//dumie
Block.defineBlock(255, "dummie",[["diamond_block", 0], ["mob_spawner", 0], ["diamond_block", 0], ["piston_top_sticky", 0], ["tnt", 0], ["destroy", 0]]);
Block.setDestroyTime(255, 1.0);
Item.addCraftRecipe(255, 1, 0 , [1, 1, 1, 1, 1, 1, 1, 1, 1]);

//Items
//The Stick Of Truth
ModPE.setItem(511,"blaze_rod",0,"The Stick Of Truth");
ModPE.setFoodItem(510,"blaze_powder",0,-20,"Pizza");

//Comands
function procCmd(command)
{
var cmd = command.split(" ");
if (cmd[0] == "help")
{
clientMessage("Item IDs 500");
clientMessage("Block IDs 252, 254, and 255");
clientMessage("type /lol for more help");
clientMessage("or type /cow for page 2!");
}
if (cmd[0] == "lol")
{
Player.setHealth(0);
clientMessage("LOL!");
clientMessage("You Should of Got the Hint With the word lol");
}
if (cmd[0] == "troll")
{
Player.addItemInventory(510, 1);
clientMessage("TROLL!");
Player.setHealth(10);
}
if (cmd[0] == "info")
{
Player.setHealth(1);
clientMessage("WE LIKE TROLLING!");
}
if (cmd[0] == "cow")
{
clientMessage("Type /troll for A Great big Troll!");
clientMessage("Type /info for info about this mod!");
}
if (cmd[0] == "creator")
{
clientMessage("Type /cw23 to learn about Wolf42");
clientMessage("Type /l999 to learn about Louis999"); 
}
if (cmd[0] == "cw23")
{
clientMessage("Wolf42 is a YouTuber and a modder, as you see here.");
clientMessage("He Also is the one who wrote what your reading right here, lol");
}
if (cmd[0] == "l999")
{
clientMessage("Louis999 is a basic modder and mod creator, he thought of this mod and created it!");
}
//Wont Work Properly
/*else{
clientMessage("That Command Isnt Real D:");
}*/
}

The humor of a 10-year-old me captured in full glory! What I find fascinating is the copyright notice at the top and the chronicle of our modding history together. I loved how I called myself a “basic” modder. Another interesting detail is that we clearly wanted a fallback if commands fell through, but we did not know how else and if else worked.

A few other funny things:

• Typing /lol kills you
• /info sets your health to 0
• Blocks with basically random faces
• Eating the pizza item would subtract 20 from your hunger, meaning it would effectively set your hunger to 0. Looking at the texture, I guess that makes sense!

But, as with all good things, we both moved on quite quickly. The tablet era was short, chaotic, and full of half-understood JavaScript. But when I got my dad’s old work laptop in early 2015, things changed. That was when I really started getting into programming…

This post will continue in part 4

During my childhood, I was obsessed with mazes. I would spend hours drawing mazes with increasingly complex rules and I would force my parents and friends to solve them. I wanted to translate this to the computer.

Every so often, I would return to the challenge. Most of my mazes were built in Minecraft. Soon though, my mind started to connect the dots. Minecraft had convinced me that computers could be bent to my will. If I could understand how the game worked, maybe I could make my own world. I was convinced understanding the .bat script was the key.

Initially, I experimented. I vividly remember trying to rename the script, after which windows would yell out a scary warning about how changing an extension might make the file unusable. I quickly pressed cancel, hoping I did not break my game.

The first time I tried opening the minecraft.bat file in notepad, I was overwhelmed. A bunch of nonsensical garbage filled my screen. I did not know it at the time, but the people who shipped the cracked version obfuscated the script. It was not meant to be understood.

I borrowed more and more books on programming and computers from the library, slowly building an understanding of how mysterious lines of text made the computer do stuff.

I attempted many times to apply my knowledge. Most of my “programming” was copying code from books in notepad, trying to run it but not having the compilers or knowledge to execute my code. My computer was littered with hundreds of little files. maze.py, maze.php, maze.java. Each an attempt to achieve my dream of creating a maze. Each time, I faced disappointment when I double-clicked, and the computer told me that the file I just worked on was unrecognised.

However, there was one piece of code I wrote that actually worked. A small little batch script - welcoming me to a new world.

echo "Hello World"

A short while later the computer I was working on died. Being locked out of a world I had only just started exploring, I had to find other ways to scratch that itch…

This post continues in part 3

My first ever digital device was an old Nokia phone we had in the house. It had no internet, no SIM card, just a snake game. My favourite part of it? The settings. I would sneak it into bed at night and play around in the settings at age 7… Until my dad caught me staying up one night after bedtime and took it away.

As many computer lovers, I started young. The first computer I ever used was our family computer that I played games on. It was a horribly slow computer running Windows XP. It took a whole 20 minutes to start up, and a further 10 to load into the desktop.

Around the time I turned 8, my parents got a new family machine, and the old computer became mine. Buggy, Caterpillar Construction Tycoon and Sim Copter were the staples of my childhood.

I have a fondly held memory where I wondered how someone would create a game. In my 8-year-old brain, I thought games were made by drawing every possible screen and your keyboard and mouse inputs would swap between frames in an interactive slideshow type fashion.

Around the time I turned 8, Minecraft started gaining popularity. All my friends were playing it, so I begged my parents to get it. After enough begging, they gave in and sourced a free version from a totally reputable online source and put it on my computer.

I have no idea what version of the game I had. Now I know it had to be one of the classic versions, but not sure exactly what version. All I knew is that my friends had cool features like survival mode, infinite worlds and redstone, while I had a finite world and basic features.

The version of the game I had contained 2 files. One was called minecraft_(random number)_xp.jar, and there was another file: minecraft.bat. Both on my desktop. To play the game I had to double-click the .bat file, a console would open up, it would stay blank for a good while, suddenly print a massive amount to the console, and I would be in the game.

As a kid, my mom would religiously take us to the library, and I would frustrate her with my book choice. I never went for the story books. I always darted for the non-fiction and natural sciences section. Around age 9, one of the books I took out was a full-blown Windows XP reference book. I did not fully understand what I read, but somewhere in it was a page on batch commands, and suddenly that .bat file started to make a bit of sense…

This post continues in part 2

Or - Should I rather say: I used to. Now we decided maybe it is best to spend some time apart, you know? With AI entering the picture… I don’t want to fall into a love triangle. CTFs made it clear, their heart belongs to someone else.

Love at first sight

CTF competitions hooked me in 2019, after I participated in PicoCTF. Immediately I was entranced. Soon after, Covid19 struck, and I was stuck at home with nothing to do, so instead of doing boring school work, I participated in every CTF I could find. The most notable one I participated in was the CSCG 2020, where I placed 21st in the global category.

In 2022, I pivoted toward competitive programming, but soon thereafter returned to CTFs.

In 2023, I jumped into CTFs again. I founded our university’s cybersecurity society in 2024, and our team ranked number one in South Africa in 2024 and 2025, closely followed by… myself! During this time I also won the BSides Joburg 2025 CTF.

What makes a good CTF challenge

Good CTF challenges teach through friction. The struggle is the point.

One of my first encounters with software security puzzles was this challenge from Securify. This is one of the best examples of a well designed CTF challenge. Simple, the goal is right there. The only thing keeping you from solving the problem is a lack of knowledge. The great thing is, you can find the information with a bit of reading and experimentation and eventually solve the challenge. The depth of knowledge you gain from bashing your head against such a challenge is incredible.

Contrast it with a bad challenge. A challenge like, for example, crack this hash.

955b322ab45819879603fe24584dc4604a1a412681a0884b34a573e1a21a217b

While a well designed crypto challenge might give you a nice python script with an implementation flaw that you have to exploit mathematically to derive the original string, a challenge like this does not teach anything. It becomes a question of who can paste the hash into CrackStation first. Not very helpful.

The cracks

During the start of 2025, I started to notice AI creeping in. First it was one of my team mates using his ChatGPT pro subscription to farm challenges in a friendly competition, then it was other teams slowly but surely catching on. I even experimented a bit, by building my own harness called tertullian. Overnight, an arms race started.

At first, challenge authors could keep up. AI solved the beginner challenges. The ones nobody really cared about. But eventually, the strongest oak must fall, AI models could soon solve close to 80% of challenges in a typical CTF. Agentic tools exploded onto the scene. Suddenly, AI companies made hacking a benchmark, and CTF challenges became training material. Most CTF challenges can be solved in half an hour with the right prompt. Success no longer correlates with a team’s problem-solving skills, but rather the amount of tokens they can afford.

Authors responded, by adding a layer of obscurity. For instance, they might remove whitespace and rename the variables of the above PHP script in an attempt to confuse the AI. I personally am not fond of this style of challenge, but understanding a piece of code with a level of obfuscation is still a skill, I do not object to this style of challenge.

The problem is not bad CTF challenges. Bad challenges have existed since the dawn of CTFs, rather the transformation of CTF challenges with excellent educational value into bad ones.

The breakup

AI teams again recognised this trend, and models started to become better at solving these obfuscated challenges. Authors had to adapt, again. This time by adding another level of indirection.

The straw that broke the camel’s back for me was when I encountered this challenge: Instead of just putting your SQLi payload into the application, you should now first XOR encrypt it with the challenge author’s name, and a value posted in the Discord. Other authors further obfuscate the challenge with more guessing layers that do not reward skill. Luck becomes the defining factor, or teams that can run 40 agents on a single challenge to find the top secret method this string is encoded in.

Could we get back together again?

The real problem is not that AI can solve challenges, rather that its presence changes what challenge authors design for.

This is an incredibly hard challenge to solve. How do you reward teams who use human effort to solve challenges, while keeping challenges fun? It is not realistic to try and ban AI usage in CTFs. How do you showcase something cool without an AI tool bypassing the learning opportunity? How do you satisfy competitive people (like myself) who want to compete, but cant compete against a machine that automatically solves your opponents challenges for them?

These are all my unanswered questions. For now, until we have a proper solution, I’m retiring from CTF competitions with the exception of small local challenges and private competitions where I trust people to not spoil the fun.

I immediately ruled out making my own system as I think it would be a waste of time that I could use to work on my engine. In the end I decided to look at the following systems.

I did not add Meson to the list as I am scared of its warp package manager and the visual studio generator sucks.

Bazel

Bazel is the build tool for Google and is used for all their stuff. I decided to reject it as I could not get it working with Visual Studio, and it needs msys.

SCons

Scons is the build system the Godot Engine uses, and rather effectively I must add. I wanted to use a similar code layout as Godot, so it seemed like a great choice.

Premake

Premake is used by a large number of AAA game studios, and I think I know why. Initialy I did not like the design, but it grew on me as it is super hackable and has everything I need.

Hacking Premake

The more I use premake the more I believe that it is designed to be hacked into the perfect build system for your needs, so that is what I did. The first thing I did was designing the architecture of my engine and building everything around that.

The architecture I decided on was loosely based on the design of Godot, where the engine is split into many modules that are mostly independent of each other. What I is modules can depend on e.g. the memory system, but physics should not depend on rendering or input. I also decided that each module must be able to compile to either an DLL or a Static library and linked into the engine at the flip of a switch. The reason I decided to do it this way was because it lowers link time if everything can be dlls for debug, and the final build can then be statically linked. Theoretically I could use incremental linking with visual studio, but I ran into issues before with that, so I would rather KISS.

I wanted to be able to do something like this in the main file.

 -- MODULE_DEFS
	include_modules({
    "pyro_memory",
    "pyro_containers",
    "pyro_reflection",
    "pyro_rendering",
    -- ...
	})

  -- RUNTIME_DEFS
	include_runtimes({
		{"launch_win32", "WindowedApp"}
	})

  -- TOOL_DEFS
	include_tools({
		"pyro_asset_tool"

	})

  -- TEST_DEFS
	include_tests({
		"pyro_memory_test",
        -- ...
	})

  -- EXTERNAL_DEFS
	include_externals({
		"gtest",
        -- ...
	})

  -- BENCHMARK_DEFS
  include_benchmarks({
    -- you get the idea
  })

This system uses a template to auto create modules, runtimes, etc if the declared type is not found.

The other thing I wanted was to use a custom premake command to add dependencies to a module, as the default way to do it in premake you need to manually add the include directory of a dependency to the target.

What I came up with is the uses command. In the module/pyro_modulename/pemake5.lua file:

pyro_module "pyro_modulename"
    -- ...

    uses {
        "pyro_other_module"
    }
    -- ...

The process for other types will be similar.

I also added some utility functions to map file vpath filter arrays to flat file lists but that is just standard boilerplate.

Implementing the system

Not comes the big challenge, actually implementing this system. For the part that includes modules and creates them if they are missing, it is easy.

function include_modules(table)
	group "engine/modules"
	for i, name in pairs(table) do
	    -- Create the module if not found
	    if not os.isfile("engine/modules/"..name.."/premake5.lua") then
            create_module(name)
	    end

	    include("engine/modules/"..name)
	end
	group ""
end

The create_module() function obviously needs an implementation, but that is the gist of it. The hard code is the using declaration, used for both external and internal(other modules)

The way I decided to implement this system is by creating an additional set of fields for each config, under projects, publicincludedirs and publiclinks. Here is an example of this in the gtest script.

pyro_external_project "gtest"
    kind "StaticLib"

    publiclinks {"gtest"}

    publicincludedirs {
        "gtest/googlemock",
        "gtest/googlemock/include",
        "gtest/googletest",
        "gtest/googletest/include"
    }

    includedirs {
        -- Ommited for brevity
    }
    files {
        -- Ommited for brevity
    }
    removefiles {
        -- Ommited for brevity
    }

The system then recursively iterates through all the items declared in the uses declaration for each project, caches the project dependencies and inserts all the dependencies as includedirs and links into the project. Every project is only touched once with this system to speed things up, and it auto-detects dependency cycles.

The pyro_module() function is used in the module premakes, and they auto declare thepublicincludedirs and publiclinks for the project so you can immediately do uses with the name of the module.

There are many other things it also does, like auto generating a documentation folder for each project and some other minor things, but that should be the gist of it all.

The code for this part is a bit of a mess, so I am not including it, but any decent programmer should be able to create a similar system in a weekend or two. The only hurdle is you should be comfortable reading the premake code as the API to do this is not documented, though it is used internally for everything.

That concludes the build-system of Pyro engine! As you can see some simple utilities can easily make life much easier. I hope this inspires you to create your own build system with Premake. Happy hacking!