The AI Series : What Is Artificial Intelligence — Really?

It’s not magic. It’s just a different way to handle spaghetti code. — By Sharad Bharadwaj

Image by author

I remember the exact moment I realised most companies have no idea what they are buying.

I was sitting in a conference room with a logistics client. They were losing money because their delivery trucks kept getting stuck in traffic or driving empty on return legs. The CTO looked me in the eye and said, “We have a smart routing AI, but it’s acting up.”

I got access to the repo. I was expecting a neural network, maybe some optimization solver like OR-Tools.

What I found was a single Python script. Inside were 4,000 lines of if-then-else statements.

• If traffic_level > 5 AND rain == True: add 15 mins.
• If driver == 'Steve' AND route == 'Downtown': use small_van.

It wasn’t AI. It was a panic attack written in code.

They were trying to mathematically model the chaos of the real world by hand. It worked when they had ten trucks. But at scale? Reality crushed them. A surprise parade closed three streets? The code broke. A driver called in sick? The code broke. They were hiring developers just to patch these rules every week.

We deleted those 4,000 lines. We replaced them with a Machine Learning model that simply looked at the last three years of driving history and figured out the patterns itself.

That is the difference. And that is what we are going to talk about today.

This isn’t an article about robots taking over the world. This is a look under the hood at what AI actually is for us builders: a tool to solve problems where standard logic fails.

The Engineering Reality: Logic vs. Statistics

If you strip away the marketing hype, AI is just a fundamental shift in how we build software. We are moving from Deterministic Logic to Probabilistic Math.

Here is the difference that actually matters to your career:

1. Traditional Software (Deterministic)

This is what you learned in CS 101. You, the human, are the god of the system. You define the rules.

• Input: A user types a password.
• Logic: You write code to compare it to the database hash.
• Output: Pass or Fail.
• The Reality: If it breaks, it is your fault. The computer did exactly what you told it to do.

2. Artificial Intelligence (Probabilistic)

Here, you resign as god. You accept that you don’t know the rules.

• Input: A photo of a handwritten check.
• Logic: You don’t write rules. You feed 10,000 previous checks into an algorithm. The algorithm creates a mathematical map (a Model) of what a “$50” usually looks like.
• Output: “I am 94% sure this says $50.”
• The Reality: If it breaks, it’s often nobody’s “fault.” It’s a statistical error.

So, what is AI really? It is not a brain. It is not conscious. It is a Function Approximator. It is a giant math equation that guesses the relationship between an Input and an Output because the relationship is too messy for a human to write down.

Why It Exists

Why do we bother with this? AI is expensive, slow, and sometimes wrong. Why not just write code?

We use it because of something called Polanyi’s Paradox, which states: “We know more than we can tell.”

Think about it. I can ask you to recognize your mother’s face. You can do it instantly. Now, I ask you to write a Python script to recognize your mother’s face using only pixel values.

• “Look for round eyes.” (What if she squints?)
• “Look for brown hair.” (What if she dyes it?)
• “Look for the distance between nose and mouth.” (What if she turns her head?)

You cannot do it. The rules are infinite. You know what she looks like, but you cannot tell the computer the rules.

This is the only reason AI exists: To automate tasks where the rules are implicit, not explicit. We stopped trying to teach computers rules and started showing them examples.

The Hidden Trade-Offs (What they don’t tell you)

This is the section most tutorials skip. When you switch from Code to AI, you aren’t just “upgrading.” You are making a massive architectural trade-off.

1. You Trade Transparency for Capability In that logistics script I deleted, I could point to line 340 and say, “This line caused the bug.” In a Neural Network, the “logic” is spread across millions of floating-point numbers (weights). If the AI denies a loan application, you often cannot say exactly why. You lose the “Why” to gain the “How.”

2. The Data Drift Nightmare Traditional code does not rot. If you write a calculator app, 2+2 will equal 4 in a hundred years. AI models rot. A model trained to predict housing prices in 2019 is useless today. The math hasn't changed, but the world has. This means you assume a permanent maintenance burden: you must constantly retrain your system just to keep it running.

