Forem: Dharshan A

The LLM Fallacy: Are We Overestimating Our Own Skills Because of AI?

Dharshan A — Tue, 28 Apr 2026 14:05:45 +0000

A new paper published in April 2026 introduces a concept that feels very relevant to every developer working with AI tools daily: The LLM Fallacy.

Paper Details

Title: The LLM Fallacy: Misattribution in AI-Assisted Cognitive Workflows
Authors: Hyunwoo Kim, Harin Yu, and Hanau Yi (ddai Inc.)
Date: April 16, 2026
Link: https://arxiv.org/pdf/2604.14807

The paper defines the LLM Fallacy as a cognitive attribution error where people mistakenly credit themselves for high-quality outputs that were heavily assisted by large language models. In other words, we produce great results with AI help, and over time we start believing we could have done it just as well, or even better, on our own.

This creates a dangerous gap between how skilled we feel and how skilled we actually are when working without AI assistance.

Why This Hits Developers Hard

As developers, we live in this reality every day. You describe a feature, iterate with the model a few times, clean up the code, and ship something that looks professional. Because the interaction feels so natural and fluent, it becomes easy to internalize the entire solution as purely your own work.

The authors point out that modern LLMs make this misattribution especially easy due to their high fluency, opacity (we don’t see the full reasoning), and extremely low-friction conversation style.

From my point of view, this fallacy is already quite common. Many developers are shipping faster than ever, yet some struggle to explain core decisions or debug similar problems when the AI is not available. This is particularly risky for newer engineers who may build confidence on assisted performance rather than deep understanding.

The Risks and the Opportunity

This doesn’t mean we should stop using LLMs, they remain one of the biggest productivity boosts in software development. The real problem is unexamined reliance.

If we never test our own baseline skills, we risk building fragile knowledge and overestimating our independent capabilities.

The paper highlights important implications for education, technical interviews, and team performance. Companies may need to evolve how they evaluate real competence beyond just final output quality.

How to Protect Yourself from the LLM Fallacy

Think through the problem and sketch your own approach before prompting the model
Periodically implement critical parts of the code from scratch without assistance
After accepting AI-generated code, close the chat and try to explain or rebuild the key sections yourself
Use the model to explore alternatives only after forming your own hypothesis
Be honest with yourself and your team about how much was truly independent work

The authors call for better AI literacy, more transparent interfaces, and updated evaluation methods. I completely agree with this direction.

Final Thoughts

The most effective developers in the future will be those who can leverage powerful LLMs to move extremely fast while actively maintaining and sharpening their own independent thinking and fundamentals.

Awareness of the LLM Fallacy is the first step toward healthier and more sustainable AI collaboration.

Have you noticed this effect in your own workflow or team? Drop your thoughts in the comments.

Read the full paper: https://arxiv.org/pdf/2604.14807

How to Fine-Tune Llama 3.1 8B for Under $5 Using QLoRA in 2026 – A Practical Guide

Dharshan A — Tue, 28 Apr 2026 06:32:14 +0000

I spent nearly three weeks and close to $300 trying to fine-tune a large language model the traditional way. VRAM errors, disappointing results, and massive bills, it was painful.

If you've ever felt the same frustration, this tutorial is for you. In 2026, fine-tuning LLMs doesn't need to be expensive or complicated. I'll show you exactly how to fine-tune Llama 3.1 8B using QLoRA for under $5, while getting solid, usable results.

By the end of this guide, you'll have a complete, working workflow you can adapt to your own domain or task.

Why Bother Fine-Tuning at All?

Let’s be honest upfront: fine-tuning isn’t always the right answer. For many applications, good prompt engineering combined with RAG delivers faster and cheaper results.

However, when you need consistent behavior, specialized knowledge, or better performance on structured outputs, fine-tuning still wins. The good news? Thanks to QLoRA and tools like Unsloth, it’s now accessible without a research lab budget.

Prerequisites

Before we start, make sure you have:

