Hype-driven CEOs: when innovation misses the point
More and more, we are being pulled away from truly important issues to satisfy executives obsessed with superficial innovation.
Yes, we’re being pulled away — from essential topics like accessibility, which are often overshadowed by technological distractions. A 2024 study by WebAIM analyzed the top 1 million homepages worldwide and found that 96.3% had detectable accessibility issues, with an average of 56 errors per page — highlighting how far digital accessibility still is from being a priority.
A friend working on an MVP for a GPT-integrated search engine told me that, initially, the project leads asked to scale back testing due to the high cost of tokens. Soon after, they suggested standardizing responses to further reduce token consumption. Unbelievable! They ended up recreating the same old chatbot that traps users in an endless loop of generic responses, offering no real solution.
This was the motivation behind writing this article.
It’s better to be prepared to think critically and strategically rather than just feed another empty case study on LinkedIn. I want to introduce practical and accessible exercises, especially for those who have never written a single line of code. This is not about deep technical expertise but about giving designers a starting point to better navigate AI-driven projects. The goal is to help them interpret technical discussions, challenge trends, and identify real solutions — instead of slapping the word GPT onto a product as if it were a silver bullet.
Hype and misplaced priorities
This doesn’t mean AI isn’t important — it just highlights a misalignment of priorities. The real commitment should be to the people using our products and solving actual problems, not blindly chasing the latest tech trend.
Many companies don’t actually want to solve problems with AI — they just want enough of an impact for presentations, reports, and LinkedIn case studies.
It’s always the same story:
- Decision-makers return dazzled from industry events, impressed by flashy AI demos.
- But they have no concrete plan for implementation.
- Specialists are pulled from their strategic projects just to validate exaggerated expectations.
- Grand roadmaps are created that keep corporate narratives spinning without ever moving forward.
How much have these AI enthusiasts actually invested in machine learning over the years?
Without a real foundation, there is no magic solution.
“If AI only made it onto your roadmap because your boss got excited at an event and wants something like the competition, chances are your product doesn’t actually need AI.”
Some companies do it right. Netflix and Spotify have years of experience using machine learning to optimize recommendations and personalize user experiences. In healthcare, solutions like NeoMed’s Kardia accelerate heart attack diagnosis, while others apply AI to clinical data analysis, assisted diagnosis, and treatment discovery.
These examples prove that AI adds real value when built on strong data foundations and clear objectives. Without those, AI is just another buzzword disguised as innovation.
The UX impact of poorly implemented AI
AI adoption directly affects user experience. One of the most common pitfalls is the chatbot trap — companies rush to implement AI to cut costs, but the end result frustrates users instead.
Users get stuck in an endless cycle of “I didn’t understand” responses, leading them to abandon the chatbot entirely. Instead of helping, these AI implementations create more barriers than solutions.
Another example: Recommendation algorithms.
- Some AI models overdo personalization, making it harder for users to discover new content.
- The lack of UX-driven AI planning leads to experiences that feel monotonous and predictable.
AI that fails UX is AI that loses user trust.
Common AI pitfalls
Friends working on GPT-based projects have shared some recurring issues:
1. Inconsistent tone of voice
Problem: GPT doesn’t match the brand’s identity, flipping between formal and casual tones.
Impact: Requires constant prompt engineering to maintain consistency.
2. Biases in data and responses
Problem: GPT is trained on internet text, leading to biased and misleading outputs.
Impact: Reinforces stereotypes, excludes groups, and spreads inaccurate information.
3. High token costs due to redundancy
Problem: GPT lacks continuous memory, forcing excessively long prompts for context.
Impact: AI-driven products become expensive to operate at scale.
Beyond that, major consultancies and system integrators often push GPT-based solutions for convenience, without considering better alternatives. Many decisions are made not based on technical feasibility but on how easy it is to sell a big-name AI brand.
The cost of keeping a system running on expensive tokens could be better invested in infrastructure and custom open-source models — but those options don’t generate the same revenue for vendors selling GPT integrations.
Let’s get this straight: GPT is amazing, BUT…
Tools like ChatGPT, DeepSeek, and others have made AI mainstream — and that’s exciting. But LLMs are not always the best choice for MVPs and scalable products.
They’re powerful, but not universal solutions.
Deploying LLMs without critical thinking leads to high costs, slow responses, and products that don’t actually solve real problems.
“The saddest aspect of life right now is that science gathers knowledge faster than society gathers wisdom.” — Isaac Asimov
AI didn’t appear overnight. It’s the result of decades of research, refined algorithms, and increased computing power.
In Uncle Tungsten, Dr. Oliver Sacks describes his childhood fascination with the elements of chemistry, intertwining it with the history of tungsten filament lamp evolution. That book helped me understand that scientific discovery precedes commercial application.
We must question the logic of prioritizing technology before defining real problems.
What happens when hype takes over?
Concepts like the Metaverse, NFTs, Gamification, and Augmented Reality had real potential but were reduced to superficial trends by misdirected hype. AI may be heading down the same path, with companies adding “AI” without a clear understanding of the problem they are trying to solve.
1. Metaverse
A digital universe with potential for education, remote work, and entertainment.
Where it went wrong:
- Meta’s hype focused on awkward avatars and virtual land speculation.
- Low accessibility (expensive VR headsets, poor interfaces).
2. NFTs
Digital ownership authentication, useful for art and gaming.
Where it went wrong:
- Became speculation and pump-and-dump schemes.
- Overflow of meaningless collections.
3. Chatbots and Virtual Assistants
Automated customer service and intelligent assistants.
Where it went wrong:
- Limited bots that just say “I didn’t understand.”
- Companies trying to replace humans instead of improving experiences.
4. Augmented Reality (AR)
Digital interactions overlaid on the real world, useful for education and gaming.
Where it went wrong:
- Hype around revolutionary AR glasses that never arrived.
- Useless apps (like QR codes that just open PDFs).
5. Gamification
Using game mechanics to boost engagement in education and productivity.
Where it went wrong:
- Companies only implementing point systems without real engagement.
- Apps forcing meaningless competition.
Hype, however, isn’t entirely negative. Without it, we might not have progressed as quickly in applying AI to medicine and automation. The key is to channel this energy not into a hollow race for innovation but as a catalyst for real and valuable discoveries.
Why are we adopting AI?
Everything comes down to the quality of the question, not the certainty of the answer. The real issue is not whether we should adopt AI, but why we are doing it. Enthusiasm can lead to adoption without critical reflection, resulting in superficial products with no real purpose.
In practice, what truly makes a difference is understanding the fundamentals — distinguishing Machine Learning, LLMs, and Deep Learning, rather than simply trying to “add AI” to everything. It’s equally important to explore alternative approaches, such as:
- Traditional neural networks vs. deep neural networks — Not every AI system needs deep learning; sometimes, simpler architectures are more efficient.
- Generative models vs. predictive models — While models like GPT generate text, others excel at forecasting trends and identifying patterns.
- Supervised, unsupervised, and reinforcement learning — Understanding how a model learns directly impacts its application.
- Rule-based systems vs. AI-driven learning — In many cases, well-defined rules outperform a machine learning model.
- The role of embeddings and vectorization — Techniques like word embeddings and semantic embeddings enhance search accuracy and recommendation quality.
- Specialized vs. general-purpose models — Some tasks are better handled by small, highly trained models rather than a large, costly LLM.
In short, before rushing to integrate AI into a product, it’s crucial to recognize that each model serves a distinct purpose. Choosing the wrong approach can lead to wasted time, excessive costs, and disappointing outcomes.
Hands-on
This is not a tutorial, and this article is aimed at those who have never written a single line of code. I chose Google Colab because it provides an accessible, ready-to-use environment without the need for complex setup. Since it runs in the cloud, anyone can execute the examples regardless of their available hardware. Additionally, its integration with popular libraries makes experimentation and prototyping fast and collaborative.
How to use Google Colab
If you’ve never used Google Colab before, follow these steps:
- Go to Google Colab and sign in with your Google account.
- Click on “New notebook” to create a new file.
- Copy and paste the example code into a cell in the notebook.
- Click the ▶️ (Play) button next to the cell to run the code.
- A text input field will appear below the executed code, allowing you to interact with the example.
Now you can run AI, Machine Learning, and Deep Learning examples directly in your browser without installing anything. But hold on… running a Colab notebook doesn’t make you a programmer! Appreciate the convenience of modern technology, but don’t walk away claiming you “understand programming” just because you executed a prewritten script. Be honest — running code is not the same as understanding how it works.
Below, we have three examples. Exploring generic AI, Machine Learning, and Deep Learning in this order provides a structured and progressive understanding:
- Rule-based models (Generic AI) serve as an initial step, demonstrating automation logic without learning capabilities. They help clarify the limitations of systems that strictly follow predefined instructions.
- Machine Learning (ML) introduces the ability to recognize patterns and learn from data, allowing models to make predictions without being explicitly programmed with rules.
- Deep Learning (DL) takes this concept even further by using deep neural networks to recognize complex patterns without relying on fixed rules.
To illustrate this, I’ve chosen a classic example: MNIST, a dataset of handwritten digits (0–9). In this case, a deep learning model learns to recognize numbers by analyzing thousands of examples — without anyone having to program specific rules for each handwriting variation. This process showcases how neural networks can extract subtle patterns from data and make highly accurate predictions.
Rule-based chatbot
Website navigation assistant
Problem:
Many websites have scattered information and complex menus, making it difficult for users to find what they are looking for.
Solution:
A simple rule-based chatbot can act as a navigation assistant, helping users quickly locate information.
It can answer questions such as:
- “Where can I find the products section?”
- “How do I access my order history?”
- “How can I talk to a representative?”
This model doesn’t require advanced AI, making it an efficient solution for improving navigation without redesigning an entire website.
Benefits:
- Enhances content discovery
- Reduces frustration and abandonment rates
How to test?
- Click the ▶️ button in the code cell to run the chatbot.
- Type ‘exit’ to close the chatbot.
- Try asking:
- “Where can I find the products section?”
- “Can I change my delivery address?”
Observe the chatbot’s responses.
import difflib
# Simple Rule-Based Chatbot (Website Navigation Assistant)
def chatbot(question):
responses = {
"where can I find the products section": "You can find the products using the search bar or by accessing the main menu at the top.",
"how do I access my order history": "Access your order history by clicking on your account and then on 'My Orders'.",
"how can I talk to a representative": "To speak with a representative, click here: [support link]",
"what are your operating hours": "Our customer service is available Monday to Friday, from 9 AM to 6 PM.",
"can I change my delivery address": "Yes, you can change your address in 'Account Settings' in the main menu."
}
question = question.lower().strip("? ")
# Find the closest match to the user's question
closest_match = difflib.get_close_matches(question, responses.keys(), n=1, cutoff=0.6)
if closest_match:
return responses[closest_match[0]]
else:
return "Sorry, I didn't understand. You can try rephrasing your question or visit our FAQ here: [FAQ link]"
# Testing in Colab
while True:
question = input("Ask a question (or type 'exit' to close): ")
if question.lower() == "exit":
print("Chatbot: Goodbye!")
break
response = chatbot(question)
print(f"Chatbot: {response}")Solution type: Rule-based (Automated FAQ).
Simple, direct, and efficient for specific and well-defined scenarios.
Is it AI? Yes.
Because it simulates an automated conversation using predefined responses.
Is it ML? No.
Because it cannot learn from new data or interactions.
Is it Deep Learning? No.
Because it does not use deep neural networks or advanced learning algorithms.
Machine Learning chatbot
Intelligent and adaptive
Problem:
Traditional FAQs often fail to cover all user questions or require them to browse long pages to find the right answer.
Solution:
A chatbot powered by Machine Learning (ML) can learn from user queries and suggest more relevant answers, making the FAQ more dynamic and adaptive.
Instead of mapping only fixed questions, the model identifies similarities between different queries and adjusts responses over time.
For example, if many users ask “Where can I see my order status?” and others ask “When will my order arrive?”, the chatbot understands that both can be answered similarly.
Reduces user effort when searching for answers and makes the experience more natural.
How to test?
Click the ▶️ button in the code cell to run the chatbot.
Type ‘exit’ to close the chatbot.
Test scenarios for the ML chatbot (Semantic Search)
Test 1: Directly matching registered questions
- “Where can I find the products section?”
- “How do I access my order history?”
- “How can I contact customer support?”
Objective: Ensure the correct answers are returned.
Test 2: Questions with synonyms and different phrasing
- “Where are the products?”
- “I want to check my previous orders, how do I do that?”
- “I need to contact support.”
Objective: Evaluate its ability to recognize semantically similar questions.
Test 3: Implicit context in questions
- “Can I change my address?”
- “What time do you open?”
- “Where is the products menu?”
Objective: Assess if the chatbot understands implied questions and maintains accuracy.
Test 4: Out-of-scope questions
- “How do I track my delivery?”
- “Do you have live chat support?”
- “Can I pay with PayPal?”
Objective: Evaluate how the chatbot handles questions without a direct pre-registered answer.
Test 5: Robustness (typos and variations)
- “how to accsess order histary”
- “customer support, how can I contact”
- “change delivery adress possible?”
Objective: Check its tolerance to spelling mistakes.
!pip install -q sentence-transformers fuzzywuzzy
from sentence_transformers import SentenceTransformer, util
from fuzzywuzzy import fuzz, process
# Machine Learning model for semantic search
model = SentenceTransformer("all-MiniLM-L6-v2")
# Expanded knowledge base for the chatbot
faq = {
"products section": [
"You can find the products using the search bar or by accessing the main menu at the top.",
"Our products are available in the designated section in the main menu."
],
"order history": [
"Access your order history by clicking on your account and then on 'My Orders'.",
"To view past orders, go to 'My Orders' under your account."
],
"speak with customer support": [
"Need help? Our support team is here for you! Click here: [support link].",
"Chat with our support team anytime! Click here: [support link]."
],
"business hours": [
"Our customer support hours are from 9 AM to 6 PM, Monday to Friday.",
"We are available Monday to Friday, from 9 AM to 6 PM."
],
"change delivery address": [
"Yes, you can change your address in 'Account Settings' in the main menu.",
"To update your delivery address, go to account settings and edit your details."
],
"track my delivery": [
"You can track your delivery by going to 'My Orders' and clicking on the tracking option.",
"To track your order, go to 'My Orders' and select the order you want to track."
],
"pay with PayPal": [
"Yes, we accept PayPal as a payment method. At checkout, select 'PayPal' and follow the instructions.",
"PayPal is available as a payment option. Simply choose it during checkout."
],
"live chat support": [
"Yes, we offer live chat support. Visit our website and click on the support option.",
"Our support team is available via live chat. Go to our website and start a conversation with a representative."
]
}
# Creating embeddings for the FAQ questions
faq_questions = list(faq.keys())
faq_embeddings = model.encode(faq_questions, convert_to_tensor=True)
def correct_spelling(user_question):
"""Applies spelling correction for better accuracy."""
best_match, similarity = process.extractOne(user_question, faq_questions, scorer=fuzz.token_sort_ratio)
return best_match if similarity > 80 else user_question # Adjust threshold as needed
def chatbot_ml(user_question):
"""Finds the best-matching response using semantic embeddings and fuzzy matching."""
corrected_question = correct_spelling(user_question)
# Improve matching to avoid confusion between "products" and "orders"
if "order" in user_question.lower() or "purchase" in user_question.lower():
return faq["order history"][0] # Always return the correct response for orders
question_embedding = model.encode(corrected_question, convert_to_tensor=True)
similarities = util.pytorch_cos_sim(question_embedding, faq_embeddings)
best_match_index = similarities.argmax().item()
response_key = faq_questions[best_match_index]
return faq[response_key][0] # Returns the first response from the matched category
# Function to run the chatbot interactively in Colab
def start_chat():
print("Chatbot started! Ask a question or type 'exit' to quit.\n")
while True:
question = input("You: ")
if question.lower() == "exit":
print("Chatbot: Goodbye!")
break
response = chatbot_ml(question)
print(f"Chatbot: {response}\n")
# Run the chatbot
start_chat()Solution type: Machine Learning with Semantic Focus
Is it AI? Yes.
Because it simulates an intelligent interaction by interpreting user intentions based on the questions asked.
Is it ML? Yes.
Because it learns patterns and recognizes intent, even with variations or different wording from the original training data.
Is it Deep Learning? No.
Because while it understands basic semantics and word context, it does not use deep neural networks or advanced algorithms.
Deep Learning
When AI stops just responding and starts learning
The fun was great while it lasted, and that’s exactly what this experiment is about — playing around with concepts by pasting some code into Colab. But now, things get serious. It would be amazing to use deep learning for a chatbot that truly understands context, adapts its language to the user, and ensures accessibility. Imagine an assistant that adjusts responses for users with limited digital literacy or provides more descriptive content for visually impaired users. However, achieving this would require millions of interactions to train the model, a robust infrastructure with GPUs/TPUs, and continuous training to maintain accuracy and responsiveness.
So, instead of forcing an artificially limited example, I chose something we can actually test: handwritten digit recognition with MNIST. This is one of the most iconic and educational examples of deep learning, as it demonstrates how a convolutional neural network (CNN) learns visual patterns without anyone having to program fixed rules. Unlike rule-based models or simple supervised learning, the network here understands the variations in handwriting styles and generalizes that knowledge to recognize new examples.
In this example, you’ll see a bunch of numbers and statistics appearing in the prompt — don’t be alarmed! That just means our deep learning model is learning. We will feed a neural network thousands of images of handwritten digits, and it will adjust its parameters until it can recognize them with high accuracy. Instead of defining fixed rules like “the number 3 has two curves,” the model learns patterns by analyzing examples. In the end, you’ll be able to test it by drawing a number, and the AI will try to guess what it is.
1. Model training
Each epoch represents a cycle where the model adjusts its weights to improve predictions. Here, we run 5 epochs to teach the AI how to recognize handwritten numbers.
- Epoch 1: The model starts learning, correctly identifying 91% of the images, but still makes significant errors (loss: 0.2861).
- Epochs 2–5: Accuracy increases to 99.58%, with loss reduced to 0.0136 — indicating that the model has become highly proficient at recognizing patterns.
2. Accuracy, loss, and validation
- Accuracy: Measures how often the model makes correct predictions.
- Loss: Indicates how incorrect the predictions are — the lower, the better.
- Validation: The model is tested with new images to ensure it hasn’t just “memorized” the numbers but can generalize to unseen data.
In our tests, the model achieved 98.77% accuracy, proving it can generalize well to new data.
3. Real predictions
In my tests, the model correctly predicted all the numbers. Let me know if your results were different!
By running this code, you trained a neural network to recognize handwritten numbers — something that once only humans could do. This highlights the power of deep learning: the ability to learn patterns without relying on predefined rules.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
# Load the MNIST dataset
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Normalize the data (from 0-255 to 0-1)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Expand dimensions for CNN (28x28x1)
x_train = np.expand_dims(x_train, axis=-1)
x_test = np.expand_dims(x_test, axis=-1)
# Create the Deep Learning model (CNN)
modelo = models.Sequential([
layers.Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
layers.MaxPooling2D((2,2)),
layers.Conv2D(64, (3,3), activation='relu'),
layers.MaxPooling2D((2,2)),
layers.Flatten(),
layers.Dense(128, activation='relu'),
layers.Dense(10, activation='softmax') # 10 classes (digits 0 to 9)
])
# Compile the model
modelo.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Train the model
modelo.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))
# Evaluate on the test set
test_loss, test_acc = modelo.evaluate(x_test, y_test)
print(f"\n Test set accuracy: {test_acc:.4f}")
# Function to test the model's prediction
def predict_digit(index):
img = x_test[index]
plt.imshow(img.squeeze(), cmap='gray')
plt.axis('off')
plt.show()
prediction = modelo.predict(np.expand_dims(img, axis=0))
print(f"The model predicted: {np.argmax(prediction)}")
# Test: randomly select a number from the test set
import random
index = random.randint(0, len(x_test) - 1)
predict_digit(index)Solution Type: Deep Learning with Convolutional Neural Networks (CNN).
Capable of identifying complex visual patterns without explicit rules, learning to recognize handwritten digits from examples.
Is it AI? Yes.
Because the model processes data and makes predictions automatically, simulating a human cognitive process to interpret images.
Is it Machine Learning? Yes.
Because it learns from labeled data (handwritten numbers) and generalizes this knowledge to predict new examples.
Is it Deep Learning? Yes.
Because it uses deep neural networks (CNNs), which analyze different levels of image details to recognize patterns and improve accuracy.
Conclusion: Promise questions, not answers
Align expectations with decision-makers. How? Commit to understanding which questions truly matter instead of promising all the answers. Invest time in identifying these key questions and exploring what still needs to be answered. If you’re the one leading the discussion, don’t divert experts from critical projects just to chase AI hype — create an environment where experimentation is encouraged, where trial and error are part of the process. This shifts the focus away from “AI” as a buzzword, reduces pressure to follow trends, and allows your team to discover meaningful solutions naturally and genuinely.
Start small discussion groups within your company to share AI insights, fostering the exchange of experiences and diverse perspectives. The current moment is unique because everyone is learning together, creating opportunities for real collaboration — where innovation isn’t just a trend but something built collectively, driven by curiosity and the pursuit of what truly makes sense.
Index of resources used in the examples
General AI — Rule-based chatbot
This example used only pure Python, without machine learning. The chatbot follows a fixed set of rules to respond to questions.
Resources used:
- Python → https://www.python.org/
- String similarity matching (
difflib) → Python Standard Library - difflib - Dictionary structure (
dict) → https://docs.python.org/3/tutorial/datastructures.html#dictionaries - String manipulation (
.lower(),.strip()) → https://docs.python.org/3/library/stdtypes.html#string-methods
Machine Learning — Semantic search chatbot
This example applies Machine Learning to find the most relevant answer based on the meaning of a question.
Libraries used:
- Sentence Transformers (For semantic search) → https://www.sbert.net/
- FuzzyWuzzy (For typo correction and fuzzy matching) → https://github.com/seatgeek/fuzzywuzzy
- NumPy (For array manipulation) → https://numpy.org/doc/stable/
Model Used:
- all-MiniLM-L6-v2 (Pre-trained model for semantic search) → https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2
Deep Learning — Handwritten digit recognition (MNIST)
This example used Convolutional Neural Networks (CNNs) to recognize handwritten numbers.
Libraries used:
- TensorFlow/Keras (Deep Learning framework) → https://www.tensorflow.org/
- Matplotlib (For image visualization) → https://matplotlib.org/
- NumPy (For array manipulation) → https://numpy.org/doc/stable/
Model used:
- Custom Convolutional Neural Network (CNN)
- Built using Conv2D, MaxPooling2D, Flatten, Dense, and Softmax layers.
Dataset used:
- MNIST (Handwritten digit image dataset) → https://keras.io/api/datasets/mnist/
References & additional reading
- WebAIM. “The WebAIM Million”, https://www.w3.org/WAI/, March 28, 2024
- MIT Technology Review. “What is AI?”, July 10, 2024
- MIT Technology Review. “What is Machine Learning?”, November 17, 2018
- MIT Technology Review. “Deep Learning”, October 16, 2023
- Spotify. “Machine Learning”
- Business Insider. “AI companies are copying each other’s homework to make cheap models”, March 7, 2025
- reddit. “Using Open-Source LLM Models vs. Expensive OpenAI APIs: A Logical Choice for Consumer Apps?”
- Forbes. “Meta’s Awful ‘Horizon Worlds’ Ad Helps Explain $70 Billion Metaverse Loss”, February 17, 2025
- The New Yorker. “Was Linguistic AI Created by Accident?”, August 23, 2024
- Lifewire. “How Deep Learning Is Revolutionizing Technology and Everyday Life”, February 10, 2025
- IBM. “AI vs. Machine Learning vs. Deep Learning vs. Neural Networks: What’s the Difference?”, July 6, 2023
