DEV Community: Bhuvi D

How did we get here ? - From Rule-Based Systems to Agentic AI

Bhuvi D — Fri, 27 Feb 2026 18:18:41 +0000

Hello there 👋

I’m writing this based on a Udemy course on Agentic AI, and I wanted to reflect on how AI evolved into what we now call agentic systems.

The Era of Rules: Symbolic AI

The story of Artificial Intelligence began with symbolic systems. Intelligence was primarily based on explicit rules and logical reasoning.

If you needed a system to compute something — let’s call it task A — you had to provide a strict chronological sequence of logical steps.

Now imagine the constraints.

There are countless tasks like A. We could not scale this. And ambiguity quickly became a problem.

What kind of ambiguity?

Consider lexical ambiguity:

“I saw her duck.”

Did she lower her head?

Or are we talking about her pet?

Rule-based systems struggle when meaning depends on context.

The Shift to Statistical Learning

Towards the 1990s, the field shifted toward statistical and machine learning approaches. Instead of relying on predefined rules, systems began learning patterns directly from data.

This was a major conceptual shift:

From explicit programming → to probabilistic modeling.

The Deep Learning Acceleration

The deep learning era accelerated this transition. With large datasets and GPU computation, models began learning hierarchical representations automatically.

This significantly advanced vision and language-based tasks.

Instead of telling systems what features to look for — they learned them.

Generative AI: Pretrain at Scale

Generative models extended deep learning even further.

They enabled:

Few-shot learning
Natural language interactions
Multimodal understanding

However, these systems primarily generate outputs in response to prompts.

Input → Model → Output.

Powerful — but reactive.

The Agentic Pivot

Agentic AI represents a structural evolution.

We are now talking about the seamless integration of:

Autonomy
Memory
Tools
Multi-agent coordination

This enables AI systems to independently execute tasks once a goal is set.

Models now:

Reason
Act
Use tools
Update memory
Adapt iteratively

The shift is architectural.

We moved from systems that respond to systems that act.

Final Thought

Generative AI produces outputs.

Agentic AI executes workflows.

And that difference might define the next era of AI systems.

If you're exploring agentic systems, I’d love to hear how you're thinking about autonomy, memory, and orchestration in your own projects.

How Drone Imagery with AI can transform farming - Learnings from a canceled Hackathon

Bhuvi D — Sun, 15 Jun 2025 14:25:56 +0000

A few weeks back, I decided to participate in a Hackathon with a few friends. The topic was based on developing tools to make farming more efficient and sustainable.
The event was unfortunately canceled 🙁, but the topic continued to intrigue me.

I found myself diving more into the topic and would love to share my learnings.

The problem statement we came up with was: 'Using drones with multispectral & thermal imaging, geospatial data, and AI to transform the current blanket farming into a sustainable, precision-based agriculture system.'

Current farming practices rely on 'blanket applications' of fertilizers, water, etc. However, this is not a sustainable practice. Imagine the impact excess use of fertilizers could have on the quality of soil in the long run. Think of the amount of water that is wasted on irrigating without direction.

Image from Google

Now coming to the interesting metric or solution is based on. NDVI stands for Normalized Difference Vegetation Index.
A score >0.33 indicates rich vegetation + high chlorophyll content.
A score <0.33 lies in the red-brown spectrum indicating poor vegetation.

My Architecture diagram

The architecture for our solution is simple -

🌿 Drones equipped with multispectral and thermal cameras capture detailed images of the field.

🌿 These images will then be processed into NDVI maps and thermal maps (using tools like QGIS).

🌿 The maps are combined using geospatial tools (like GeoPandas) to show variations across the field by tagging them location-wise.

🌿 AI/ML models analyze the data to identify crop stress, soil issues, and pest risks by classifying it.
To discuss the kind of tagging/labelling for AI models -
Ex: A low NDVI score + high temp ( captured using thermal map data) —> low moisture area —> hence need more irrigation.

🌿 The system provides real-time, zone-specific advice for targeted spraying of fertilizers, or irrigation.

🌿 Farmers receive valuable insights via a dashboard, enabling smarter, affordable precision farming.

The solution is modular and accessible, especially with the current advancements in drone technology.

AI generated visual