Intermediate Python skills and basic familiarity with Hugging Face
A Hugging Face account (for gated models like Llama 3.1)
Access to a GPU with at least 16GB VRAM (RTX 4090, A100, or Colab Pro works well)
Basic understanding of what LoRA is (we’ll cover the practical side below)

Concepts Overview: Why QLoRA?

Full fine-tuning updates every parameter in the model — extremely expensive in both memory and compute.

LoRA (Low-Rank Adaptation) freezes the base model weights and only trains small adapter layers. This dramatically reduces the number of trainable parameters.

QLoRA takes it further by quantizing the base model to 4-bit precision while keeping the adapters in higher precision. The result is massive memory savings with surprisingly little drop in quality.

In practice, this means you can fine-tune an 8B model on relatively modest hardware without sacrificing too much performance. That’s why QLoRA became the go-to efficient fine-tuning method in 2026.

Step-by-Step Implementation

1. Environment Setup

pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps xformers trl peft accelerate bitsandbytes

2. Load the Model in 4-bit

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048
dtype = None
load_in_4bit = True

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Meta-Llama-3.1-8B-bnb-4bit",
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
)

3. Prepare Your Dataset

from datasets import load_dataset

dataset = load_dataset("json", data_files="training_data.json", split="train")

def formatting_prompts_func(examples):
    texts = []
    for instruction, input_text, output in zip(examples['instruction'], 
                                              examples['input'], 
                                              examples['output']):
        text = f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
{instruction}

### Input:
{input_text}

