DEV Community: Aazan Noor Khuwaja

Why Is the Shortest Route Sometimes the Worst? My take on Adaptive A* Algorithm.

Aazan Noor Khuwaja — Sat, 14 Mar 2026 18:28:11 +0000

The second research article I read recently is Adaptive A* Algorithm for Dynamic Routing, and after analyzing it, it totally changed my perception of navigation apps (Google Maps) used in everyday life and problem-solving.

I use standard GPS routing daily (as well as the overwhelming majority of people). It is very effective in searching for the shortest distance between point A and point B. Nevertheless, reading this article, I was exposed to a critical weakness of the conventional navigation, particularly in electric vehicles (EVs): the most direct line is pointless when it gets you stuck with a flat battery.

The Adaptive A* Algorithm is an autonomous, forward-thinking navigator instead of just adding up a fixed, static route before getting in your car. You give it a place to go, and it actually tracks real-time traffic, battery depletion, and where charging stations are, and it changes its course on the fly with minimal or no human intervention.

The Brain of the Revelation of the Algorithm. I had to understand how this algorithm was able to pull this off without it having to freeze or even take minutes to recalculate. Coincidentally, developers are improving the traditional A search with a very dynamic brain.

This is a system that depends on some brilliant upgrades, which are broken down in the paper:

Dynamic Heuristic: Standard A* This is based upon a fixed heuristic (guess) of the distance to the goal. Adaptive continuously changes this guess according to changes in real life, such as sudden traffic jams or a reduction in temperature, to affect the battery of the car.

Prefers Energy over Distance: It does not only consider miles. It compares the cost of a route depending on the energy consumption. A steep and short hill may be more expensive than a long, flat road.

State Preservation (Memory): This was the most interesting part to read. When the map is modified, the standard algorithms discard all the information and compute everything afresh. Adaptive A stores the portions of the map that were not altered, which saves tremendous units of processing power. It is a literal shortcut to the plan redraw and trying to start afresh.

Of course, the dynamic navigation system cannot be tested simply by providing a question regarding whether the system has reached the destination. The authors described the comprehensive method of evaluating this algorithm. Instead of just considering the last route, they consider the AI because of computation time (how fast can it recalculate in milliseconds?), energy efficiency (saved battery over standard routes?), and nodes explored (how well did it search the map without exhausting its memory?).

Restrictions are possible, but it is not all perfect. The article was rather categorical regarding the complexity of real-life implementation. But the largest problem is that of Data Dependency--the algorithm is as good as the live traffic data and weather data it is fed with. The adaptive nature is disrupted in case of sensor malfunction or the loss of the 5G connection. The other issue is the computation cost of the car's internal hardware; the continuous updating of huge graph networks needs heavy processing power.

This paper was a summation of it during my AI course. We have just been literally writing code in Python to create graph networks with NetworkX to trace the routes in cities with BFS (Breadth-First Search) and DFS (Depth-First Search). Surprisingly, this paper applies the very concepts that we study in the classroom, the cities being the nodes and the cost of the path (weight) being the edges, and scales it to the real world. As opposed to a plain and straightforward map of Romania, these algorithms follow delicate and dynamic digital road systems to hit their targets safely.

It is a truth to say that when I first saw the enormous mathematical equations that were the heuristic updates in the paper, they looked to me like an entanglement of complex calculus. But just to have a sample of the subject, I decided to save the PDF at Google NotebookLM and asked it to explain the "adaptive" update step simply. It instantly gave me an analogy of genius: it equated the algorithm to a driver who is presented with the sign that the road is closed and merely recalculates the ETA of just the impacted streets and does not forget the entire map of the city. Even that experience superimposed all the dense academic wording and made the entire graph math understandable.

The Adaptive A* algorithm is not only an ingenious line of reasoning but also the basis of intelligent, self-directed transportation. And then, when we have read this paper, I am most impatient to find out how we write these dynamic heuristics ourselves.

And a short video summary in which I further explained what I researched in this research paper.

Video:

I would like to thank my teaching assistant, @raqeeb_26 who assisted in exploring the work relating to the research.

What Happens When AI Stops Waiting for Your Prompts?

Aazan Noor Khuwaja — Sat, 14 Mar 2026 18:06:47 +0000

I recently read a study paper titled "The Rise of Agentic AI, which entirely changed how I view technology's evolution.

I utilize a typical generative AI almost every day, just like the vast majority of us. It is so intelligent, yet I have understood that it is also 100% passive. It merely sits there waiting to be prompted and returns text. However, as I read this paper, I got exposed to an enormous transformation towards agentic AI.

Rather than merely responding to questions, Agentic AI is an independent, purpose-directed computer employee. You provide it with a task to accomplish, such as Plan my whole travel itinerary and book it within my budget, and it literally sits there and uses the internet to do it, with little to no hand-holding.

The revelation of the brain of the AI. I needed to know how these agents pulled this off as I continued to read the paper. It happens that developers are creating architectures that replicate human thought.

This brain is divided into several interesting modules, which the paper breaks down:

Profile: To begin with, the AI is assigned a particular persona, such as a "Senior Python Developer" or a "Financial Analyst," on which it is based.

Memory: It is similar to us in that it possesses short-term memory regarding the activity at hand, but above all, it has a long-term memory. It keeps the past wrongs in memory to avoid them.

Planning & Action: This made the most interesting part to read. The agent takes an overwhelmingly objective approach and divides it into small, actionable units. In case it encounters an error in code execution or web searching, it does not shut down and wait until I fix it. It is a literal criticism of its own error, a revision of its plan, and an attempt to begin again.

