Back to blogYouTube Video

Published September 6, 2026

Not everything needs to be an AI agent

Can't play the video or having issues? Here's the direct link.

AI Summary

The video argues against the indiscriminate use of AI agents and LLMs for deterministic tasks, using a GitHub project's AI-driven installation prompt as a primary example of misuse. The creator demonstrates that installing the SQL interface requires only a handful of standard shell commands (curl, clone, gradle, cmake) — a process that is cheap, fast, and guaranteed to produce identical results every time. In contrast, delegating this to an LLM introduces non-determinism, hallucination risks, unnecessary token costs, and security concerns from executing unvetted, variable outputs. The core thesis distinguishes between two tool categories: deterministic code (reliable, repeatable, ideal for defined workflows like installation, builds, and infrastructure) and LLMs (probabilistic, reasoning-capable, suited for ambiguous or complex decision-making). The creator advocates for a hybrid architecture where LLMs *write* the deterministic code, but agents do not *execute* the workflows, warning against the hype that everything must be 'agentic.'

Key Takeaways

  • Match the tool to the problem class: use deterministic code (scripts, binaries, CI/CD) for repeatable, well-defined procedures (installations, builds, deployments); reserve LLMs for tasks requiring reasoning, ambiguity resolution, or unstructured data processing.
  • AI-driven installation prompts are an anti-pattern: they replace a free, instant, auditable shell script with a slow, expensive, non-deterministic, and opaque LLM execution that cannot guarantee idempotency.
  • Non-determinism is a liability in infrastructure: if a process must produce the exact same filesystem state, environment, or artifact every run, statistical models are the wrong abstraction layer.
  • Security and auditability favor static code: a shell script or binary can be reviewed, pinned, and hashed; an LLM prompt executing variable commands cannot be fully vetted before runtime.
  • Cost and latency compound at scale: burning LLM tokens for routine automation (e.g., `curl | bash` equivalents) wastes budget and introduces latency where a local script executes in milliseconds.
  • LLMs are best used as code generators, not runtime engines: have the model write the installation script, CI pipeline, or Terraform module, then commit and run that deterministic artifact — do not invoke the model at execution time.
  • Resist 'agent-washing': not every CLI, installer, or workflow benefits from an agentic layer; simplicity and reliability often come from removing the probabilistic middleman.
  • Hybrid workflows maximize reliability: deterministic orchestration (Make, Bash, Python, GitHub Actions) + LLM-assisted generation = robust, maintainable systems without runtime surprise.

Description

Book a call: https://calendly.com/itshassanaziz/discuss-a-project ==== ==== ==== WHAT'S THIS VIDEO ABOUT? A GitHub project recommends installing its software by pointing an AI agent at a markdown file instead of just running the install commands yourself. I get into why that's a bad idea: LLMs aren't deterministic, so the same install prompt can behave differently each time, while a plain script or a handful of bash commands will run the same way every time and cost nothing in tokens. Code and LLMs solve different problems, and knowing when to use which one will save you a lot of headaches. Like, subscribe, & leave me a comment if you have a specific request. Thanks. ==== ==== ==== TIMESTAMPS 00:00 Intro: AI Hype Take 00:14 GitHub Project Example 00:48 Why LLMs Are Non-Deterministic 01:28 The Install Is Actually Simple 02:03 Risks of AI-Run Markdown Files 02:38 Bun.sh Install Script Comparison 03:27 Understanding Deterministic Code 04:20 When Code Beats AI Agents 04:51 Lesson: Code vs LLMs 05:15 Stop Falling for AI Hype 06:04 Closing Thoughts WATCH THESE NEXT https://www.youtube.com/watch?v=OmV52jkTnjE https://www.youtube.com/watch?v=O8bxVFDcsIE https://www.youtube.com/watch?v=lt41ujdXZVY ==== ==== ==== WHY LISTEN TO ME? Hey everyone, I'm Hassan. I run an AI/Automation and Software Development agency at hassandev.me. I've built custom workflows that save clients 20+ hours every week. I've helped businesses solve CRM issues that directly led to an increase of $430k CAD in quotations. I've scaled platforms to 100,000 users and beyond. I also enjoy making content and sharing what I learn with the world. I love to yap on YouTube, as you can see. I'm very active here, and on X, so if you want to reach out to me, leave a comment or DM me on X. MY LINKS Website: https://www.hassandev.me Portfolio: https://www.hassandev.me/work YouTube: https://www.youtube.com/@itshassanaziz?sub_confirmation=1 My Book: https://www.hassandev.me/designing-websites X / Twitter: https://x.com/intent/user?screen_name=nothassanaziz Instagram: https://www.instagram.com/hassansdev/ LinkedIn: https://www.linkedin.com/in/hassan-aziz-web