### Response:
{output}"""
        texts.append(text)
    return {"text": texts}

dataset = dataset.map(formatting_prompts_func, batched=True)

4. Apply LoRA Adapters

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj"],
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    use_gradient_checkpointing = "unsloth",
    random_state = 42,
)

5. Configure and Start Training

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    dataset_text_field = "text",
    max_seq_length = max_seq_length,
    dataset_num_proc = 2,
    packing = False,
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 80,
        learning_rate = 2e-4,
        fp16 = not torch.cuda.is_bf16_supported(),
        bf16 = torch.cuda.is_bf16_supported(),
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 42,
        output_dir = "outputs",
        report_to = "none",
    ),
)

trainer.train()

6. Save and Merge the Model

model.save_pretrained("lora_adapter")
tokenizer.save_pretrained("lora_adapter")

model = model.merge_and_unload()
model.save_pretrained("fine_tuned_llama_8b")
tokenizer.save_pretrained("fine_tuned_llama_8b")

Running and Testing

FastLanguageModel.for_inference(model)

messages = [{"role": "user", "content": "Explain how QLoRA works in simple terms."}]
inputs = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to("cuda")

outputs = model.generate(input_ids=inputs, max_new_tokens=512, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Troubleshooting Common Issues

Out of Memory (OOM): Reduce batch size or increase gradient accumulation steps
Overfitting: Use fewer steps, add more diverse data, or lower learning rate
Poor generation quality: Check your dataset formatting and instruction quality
Slow training: Make sure you're using Unsloth and gradient checkpointing

Next Steps

Once you have a working setup, you can explore:

Preference tuning with DPO or ORPO
Model merging techniques
Production inference with vLLM
Combining fine-tuning with RAG for better results

Have you tried fine-tuning with QLoRA yet? What challenges did you face? Share your experience in the comments!

Generative AI vs AI Agents vs Agentic AI: What's the Real Difference?

Dharshan A — Mon, 13 Apr 2026 18:46:24 +0000

Generative AI, AI Agents, and Agentic AI are three of the most talked about topics in AI development right now. Many developers use these terms interchangeably, but they are fundamentally different. Choosing the wrong approach can make your project unnecessarily complex or too limited.

In this guide, I will explain each concept in simple language with practical developer insights and a real world example.

What is Generative AI?

Generative AI is the base layer. It consists of large language models trained on huge amounts of data that can create new content when given a prompt.

Models like GPT 4, Claude, Llama 3, or Gemini belong here. You give them input and they generate text, code, images, or summaries.

Main characteristics:

Fully reactive — it only responds to your prompt
Excellent at creative and language tasks
Has no access to real time information or external tools
Knowledge is limited to its training data

Typical use: Writing emails, generating code snippets, creating meeting summaries, or drafting blog outlines. Most basic AI chatbots you see are built using Generative AI.

What is an AI Agent?

An AI Agent is a step above simple generation. It is an LLM that can actively use tools to complete a specific task.

The key capability is tool calling. The agent can decide when to use external tools like web search, calculators, databases, or APIs, fetch fresh data, and then provide a complete answer.

Practical example: You ask the agent, “What are the current pricing plans of Vercel and Render?” The agent does not know the latest pricing, so it calls a web search tool or scrapes the official pages, extracts the information, and gives you a clear comparison.

AI Agents are perfect when you need the model to perform one focused job that may require up to date or external information.

What is Agentic AI?

Agentic AI is where things get powerful. It is a complete multi agent system where several specialized AI agents work together like a team to solve a complex, end to end process.

Each agent has a specific role, its own tools, and they can communicate with each other, hand off tasks, run steps in sequence or parallel, and even ask for human input when needed.

New Real World Example: Building an Automated Competitor Analysis System for a SaaS product.

Here is how the agents work together:

Agent 1 (Research Agent): Searches the web and finds top competitors
Agent 2 (Pricing Agent): Visits each competitor’s website and extracts current pricing information
Agent 3 (Feature Agent): Analyzes competitor features, strengths, and weaknesses
Agent 4 (Review Agent): Reads recent customer reviews and identifies common complaints
Agent 5 (Report Agent): Combines all the data and generates a professional competitive analysis report with recommendations

All these agents collaborate, share findings, and produce a complete report that would normally take a human analyst many hours. This is Agentic AI in action.

Quick Comparison Table

Aspect	Generative AI	AI Agent	Agentic AI
Core Purpose	Create new content from prompts	Perform one specific task using tools	Automate complex multi step workflows
Working Style	Reactive only	Reasoning + Tool use	Multiple agents collaborating
Complexity Level	Simple	Medium	Advanced
Best For	Content creation, coding help, summarization	Real time data lookup, single actions	End to end automation and complex processes
Frameworks	OpenAI API, basic prompting	LangChain + Tools	LangGraph for multi agent orchestration

When to Use Which Approach?

Use Generative AI for quick content generation and creative tasks.
Use AI Agents when your application needs to interact with external data or tools for one focused task.
Use Agentic AI when you want to automate entire business workflows that involve many steps and decision points.

In most production applications, these three layers work together. Generative AI provides the intelligence, AI Agents add action capability, and Agentic AI brings everything together into smart automated systems.

Final Thoughts

Generative AI is great at creating things.
AI Agents make those creations useful by connecting to the real world.
Agentic AI brings multiple agents together to solve difficult, multi step problems automatically.

Understanding these differences will help you design better AI systems and choose the right architecture from the beginning.

Are you currently working on any AI agents or agentic workflows? What example would you like to see next — perhaps a customer support agent or a code review system? Let me know in the comments.

Data Scientist vs Machine Learning Researcher vs Machine Learning Engineer

Dharshan A — Mon, 13 Apr 2026 18:12:37 +0000

These three roles are often confused with one another. While they work closely together in the AI/ML field, their day-to-day responsibilities and required skill sets are quite different.

The Data Science Project Lifecycle

A typical data science project includes data collection, feature engineering, feature selection, model building, evaluation, deployment, and ongoing monitoring. The three roles come into play at different stages of this process.

1. Data Scientist

A Data Scientist focuses on solving business problems using existing machine learning and deep learning algorithms.

Key Responsibilities:

Exploratory data analysis
Feature engineering and selection
Building and tuning models with ready-made algorithms (Random Forest, XGBoost, Neural Networks, etc.)
Evaluating model performance
Monitoring and retraining models every few weeks

Core Skills:

Strong Python or R programming
Statistics and probability
Data visualization
Machine learning frameworks (Scikit-learn, TensorFlow, PyTorch)
Business and domain knowledge

2. Machine Learning Engineer

Once a model is built and tested by the data scientist, the Machine Learning Engineer takes it to production.

Key Responsibilities:

Deploying models on cloud platforms (AWS, GCP, Azure, etc.)
Building scalable ML pipelines
Containerization using Docker and orchestration with Kubernetes
Setting up monitoring and retraining systems
Ensuring the model runs reliably at scale

Core Skills:

Strong software engineering practices
Cloud infrastructure
MLOps and CI/CD pipelines
API development
Linux and production environments

3. Machine Learning Researcher

When no existing algorithm can solve the problem, a Machine Learning Researcher steps in to create new ones or significantly improve current methods.

Key Responsibilities:

Developing new machine learning algorithms
Modifying and experimenting with existing models
Deep mathematical analysis of algorithms
Publishing research papers

Core Skills:

Advanced mathematics and statistics (usually PhD level)
Strong theoretical understanding of ML/DL
Research and experimentation skills

Only large tech companies like Google, Amazon, Meta, Microsoft, and Flipkart usually hire dedicated ML Researchers. Most companies don’t need them because existing algorithms are sufficient for their use cases.

Quick Comparison

Aspect	Data Scientist	ML Engineer	ML Researcher
Primary Focus	Solving business problems	Deploying & scaling models	Inventing new algorithms
Math Level	Good	Moderate	Expert (PhD level)
Programming	High	Very High (production)	High (research)
Deployment	Basic	Expert	Minimal
Common Employers	Most companies	Tech & product companies	Big Tech & Research Labs

The Reality Check

In startups and small companies, one person often handles all three roles. In bigger organizations, the responsibilities are more clearly divided.

Which Path Should You Choose?

Data Scientist: Best if you enjoy solving problems, analyzing data, and delivering business value.
ML Engineer: Ideal if you love building systems, working with cloud technologies, and production engineering.
ML Researcher: Only if you have (or want to pursue) deep expertise in math and genuinely enjoy research.

Many people start as Data Scientists and later specialize based on what they enjoy most.

Have questions about which role suits you? Feel free to drop them in the comments.

5 Small Habits That Actually Made Me a Better Developer

Dharshan A — Mon, 13 Apr 2026 08:24:57 +0000

I’ve been coding for years. I’ve tried fancy frameworks, complicated tools, and big learning plans. But the things that helped me the most were surprisingly small daily habits.

Here are the 5 habits that made the biggest difference

1. Write down what I built every day

Even if it’s just 2 lines: "Fixed login bug" or “Made the button work”. At the end of the week I can see real progress. This stopped me from feeling like I did nothing.

2. Delete code instead of commenting it out

I used to leave old code with // comments everywhere. Now I delete it. My files are cleaner, easier to read, and I make fewer mistakes.

3. Take a 5-minute break every hour

I set a timer. When it rings, I stand up, walk, or look out the window. My brain works much better and I catch bugs faster after the break.

4. Use the "10-minute rule" for problems

If I’m stuck on something, I only allow myself 10 minutes of struggling. After that I ask Google, Stack Overflow, or a friend. This saves me hours of frustration.

5. Keep one simple notebook (not digital)

I write down ideas, shortcuts I learn, and error messages. Paper feels faster than opening another app. I go back to it often.

Why these small habits work better than big changes

Learning a new framework or language feels exciting but usually doesn’t stick. Small habits are easy to start and they compound over time. After a few months you notice you’re faster, calmer, and write better code.

Start with just one

Don’t try all five at once. Pick one habit this week. Try it for 7 days and see how it feels.

My challenge to you

Which small habit are you going to try first? Or what small habit has helped you the most as a developer?

Tell me in the comments. I read every single one.

Small changes > Big promises.

Build a Production-Ready RAG System Over Your Own Documents in 2026 – A Practical Tutorial

Dharshan A — Sat, 04 Apr 2026 07:23:52 +0000

Retrieval-Augmented Generation (RAG) has moved far beyond simple chat-over-PDF demos. In 2026, if your RAG system hallucinates on important queries, returns irrelevant chunks, or costs a fortune to run, it won't survive production.

This tutorial walks you through building a reliable, evaluable, and scalable RAG pipeline that you can actually put behind an API or in a product. We'll use your own documents (PDFs, Markdown, text files, etc.) and focus on the parts that actually matter in real deployments: smart chunking, hybrid retrieval, reranking, evaluation, and basic guardrails.

Why Most RAG Projects Fail in Production

Bad chunking destroys context.
Pure vector search misses exact keywords.
No evaluation = you have no idea if it's improving.
No reranking or metadata filtering = noisy results.
No separation between indexing and querying pipelines.

We'll address all of these.

Tech Stack (2026 Edition – Balanced & Practical)

Orchestration: LangChain (flexible) or LlamaIndex (stronger for document-heavy RAG). I'll use LangChain here.
Embeddings: text-embedding-3-large (OpenAI) or open-source alternatives like Snowflake Arctic Embed.
Vector Store: Chroma (dev) → Qdrant or Weaviate (production).
LLM: Grok, Claude, GPT-4o, or local with Ollama.
Reranking: Cohere Rerank or BGE reranker.
Evaluation: Ragas.

Prerequisites

pip install langchain langchain-community langchain-openai langchain-qdrant \
            pypdf sentence-transformers chromadb ragas cohere

Step 1: Document Loading & Cleaning

from langchain.document_loaders import PyPDFDirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = PyPDFDirectoryLoader("your_documents_folder/")
docs = loader.load()

print(f"Loaded {len(docs)} documents")

Step 2: Strategic Chunking

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,
    chunk_overlap=150,
    separators=["\n\n", "\n", ". ", " ", ""]
)

chunks = text_splitter.split_documents(docs)

Step 3: Embeddings & Vector Store

from langchain_openai import OpenAIEmbeddings
from langchain_qdrant import QdrantVectorStore
from qdrant_client import QdrantClient

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

client = QdrantClient(":memory:")

vector_store = QdrantVectorStore.from_documents(
    documents=chunks,
    embedding=embeddings,
    client=client,
    collection_name="my_knowledge_base"
)

Step 4: Retrieval with Reranking

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import CrossEncoderReranker
from langchain_community.cross_encoders import HuggingFaceCrossEncoder

retriever = vector_store.as_retriever(search_kwargs={"k": 20})

compressor = CrossEncoderReranker(
    model=HuggingFaceCrossEncoder(model_name="BAAI/bge-reranker-large"),
    top_n=5
)

compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=retriever
)

Step 5: The RAG Chain

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model="gpt-4o", temperature=0.0)

template = """Answer the question based only on the following context.
If you don't know the answer, say "I don't have enough information."