For now, I wanted to share all of this, I am keenly looking into datasets, etc which will help me build a functional model.
I am looking forward to any insights from you 😊

Diving into Next.js - My 2-Week Learning Experience

Bhuvi D — Wed, 11 Jun 2025 17:48:15 +0000

For my internship, I am working on a deployed product with hundreds of users. I was familiar with React but not with Next.js. I was given a two-week learning phase to familiarize myself with Next.js and get started.
Firstly, Next.js is a framework built on top of React by Vercel. It is used in many production-level projects.

The reason: file-based routing, SEO support, multiple CSS features, instant UI retrieval from the server, creation of API endpoints within the project itself, and loads of other features.
You can read about this in detail here - link.

To learn Next.js quickly and just get a grasp of the significant features, I made use of the official documentation tutorial.

Here are some key useful points from the tutorial:

➡️ Next.js is highly compatible with Tailwind CSS and will install modules automatically if chosen. Alternatively, one can also create CSS modules, the major benefit of doing either is the ability to evade style collisions and apply styles to components easily.

➡️ Next.js optimizes font retrieval, it hosts font files to reduce the number of requests made while rendering custom fonts for a website.
The cooler part, however, is image optimization. Those who have worked with HTML will be familiar with the problem of optimizing an image for different screens, be it the dimension or layout, and the next/image does this automatically.

➡️ Personally, while working on my tasks, the thing that made code tracing so easy was the file-system routing. The URL is mapped to route segments. Each route has a page.tsx or page.jsx which exports the visible components. There is additionally another standard file called layout.tsx for components shared between multiple pages (navigation bars, etc.), so re-rendering for every page is avoided. The <a> tag in HTML initiates a complete refresh on link routing, whereas the next/link prefetches code for the linked routes, thereby making link navigation almost instantaneous.

➡️ The next part deals with understanding APIs and DB connectivity. Next.js uses React Server Components, so there is no need to maintain API layers while dealing with the backend for small applications, as databases can be queried directly. Larger applications, including the one that I worked on, need an explicit modular API layer for scalability and security.
As an example, if the requirement was to fetch the number of transactions made in a case, using JS would mean fetching data and using an array method to compute the count, but using an SQL query directly is much easier.

➡️ Most websites, including the one I worked on, require data to be dynamically rendered. Data fetching can be slow at times. Loading.tsx is a special file that can contain UI to be shown while the data is being fetched.
You might have observed loading skeletons, this is to improve the user experience while waiting for data retrieval.
Streaming the entire page may not be needed in all cases, the slow fetching might be due to a few components. React's Suspense allows certain parts of the page to be loaded after the main UI is displayed. Suspense boundaries can be created based on the requirement.

constructing a skeleton with tailwind utility classes

export function TableRowSkeleton() {
  return (
    <tr className="w-full border-b border-gray-100 last-of-type:border-none [&:first-child>td:first-child]:rounded-tl-lg [&:first-child>td:last-child]:rounded-tr-lg [&:last-child>td:first-child]:rounded-bl-lg [&:last-child>td:last-child]:rounded-br-lg">
      {/* Customer Name and Image */}
      <td className="relative overflow-hidden whitespace-nowrap py-3 pl-6 pr-3">
        <div className="flex items-center gap-3">
          <div className="h-8 w-8 rounded-full bg-gray-100"></div>
          <div className="h-6 w-24 rounded bg-gray-100"></div>
        </div>
      </td>
      {/* Add more <td> skeleton cells here based on your table structure */}
    </tr>
  );
}

➡️ Next.js has client hooks like useSearchParams() and usePathname(), which help in accessing parts of the URL. The useSearchParams() hook enables us to get parameters from the client without hitting the server.

➡️ The next interesting part is the graceful error handling. JS uses try-catch blocks for error handling. The file will contain an error object along with a reset client-based function to re-render the route.
Form validation can be done on the client side using simple constraints such as required.

client component with error and reset

'use client';

import { useEffect } from 'react';