When Agents Team Up, the part that truly left me astonished was that of multi-agent systems. One AI is nothing when you can have an entire team. The study points to structures where there is a society of AI developed by developers. The manager agent decomposes a software project, gives the code to a developer agent, and hands the output to a tester agent. They share ideas, discuss, and resolve issues.

Assessment of the AI (Evaluation Metrics): Naturally, an autonomous system cannot be tested by a multiple-choice test. The researchers outlined the difficulty of the process of assessing these agents. Rather than simply taking the final result, they evaluate the AI based on Task Success Rate (has it successfully done the job?), Efficiency (how many API calls did it make non-useful?), and Robustness (how well does it cope with unexpected errors?).

Blocks Ahead: But it is not all perfect. The article was quite definite on how difficult things have become. Security is a huge issue--they can freely surf the web and execute scripts; therefore, they are the best targets of hackers. Another problem is also the problem of coordination chaos, where the various agents may find themselves in indefinite loops arguing against each other. And the biggest question is whether, in an autonomous AI, the worst financial trade occurs or files with valuable information are deleted, who is responsible?

During my AI course, this paper brought it all together when related to our AI lectures. We have been studying rational agents working in the PEAS (Performance, Environment, Actuators, Sensors) framework. Remarkably, Agentic AI uses the standard utility-based agent that we analyze in the classroom and up-scales it to the contemporary web. These agents do not operate on a simple grid in 2D but rather have web APIs as actuators and live internet data as sensors; they navigate tricky digital worlds to strike their targets.

My NotebookLM "Aha!" Moment To tell the truth, at the moment when I initially looked at the architectural schemes in the paper, they seemed to me like a maze of flowcharts of the first order. However, I chose to save the PDF in Google NotebookLM and requested it to describe the coordination of the team in a simple fashion. It immediately provided me with an analogy of genius, of the reactive and deliberative loop being compared to human reflexes and strategic planning. Even that one encounter layered all the thick academic verbiage and rendered the whole system orchestration comprehensible.

The agentic AI is not only a new tool but also the start of a digital workforce. And when we have read this paper, I am terribly eager to know what we are going to put up with next.

And there is a brief overview in video form in which I explained what I explored in this research paper further.

Video:
All thanks to @raqeeb_26, our teaching assistant, for helping us to explore the research-related work.

This is My First and Last "Vibe Coded" Product

Aazan Noor Khuwaja — Wed, 04 Mar 2026 20:58:38 +0000

If you think you can just sit back and let Copilot or Cursor build a complex desktop-to-browser architecture for you, let me stop you right there. The AI completely f*cked my codebase at the start. It wrote brilliant functions, confidently deleted them two prompts later, and introduced bugs that kept me awake for days during my sessional exams.

This is the story of how a simple script to survive load shedding turned into a two-week debugging nightmare, and why FlashYT is the last app I will ever "vibe code."

Story:
If you live in Pakistan, you know the drill. You plan out your day, sit down to grind through some university lectures or a new tech skill, and suddenly—the power goes out. The Wi-Fi dies.

To survive the load shedding, I started using yt-dlp to download my study materials. But let's be honest: I am lazy. Having to open a terminal, paste a URL, and manually type out format flags every single time I wanted a specific 1080p video was a terrible user experience. I just wanted a simple button next to the YouTube player.

I initially threw together a quick Tampermonkey script connected to a Python FastAPI backend. It worked beautifully on my laptop. Feeling proud, I shared it with a friend who had the same problem.

We set it up on his machine, and... it completely failed.

At that point my ego was genuinely hurt. This failure sent me down a rabbit hole. I started researching why so many popular YouTube downloader extensions eventually break or get removed. The answer was simple: they route traffic through central servers, which eventually get flagged and blocked.

I realized the only way to build a tool that survives is to make the user their own server. I discovered Chrome's "Native Messaging" API, which allows a browser extension to talk directly to a local Python script running quietly on the desktop. No cloud, no IP blocks, just a seamless, 1-click download right from the YouTube interface.

The Nightmare of Vibe Coding:
Since this architecture was completely new to me, I decided to test the current state of AI. I tried to "vibe code" the whole thing, commanding LLMs like Copilot and Cursor to write the logic without me deeply understanding the foundations first.

It was my first time relying this heavily on AI, and I can confidently say it will be my last.

For two weeks, right through my 4th-semester sessional exams, I completely forgot about sleep. The AI would write a brilliant block of code, only to confidently delete it two prompts later. It would "fix" one bug by creating three new ones. And right when I was deep into tracing a critical error, the models would hit their usage limits, leaving me staring at broken code at 4 AM.

Debugging AI-generated spaghetti code when you don't fully grasp the underlying system is pure torture. I almost gave up.

Then, my sister asked me for a tool to download some YouTube videos. That was the push I needed. I stopped blindly trusting the AI, started actually reading the docs, fixed the architecture myself, and finally stabilized the native host connection.

Now Finally FlashYT is Alive:

Today, I am open-sourcing FlashYT. It works on Linux, Mac, and Windows. It adds a simple "Download" button directly to the YouTube player, fetches exact qualities instantly, and downloads up to 4K video seamlessly.

It is completely free, open-source, and has zero ads.

Is it perfect? No. It’s still in the testing phase, and there are plenty of edge cases to iron out. But it solves the exact problem I set out to fix.

If you are tired of shady download websites, give FlashYT a try. Check out the repo, install the beta, break it, and let me know what needs fixing.

🔗 Repo & Installation: https://github.com/aazannoorkhuwaja/FlashYT