Context:
{context}

Question: {question}
Answer:"""

prompt = ChatPromptTemplate.from_template(template)

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": compression_retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

print(rag_chain.invoke("What are the key points from the Q3 report?"))

Step 6: Evaluation with Ragas

Use Ragas to measure faithfulness, answer relevancy, context precision, and recall on a test dataset of questions and ground truth answers.

Going Production-Ready

Separate indexing and querying pipelines
Add semantic caching to reduce costs
Implement guardrails (e.g., Guardrails AI or NeMo)
Set up monitoring with LangSmith, Phoenix, or Prometheus
Deploy using FastAPI with async endpoints
Build a proper re-indexing strategy for fresh documents

Final Thoughts

Building a basic RAG takes an afternoon. Building one that stays accurate, cheap, and trustworthy at scale takes discipline around retrieval quality and continuous evaluation.

Start small: load your documents, get decent retrieval, add evaluation, then iterate based on real metrics — not gut feel.

The code above gives you a solid foundation you can extend today. Drop your documents in a folder and start experimenting.

Happy building!

Have you built a production RAG system? What was the biggest surprise or pain point? Share your experiences in the comments.

AI in 2026: From Hype to Real-World Impact – What Developers Need to Know

Dharshan A — Thu, 02 Apr 2026 14:23:09 +0000

2025 felt like the wild west of AI. Flashy demos, constant experimentation, and a lot of guesswork around what actually worked.

In 2026, things have stabilized.

AI is no longer just a novelty. It’s becoming a practical teammate—helping developers ship faster, build better systems, and solve real problems without burning out.

The biggest shift?
We’re moving away from chasing massive models toward building smarter, more efficient systems.

Small Language Models (SLMs) running cheaply
Agentic workflows handling multi-step tasks
Better memory and context handling
Early progress in world models

For developers, this is a huge win: less fighting APIs and token limits, more focus on building useful products.

Key Trends Developers Should Watch (and Build With)

1. Agentic Workflows Over Isolated Agents

Fully autonomous agents are still evolving, but 2026 is the year of practical AI workflows.

Better orchestration
Self-checking mechanisms
Persistent memory
Multi-step task handling

Instead of one-shot prompts, systems now:

plan → execute → reflect → adapt

Interoperability between agents is improving too.

Dev tip: Start experimenting with orchestration frameworks that support planning, execution, and reflection loops.

2. Rise of Efficient and Domain-Specific Models

Scaling laws are hitting limits. The focus has shifted to:

Smaller, optimized models
Fine-tuned SLMs
Domain-specific LLMs
Edge and on-device AI

These models are faster, cheaper, and easier to deploy.

There’s also quiet progress in quantum + AI hybrid systems, especially for niche use cases.

3. World Models and Physical AI

AI is moving beyond text.

World models aim to understand and simulate real-world physics and environments.

Robotics
Simulations
Video generation
Spatial reasoning systems

This is where AI starts interacting with the real world—not just predicting text.

4. AI-Native Development and Coding Assistants

Coding assistants have evolved beyond autocomplete.

Understand entire codebases
Track project history
Assist with architecture decisions
Refactor intelligently
Generate tests with context

Repository-level intelligence is now a real productivity multiplier.

5. Security, Governance, and Pragmatism

As AI adoption grows, so does responsibility.

Explainability
Built-in safety checks
Privacy (on-device AI)
Measuring real ROI

The shift is clear: from experimentation to accountability.

6. Enterprise and Infrastructure Impact

AI is now reshaping real business workflows.

AI agents embedded into operations
Massive data center and energy investments
More realistic valuations
Continued infrastructure growth

Practical Advice for Developers in 2026

1. Master Context Engineering

Deciding what the model sees matters more than the model itself.

Documents
Code context
Memory
Summaries

Better context = better output.

2. Build with Agents in Mind

Design systems for:

Multi-step workflows
Feedback loops
Long-running tasks

3. Integrate, Don’t Replace

Augment existing workflows instead of rebuilding everything with AI.

4. Use Open Source Models

They offer lower cost, more control, and reduced dependency on external APIs.

5. Optimize for Cost and Speed

Fine-tuned small models often outperform large ones in real-world production.

6. Treat Prompting as a Core Skill

Clear prompts + structured context = high leverage.

Challenges and the Road Ahead

Regulations are still evolving
Ethical concerns remain
Architectures beyond scaling are still being explored
Market corrections are possible

But the direction is clear: pragmatic progress.

Conclusion: Build the Future

2026 isn’t about waiting for AGI.

It’s about using today’s AI to:

Ship better products
Move faster
Reduce friction in development

The biggest wins will go to developers who treat AI as a capable but imperfect collaborator.

If you’re building with AI this year, focus on:

Reliability
Cost efficiency
Real user value

That’s where the real impact is happening.