export default function Error({
  error,
  reset,
}: {
  error: Error & { digest?: string };
  reset: () => void;
}) {
  useEffect(() => {
    console.error(error);
  }, [error]);

Server-side validation, however, is needed to ensure the right data is entering the database and no malicious attempts occur on the client’s side.
Authentication and authorization: NextAuth.js abstracts and simplifies much of the process involved in verifying the identity of someone initiating a login.

Thanks for reading 😊
Please feel free to share your thoughts and insights.

I took the AWS Cloud Practitioner Essentials course, and here's what I learned.

Bhuvi D — Wed, 04 Jun 2025 14:46:49 +0000

I just completed the course titled 'AWS Cloud Practitioner Essentials' today.
Just wanted to share a few things I learned :)

(Note: This is a certificate of completion from AWS’s beginner-level course, not the Cloud Practitioner certification exam.)

Firstly, to give an overview of the course itself - it's a great course, it has this coffee shop metaphor, to explain the concept of setting up a business on AWS. Certainly made it easy for me, as I had zero prior knowledge of Cloud.

The first part of the course deals with what a client-server model is, followed by why one must migrate to cloud-based deployment. There are multiple benefits. Relying on physical data centers as a company is not a good idea, considering the cost needed to set up and keep them running. Additionally, companies lose the ability to scale conveniently.

After migrating to the cloud, the use of infrastructure becomes flexible, you can pay based on resources used, and don't have to make predictions beforehand.

You can read about some advantages of cloud computing here - [Link]
The next section of the course deals with Amazon EC2 (Elastic Compute Cloud) which basically offers a platform to run instances.
So the first step in the whole process is to launch an instance. One must choose various configurations including OS, application server, etc. along with hardware configuration and security settings.

The interesting part is that this allows businesses or individuals to manage virtual servers without having to invest in physical infrastructure. (Note: EC2 is not serverless. For serverless computing, AWS offers Lambda.)

Next, one can connect and use the instance.
Depending on the need of the applications one can choose from 5 different types of instances. The idea is to choose the instance based on your specific CPU or memory requirements. The section also deals with pricing plans, to optimize and make it fair for the users.

Here is a visual I created to get an overview of the types of instances -

There is also another important concept of the Elastic Load Balancer discussed. It can be thought of as a mediator cum distributor, which directs the incoming requests from customers to various instances.
This is particularly useful if you receive more than expected traffic to your hosted service, and need to evenly distribute it for optimal delivery.

Amazon SNS and Amazon SQS (Simple Notification Service / Simple Queue Service) are services that can be integrated into applications to facilitate the design following a microservices approach instead of a monolithic approach.
This means that when you have 2 or more components in an application, instead of tightly coupling them (monolithic), where the failure of a single component causes the entire application to fail, the microservices approach ensures that components continue to communicate with each other in case of failure via services.

Personally, the most interesting part of this course for me was the global infrastructure setup of AWS. That is how they ensure that systems continue to run even in the case of disasters.
Setting up or we can say choosing a data center region in this case, will be dependent on factors like - proximity to customers, compliances, etc.
Now AWS recommends running EC2 instances on multiple Availability Zones. Availability zones consist of a single data center or a group of data centers within a single region. So let's say somehow a natural disaster causes the destruction of a data center, there is still another availability zone situated in the same region to ensure the running of applications. The key point here is the low latency yet safe distance between availability zones.

The subsequent part of the course discusses ways to interact with AWS resources - this can be done using AWS Command Line, Management Console, or Software Development Kits.

Now there are some cool network configurations available to enable a more secure and direct connection from private networks to AWS resources/instances. You can explore more on VPC here - [Link]
The Virtual Private Cloud (VPC) enables one to create an isolated portion of the cloud with Subnets. An internet gateway must be used to access the VPC.
AWS Direct Connect allows you to establish a one-to-one connection between a corporate data center and the VPC.

To enable security, there are network ACLs (Access Control Lists) present at the subnet level and Security Groups present at the instance level.

The following model is fundamental to AWS in ensuring security agreements: the Shared Responsibility Model.

Screenshot -

I feel the other parts of the course are more specific to what AWS can offer and are definitely worth exploring if you plan to host applications on the cloud.
Overall, I feel the course has given me a holistic and high-level understanding of the fundamentals of AWS.

Note: As it may have been evident, I am a beginner, I certainly will appreciate inputs from those with a deeper understanding.

Thanks,
Have a great day!!

Bhuvi （￣︶￣）↗