Transcript

Auto-generated transcript
Hey, what's going on guys? I want to talk about AI and how despite all the hype behind it, it is not as valuable of a technology as people make it out to be and not everything needs to be an AI agent. So I came across this project on GitHub, which is basically some SQL interface for some database that I've never heard of. But the part that stood out to me is that they recommend installing the entire thing with a prompt with an ai agent prompt and if you look over here this is literally just a markdown file that tells you how to install the entire thing and some of you might think this is actually a good thing this is not this is a horrible horrible use case for an ai agent there's a horrible use case for an llm you should not be doing something like this with ai so basically this whole markdown file is going to tell your ai agent what exact commands it needs to run to install this sql interface the only problem is llms i've talked about this a thousand times already they're non-deterministic they're hallucinatory if you want to consistently run a set of commands every single time the exact same way in the exact same order you need an installation script you need code you need deterministic code that's guaranteed to run the same way every single time right you're not going to get that from a markdown file that some statistical model is going to run differently every single time you run it And what even crazy is the steps that this Markdown file is trying to automate aren even all that difficult like all you have to do is grab the distribution from the releases page this is very easy you can do this with a curl command very easily you clone the repo basic shit you just build it with gradle and cmake over here and you basically have the entire program built and able to run on your computer it's like five or six commands and you're trying to automate it with some ai agent that's going to cost you so many expensive LLM tokens each time you run this. Not only that, but it's not even guaranteed to run the same way every single time. It's a horrible way to solve this problem. Not only that, but just the idea of executing some random markdown file with an AI agent just seems so mind-boggling to me. Like, yeah, just point your LLM to some random markdown file that some guy wrote and deal with the consequences. Who knows what could happen, right? I'm not a huge fan of these kinds of installation scripts that just run some custom code on your computer But even they are much better than having installation prompts that prompt an AI agent to run something on your computer an example is bun dot sh and one is just a JavaScript runtime like node.js, right and If you want to install it, you have to run all of this custom code over here, right? This is the installation script There are still dangers with executing these custom installation scripts on your computer You don like you never know what in them unless you actually review the code which almost nobody is gonna do Especially now that AI is writing all of this thousands of lines of code But the benefit here is that this is code right This is deterministic code It going to run the exact same way every single time. It's going to create the same folders with the same names, going to create the same files. Everything is going to be the exact same, right? But when it comes to this installation prompt over here, you don't get that guarantee. It's going to run slightly differently every single time. It might work some of the time, but it's also going to produce some really weird and hard to catch bugs many different times. So I know I bash LLMs a lot on my channel, but I'm really not against them. Like I just think they have certain use cases and I think deterministic code has certain use cases. There's a big thing with code is it's deterministic, right? And I say this word a lot on my channel. All it means is that this code is guaranteed to run the same way every single time, right? You can't say the same thing about LLMs. They're always gonna be slightly different. they're going to vary slightly, very, very slightly in their output every single time you run the exact same prompt, right? So there are certain use cases where code is useful, and there are certain use cases where LLMs are useful. But when it comes to something like a deterministic action, which an installation script definitely falls under, you should be using code, right? Like installing this software does not require any reasoning. It does not require some really vague, really complex steps that you can represent in code it literally just a bunch of bash commands you can run you can literally copy and paste them in your terminal and you have the entire program up and running in less than a minute so the fact that you using a prompt over here and a non deterministic machine to execute it instead of just using pure code that going to be cheaper faster and more reliable is just mind-boggling to me so that's the lesson for today right understand that code and llms are solving different problems you can't just replace one with the other you need both right you need code for the deterministic parts of your application so that you can actually make them more reliable. And you need LLMs for the non-deterministic reasoning kinds of tasks in your applications so that you can solve those without necessarily having to go through a lot of code to represent all those states, right? And please, for the love of God, stop falling into the hype of AI. It is not as revolutionary as many people seem to make it out to be. The technology isn't that advanced. It has many use cases. I'm using it all the time, every single day, but just don't fall into the hype that everything needs to be an AI agent, because it doesn't, right? Like the amount of problems you can just solve with traditional deterministic code is insane. And you don't even need LLMs for all of that. You can use LLMs to write the code, but you don't even need an AI agent to actually execute it, which is insane. The amount of complicated tasks you can run reliably and execute as many times as you want with just pure code. It's insane. So don't fall into the hype. Not everything needs to be an AI agent. Try to make your AI workflows as deterministic and reliable as you possibly can, and you're going to have a good time. Hope that was helpful, and I'll catch you in the next one.

Share this article

All great things started with a conversation

If you've got a cool project or opportunity and you want me to be a part of it, set up a free meeting with me here, and let's talk. 😊