3. The Latency Tax A traditional if-statement takes nanoseconds. A modern LLM call can take seconds. I’ve seen startups fail because they put a fancy AI model in a user flow that needed to be instant. AI is heavy.

Visualizing the Architecture

As an architect, I rely on diagrams to explain these risks to stakeholders. Here are three mental models that explain the “system reality” of AI.

Diagram 1: The Maintenance Crossing Point

This is the most important chart for budget conversations. Traditional code is cheap to start but gets expensive as you add complexity (spaghetti code). AI is expensive to start (data cleaning is hell), but it stays manageable as complexity grows.

Image by author

Diagram 2: The Probabilistic Pipeline

In traditional software, the code is the boss. In AI, the data is the boss. Notice the “Human Loop” at the end. Since AI is probabilistic (it guesses), you must have a fallback for when confidence is low.

Key Insight: If you build an AI system without a “Human Review” path for low-confidence guesses, you are building a system that will inevitably crash your business reputation.

Real-World Scenarios

Here is where I see this applied (and misapplied) in the industry.

1. The “Keyword Search” Failure (Legal Tech)

• The Problem: A law firm needed to find documents mentioning “indemnification.”
• The Old Way: They used SQL LIKE '%indemnification%'.
• The Failure: It missed every contract that used the phrase “hold harmless” instead. It’s the same concept, different words. Code can’t handle synonyms.
• The AI Fix: We used Semantic Search (Vectors). It understood that “indemnification” and “hold harmless” are conceptually close, even if the spelling is different.

2. The “Screw Inspector” (Manufacturing)

• The Problem: A factory needed to spot defective screws on a conveyor belt.
• The Old Way: A camera system with hard-coded rules: “If dark pixels > 50, reject.”
• The Failure: Every time the sun shifted and the lighting changed, the “dark pixel” count changed. The code rejected perfectly good screws.
• The AI Fix: Computer Vision. We showed it 5,000 photos of good screws and 5,000 bad ones. It learned to ignore the lighting and focus on the shape.

How Developers Can Level Up

If you are a developer seeing this wave coming, don’t panic. But you do need to pivot.

1. Stop obsessing over “The Model.” Freshers obsess over which model to use (Llama vs. GPT-4). Seniors obsess over the Data Pipeline. 80% of AI engineering is just plumbing — moving data from A to B, cleaning it, and storing it. If you know SQL and Python, you are already halfway there.

2. Learn to think in “Pipelines,” not “Functions.” In standard code, you write logic. In AI, you build a factory that produces logic. Your job shifts from “writing the rules” to “curating the examples that teach the rules.”

3. Master the boring stuff: Evaluation. How do you know if your AI is working? It doesn’t crash, but it might be lying. Learning how to measure “Recall” (did we find everything?) vs. “Precision” (was what we found actually correct?) is the difference between a toy and a product.

How Freshers Can Break Into This Area

I see hundreds of resumes. Here is how to stand out:

1. Don’t build a chatbot wrapper. Calling the OpenAI API is easy. It proves nothing.

2. Build the “Unglamorous” System. Go scrape a messy website. Clean the data (this is the hard part). Train a simple model to categorize it. Build a frontend to display it.

• Why this works: It shows me you can handle the dirty work of data engineering, which is what I actually need to hire you for.

3. Explain the “Why” in interviews. If I ask, “Why did you use AI here?”, the wrong answer is “Because it’s cool.” The right answer is: “I tried to write a Regex script first, but the data was too inconsistent, so I used a small NLP model to handle the variance.” That shows engineering maturity.

Final Thoughts

AI is the most powerful tool in our modern stack, but it is also the most dangerous.

It is dangerous because it is silent. When traditional code breaks, it crashes loudly. You get a stack trace. When AI breaks, it just gives you the wrong answer with high confidence. It quietly degrades your business while your dashboards look green.

The skill you need to cultivate is not just how to build AI, but how to mistrust it.

Use it to solve the impossible problems. Use it to unlock scale. But never forget that at its core, it is just a statistical guess. And it is your job as the architect to build the safety rails around it.