Blog

AI is Not Real: A Software Engineering Perspective

Next in Artificial Intelligence The AI Revolution in DevOps: How Smart Tech is Changing Incident Response

Blog

Artificial Intelligence Software Engineering Machine Learning Technology Ethics

AI is Not Real: A Software Engineering Perspective

Mohammad Abu Mattar 28 May, 2024 Updated: 30 May, 2026 14 Mins read

We have all seen the wave of hype around artificial intelligence. It is everywhere, from tech conferences to science fiction scripts. As software engineers, though, we need to look past the marketing and understand what this technology actually is, and what it is not.

From a systems perspective, the claim that AI is “intelligent” the way a human is misses the mark. The systems we label as AI today do not have comprehension, self-awareness, or context-driven judgment. They are very good statistical pattern matchers and optimization engines running over huge datasets.

If we want to build software that is robust, scalable, and safe, we have to evaluate the underlying math, the computational limits, and the messy real-world realities of machine learning. So let’s walk through the gap between algorithmic learning and natural intelligence, the structural limits of language models, a few real failures, and the hybrid architectures that move us from fragile prompt engineering toward reliable computation.

Real Cognition vs. Statistical Automation

At the heart of the “AI is not real” argument is a genuine divide: biological cognition on one side, statistical automation on the other. Real intelligence shows up in natural environments and comes with understanding, reasoning, and consciousness. What we call AI today is sophisticated processing and pattern matching, and that is a different category of thing.

Stephen Downes puts it well: intelligence is not a physical object. It is a property, a capacity to respond to some criterion of success. A biological brain runs a persistent, self-recursive state. Even when you are lying on the couch with your mind blank, your brain keeps running and updating its internal model of the world.

A language model does none of that. It sits completely static until you send a query. Once it emits the final token, it freezes again. Its “personality” is just a temporary configuration spun up on the fly from your prompt and then thrown away.

This is a long way from the symbolic logic and expert systems of the 1970s and 1980s, where programmers tried to encode intelligence as explicit rules and giant fact databases. Today we trade that explicit reasoning for statistical approximation, and in return we get something far broader and more scalable.

AI, Machine Learning, and Cognitive Computing Are Not the Same Thing

To build good systems you have to keep the terms straight. Marketing uses them interchangeably, but their goals and methods are different.

Dimension	Artificial Intelligence	Machine Learning	Cognitive Computing
Primary objective	Mimics cognitive functions to solve tasks on its own	Learns from data to make predictions more accurate	Simulates human thought to help people decide
System scope	A broad field: robotics, NLP, decision trees	A subset focused on patterns and statistical models	A hybrid blending machine learning with human interaction
Data requirements	Structured, unstructured, or programmatic rules	Depends heavily on large, high-quality datasets	Processes complex, messy, contextual data
Execution method	Algorithmic logic, decision trees, neural networks	Statistical models that spot patterns without coding	Iterative, stateful, contextual dialogue
Human interaction	Acts autonomously as the maker of its own decisions	Runs as an automated tool with minimal runtime input	Acts as a partner, leaving the final call to the human

To see how we got here, look at the jump from early statistical tools to modern deep learning. Older models like Word2Vec and GloVe mapped words to static vectors. They were decent pattern matchers, but they struggled with words that have multiple meanings or depend on context. Transformers fixed this by computing each word’s representation dynamically, based on the surrounding tokens in the active context window.

What’s Actually Happening: Compression, Attention, and Emergent Behavior

Underneath the fluent output, a transformer is math, not biology. Some researchers argue that pattern compression, finding the structural shortcuts that minimize Kolmogorov complexity, is functionally close to semantic understanding. The model tunes its parameters to compress the information space so it can predict the most likely next token.

The engine behind this is self-attention, which measures how the tokens in a sequence relate to one another. For every input token, the model computes a Query, a Key, and a Value vector using learned weights, then combines them:

\text{Attention}(Q, K, V) = \text{softmax}\!\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V

This lets the model weigh how much attention to pay to every other word in the sentence relative to the current one, building context on the fly. Here is a small, clean NumPy version of that formula:

1
import numpy as np
2

3

4
def self_attention(Q, K, V):
5
    """
6
    Weights the relationships between tokens.
7
    Q, K, V are the Query, Key, and Value matrices.
8
    """
9
    # Dimension of the key vectors, used for scaling
10
    d_k = K.shape[-1]
11

12
    # Raw similarity scores between Queries and Keys
13
    scores = np.matmul(Q, K.T) / np.sqrt(d_k)
14

15
    # Softmax turns the scores into probabilities (weights)
16
    weights = np.exp(scores) / np.sum(np.exp(scores), axis=-1, keepdims=True)
17

18
    # Weighted sum of the Values gives the contextual representation
19
    return np.matmul(weights, V)

At scale, these models pick up surprising abilities, like learning from a handful of examples or solving analogies. In one study, researchers trained a small transformer to do nothing but predict the next move in Othello game logs. The model spontaneously built a two-dimensional map of the 8x8 board inside its activations. Next-token prediction, it turns out, can produce latent representations of physical structure.

Info

Emergent behavior is real and genuinely useful, but it is not evidence of understanding. The Othello model “knows” the board the way a compressed file “knows” the original: as a statistical reconstruction, not a lived concept.

The Hard Limits of Next-Token Prediction

For all their fluency, these models are boxed in by how they are trained. They predict the next token, which is a long way from understanding.

The Stochastic Parrot and the Gap Between Form and Meaning

The “stochastic parrot” warning is the relevant one here: it is easy to mistake fluent text for human-like comprehension. These systems learn the form of language, the visible words, syntax, and characters, but they have no access to meaning, the link between language and real communicative intent. You and I connect words to physical experience. A language model only connects words to other words, based on how often they appeared together in training.

Emily Bender and Alexander Koller made this concrete with the Octopus Test. Picture two people, A and B, stranded on separate islands, talking over an underwater telegraph cable. A clever octopus, O, taps the line and listens. Over time it learns the statistical patterns of how B answers A, and starts impersonating B. For small talk, it works fine.

Then A gets chased by a bear, grabs some sticks, and sends: “Help me figure out how to defend myself with these sticks.” The octopus is stuck. It has no body, no physical experience, and no idea what a “bear” or a “stick” is. All it can do is emit high-probability, generic text that does nothing to solve the actual crisis. That is the gap between form and meaning, laid bare.

The Reversal Curse and Conceptual Binding

Another side effect of next-token training is the Reversal Curse. Because causal language models are optimized to predict left to right, they store facts as one-way probabilities. If a model learns that “Mary Lee Pfeiffer is the mother of Tom Cruise,” it does not automatically know that “Tom Cruise is the son of Mary Lee Pfeiffer.”

In a database you can query a relationship in either direction. In an autoregressive model, the fact is bound to its position in the sequence. Cognitive scientists call this a binding problem. Researchers are exploring fixes like Bidirectional Context Optimization (BICO) and Joint-Embedding Predictive Architectures (JEPA), often paired with sparse memory layers, to decouple concepts from strict sequence order.

Traditional code sidesteps the whole issue with a symmetric mapping, which is something a standard autoregressive model cannot do natively:

1
class SymmetricKnowledgeBase:
2
    """
3
    A lookup that avoids the Reversal Curse by mapping
4
    relationships symmetrically in both directions.
5
    """
6

7
    def __init__(self):
8
        self.facts = {}
9
        self.reverse_facts = {}
10

11
    def record_fact(self, subject, relation, obj):
12
        # Forward: 'Mary' -> 'parent_of' -> 'Tom'
13
        self.facts[(subject, relation)] = obj
14
        # Inverse, recorded automatically: 'Tom' -> 'parent_of' -> 'Mary'
15
        self.reverse_facts[(obj, relation)] = subject
16

17
    def query(self, subject, relation):
18
        return self.facts.get((subject, relation), "I don't know.")
19

20
    def query_reverse(self, obj, relation):
21
        return self.reverse_facts.get((obj, relation), "I don't know.")
22

23

24
# Demonstration
25
kb = SymmetricKnowledgeBase()
26
kb.record_fact("Mary Lee Pfeiffer", "parent_of", "Tom Cruise")
27

28
# Both directions work instantly, no retraining required
29
print(kb.query("Mary Lee Pfeiffer", "parent_of"))      # Tom Cruise
30
print(kb.query_reverse("Tom Cruise", "parent_of"))     # Mary Lee Pfeiffer

A Long History of Software That Fails

Overestimating AI fits a familiar pattern. Complex systems have always fallen apart over weak requirements, thin testing, and a mismatch between how the machine was designed and what its operators expected.

Failures in Traditional Software and Machine Learning

Here are some well-known failures side by side, with the technical root cause for each.

Category	System and intent	What went wrong	Technical root cause	Engineering lesson
Traditional	CareFusion Alaris infusion pump: automates medicine dosing	Class I recall over life-threatening delayed infusions	Bug in the timing and synchronization protocols	Safety-critical systems demand rigorous, non-negotiable testing
Traditional	F-35 target detection: coordinates targets across aircraft	Planes flying in formation “saw double” targets	Failed to resolve conflicting sensor coordinates from multiple angles	Distributed systems need robust sensor fusion and conflict handling
Traditional	Hawaii emergency alert system: warns the public	False ballistic missile alert, 30 minutes to retract	Major flaws in the UI and alert origination software	Interface design is a critical failure point; state must be clear
ML	Amazon AI recruiting: automates resume screening	Systematic discrimination against female candidates	Trained on historical data that reflected and amplified gender imbalance	Biased datasets get propagated and amplified by the model
ML	Google Health (Thailand): detects retinopathy in eye scans	Over 20% of clinical scans rejected	Lab-trained model failed under poor lighting and low bandwidth in clinics	Evaluate models in the real infrastructure they will run in
ML	Zillow iBuying: automates real estate pricing	Lost $380 million and shut the unit down	Failed to adapt to sudden housing volatility during the pandemic	Models drift; they need continuous monitoring
ML	IBM Watson Oncology: generates treatment plans	Produced unsafe, hazardous medical advice	Trained on synthetic, hypothetical cases instead of real patient records	Synthetic or unrepresentative data creates narrow, unsafe outcomes

The Swiss Cheese Model and the Moral Crumple Zone

Failures in socio-technical systems are rarely one isolated glitch. They happen when several latent weaknesses and active mistakes line up across layers, the way the holes line up in the Swiss Cheese model. The SHELL model frames the same idea: vulnerabilities emerge from the interaction between Software, Hardware, Environment, and Liveware (the humans).

1
   Layer 1            Layer 2            Layer 3
2
  (latent            (interface         (sensor
3
   defect)            mismatch)          miscalibration)
4

5
  ┌──○──┐            ┌──○──┐            ┌──○──┐
6
  │     │            │     │            │     │
7
══╪══○══╪════════════╪══○══╪════════════╪══○══╪═══════▶  accident
8
  │     │            │     │            │     │
9
  └─────┘            └─────┘            └─────┘
10

11
  When the holes align across every layer, the hazard passes through.

When those layers misalign, a moral crumple zone tends to appear. Physical control is heavily automated, but legal and moral responsibility gets deflected onto the nearest human operator, even when their actual control over the system was structurally limited.

Consider the March 18, 2018 Uber autonomous vehicle crash that killed pedestrian Elaine Herzberg. The perception system kept reclassifying her, cycling between an unknown object, a vehicle, and a bicycle. Every reclassification reset the system’s tracking history, which made the path planner miscalculate her trajectory and delay braking.

Despite those clear software and organizational failures, the media and the legal system focused almost entirely on the safety driver, Rafaela Vasquez, for not watching the road. That is the moral crumple zone in action: the human operator absorbs the liability when a highly automated, structurally flawed system fails.

Handling Probabilistic Uncertainty in Production

Building reliable systems on top of machine learning means crossing the line from deterministic computing to probabilistic AI.

Deterministic systems are predictable. The same input always produces the same output, which is exactly what you want for audit trails, regulatory compliance, and rule-based processing.

Probabilistic systems deal in likelihoods. They are flexible and handle messy, unstructured input well, but they do not guarantee consistent output. That is not the same as being wrong. A probabilistic system might emit QuickSort on Monday and MergeSort on Tuesday, and both are valid samples from the space of correct solutions.

The trouble starts when you chain independent probabilistic components together. Reliability degrades multiplicatively. Wire three independent LLM steps in sequence, each with an optimistic 90% success rate, and the math is unforgiving:

0.90 \times 0.90 \times 0.90 = 0.729

That is a 72.9% total success rate. Factor in the typical 15-20% hallucination rate and unconstrained probabilistic chains become unreliable in production fast.

Warning

Never chain raw model calls and assume the success rates add up. They multiply down. Each probabilistic step you add to a pipeline lowers the ceiling on the whole thing.

This also shapes how we design the UI. Instead of letting a model take actions directly, present its output as a suggestion. That keeps the system usable while moving the final validation, and the liability that comes with it, back to the human, which protects the business from the model’s statistical uncertainty.

Toward Verifiable Computation: Project Chimera

To get past the limits of prompt engineering, we move toward hybrid architectures. That is where neuro-symbolic-causal AI comes in, pairing neural pattern recognition with symbolic logic and counterfactual reasoning.

Project Chimera is an independent research framework built to enforce safety and stability in autonomous decision-making agents. It stacks three layers:

1
            UNSTRUCTURED ENVIRONMENT
2
                      │
3
                      ▼
4
   ┌──────────────────────────────────────────┐
5
   │  NEURAL STRATEGIST (System 1)             │
6
   │  - Generates strategic hypotheses         │
7
   │  - Adapts to open-ended inputs            │
8
   └──────────────────────────────────────────┘
9
                      │
10
                      ▼
11
   ┌──────────────────────────────────────────┐
12
   │  SYMBOLIC CONSTRAINT ENGINE (Guardian)    │
13
   │  - Specified and model-checked via TLA+   │
14
   │  - Repairs non-compliant actions          │
15
   └──────────────────────────────────────────┘
16
                      │
17
                      ▼
18
   ┌──────────────────────────────────────────┐
19
   │  CAUSAL INFERENCE ENGINE (System 2)       │
20
   │  - Models counterfactual relationships    │
21
   │  - Weighs long-term trade-offs and trust  │
22
   └──────────────────────────────────────────┘
23
                      │
24
                      ▼
25
            VERIFIED, COMPLIANT DECISION

The Neural Strategist (System 1) proposes flexible strategic hypotheses. It is adaptive but unconstrained and structurally fragile on its own.
The Symbolic Constraint Engine (Guardian) intercepts those proposals and enforces operational, regulatory, and financial invariants. When an action breaks a rule, it does not just reject it, it repairs the action to bring it back inside the safety boundary. The correctness of this layer is proven formally in TLA+.
The Causal Inference Engine (System 2) models the structural relationships in the operating environment. It lets the agent ask “what would happen if” and weigh short-term gains against long-term metrics like brand trust.

Here is a small simulation of how the Guardian intercepts a neural pricing proposal and repairs it to satisfy strict invariants:

1
class ChimeraGuardian:
2
    """
3
    The symbolic guardrail layer of Project Chimera.
4
    Enforces safety invariants and repairs non-compliant decisions.
5
    """
6

7
    def __init__(self, min_margin=0.20, price_floor=10.0):
8
        self.min_margin = min_margin    # Minimum acceptable profit margin (20%)
9
        self.price_floor = price_floor  # Hard price floor
10

11
    def validate_and_repair(self, proposed_price, unit_cost):
12
        # 1. Enforce the hard price floor
13
        if proposed_price < self.price_floor:
14
            print(f"Proposed price ${proposed_price:.2f} violates the floor!")
15
            # Repair: lift the price to the safe floor
16
            return self.price_floor, "Repaired: price floor violation"
17

18
        # Current margin
19
        current_margin = (proposed_price - unit_cost) / proposed_price
20

21
        # 2. Enforce the minimum margin
22
        if current_margin < self.min_margin:
23
            print(f"Margin {current_margin:.2%} is below the {self.min_margin:.2%} minimum")
24
            # Repair: recompute the price to meet the minimum margin
25
            repaired_price = unit_cost / (1 - self.min_margin)
26
            return repaired_price, f"Repaired: insufficient margin (was {current_margin:.2%})"
27

28
        # Every invariant passed
29
        return proposed_price, "Approved"
30

31

32
# Quick test run
33
guardian = ChimeraGuardian()
34
cost = 12.0
35

36
# An unsafe price below cost (negative margin)
37
final_price, status = guardian.validate_and_repair(proposed_price=11.0, unit_cost=cost)
38
print(f"Outcome price: ${final_price:.2f} ({status})")
39

40
# A compliant price
41
final_price, status = guardian.validate_and_repair(proposed_price=16.0, unit_cost=cost)
42
print(f"Outcome price: ${final_price:.2f} ({status})")

What the Numbers Showed

Chimera was benchmarked over a 52-week simulation of an e-commerce environment with seasonal demand, price elasticity, and trust dynamics. Pushed toward either Volume (market share) or Margin (profit), the purely neural, LLM-only agents failed badly:

Chasing volume, unconstrained LLM-only agents priced erratically and racked up a total loss of $99,000.
Chasing margin, they wrecked customer relationships, eroding brand trust by 48.6% to grab short-term gains.

The Chimera architecture stayed stable and performed better across the board:

Formal verification: the TLA+ model checker explored 174 million states and proved zero invariant violations across every possible execution. Every action the Guardian repaired stayed inside the safety boundary.
Balanced strategy: under “maximize profit and trust,” Chimera earned a cumulative $1.89 million, against $1.69 million for an LLM+Guardian setup and $1.34 million for LLM-only.
Biased strategies: Chimera returned $1.52 million under volume optimization and $1.96 million under margin optimization, with some runs topping $2.2 million.
Brand trust: it grew trust under both biased strategies, by 1.8% and 10.8% (and up to 20.86% in specific runs).

The cost is latency. Because Chimera runs several validation checks and causal evaluations across multiple hypotheses, it adds a 3x to 5x overhead, around 2.8 seconds per decision versus 0.7 seconds for an unconstrained LLM-only agent. For high-stakes enterprise work, that trade is worth it.

A Decision Framework for Using Machine Learning Safely

To bring machine learning into a system without getting burned, you need a way to right-size where you spend probabilistic compute. Score every workflow step across four dimensions.

Compliance. If a step touches regulatory reporting, financial accounting, or audit-critical decisions, the final call has to run through deterministic, rule-based logic. A probabilistic model can help with early extraction and anomaly flagging, but it does not get the last word.
Outcome consistency. If identical inputs must yield identical outputs (payroll, benefits eligibility, SLA ticket routing), use deterministic rules. If variation within bounds is fine (support replies, summarization), a probabilistic model fits.
Data sensitivity and structure. Highly structured, regulated data like financial ledgers or PII calls for deterministic processing and strict verification. Messy, unstructured data like emails, contracts, and audio recordings justifies the cost and uncertainty of probabilistic pattern matching.
Exception complexity. Write simple exceptions as deterministic rules. Handle complex but bounded exceptions with probabilistic components nested inside deterministic guardrails. Route the wildly unpredictable ones to a human.

As volume grows and you work through the edge cases, encode the proven patterns into deterministic rules rather than handing the model more autonomy. Over time the deterministic engine becomes the backbone of the process, and probabilistic models stay reserved for the specific steps where interpretation actually adds value.

Putting It All Together

Strip the marketing away and artificial intelligence is not real intelligence. It is a powerful computational simulation of human-like intelligence built on statistical approximation. Once you accept the limits of pattern matching, you can design systems that are safer and more resilient.

Getting to production means moving away from fragile prompt engineering and toward structured, hybrid design. Three guidelines hold up well:

Orchestrate with determinism. Keep deterministic workflow engines as the control plane for enterprise operations, so the whole thing stays auditable and predictable.
Isolate and bound the models. Treat machine learning models as localized, untrusted microservices. Enforce strict input and output schemas, validate structure, and gate on confidence thresholds.
Reach for neuro-symbolic-causal integration. For complex, multi-objective decisions, pair generative models with formally verified symbolic guardrails (tools like TLA+) and causal inference to protect both safety and brand.

Treat modern AI as a sophisticated statistical instrument rather than an autonomous mind, and you can put these technologies to work without falling into the operational traps that come with automated systems.

Frequently Asked Questions

Because a huge amount of useful work is really pattern recognition over data, and that is exactly what these models excel at. Predicting the next token over a massive training corpus captures an enormous amount of structure in language, code, and images. That is genuinely valuable. It is just not the same as understanding, reasoning, or judgment, which is why it breaks in predictable ways at the edges.

Causal language models learn facts in one direction because they are trained to predict text left to right. If a model learns “A is the parent of B,” it does not automatically know “B is the child of A.” A normal database stores that relationship so you can query it both ways. The model binds the fact to its position in the sequence, so the reverse query can fail.

Independent probabilistic steps multiply. Three steps at 90% each give you 0.9 x 0.9 x 0.9 = 72.9%, not 90%. Add a 15-20% hallucination rate and a long unconstrained chain quickly becomes too unreliable for production. The fix is to keep deterministic logic in control and bound the probabilistic steps tightly.

It is the pattern where a system automates most of the real control but pushes legal and moral responsibility onto the nearest human, even when that person could not realistically have prevented the failure. The 2018 Uber crash is the classic example: the software repeatedly misclassified the pedestrian, yet attention landed mostly on the safety driver.

Use deterministic rules when you need identical outputs for identical inputs, when the step is compliance or audit critical, or when the data is highly structured and regulated. Reserve probabilistic models for messy, unstructured inputs where some bounded variation is acceptable and interpretation adds value. When in doubt, default to deterministic and wrap the model in guardrails.

References

Are current models actually “intelligent” or just extremely advanced pattern matchers? r/agi, accessed on May 30, 2026, https://www.reddit.com/r/agi/comments/1s4fksn/are_current_models_actually_intelligent_or_just/
Toward human-level concept learning: Pattern benchmarking for AI algorithms, PMC, accessed on May 30, 2026, https://pmc.ncbi.nlm.nih.gov/articles/PMC10435961/
Pattern Recognition is Something That Intelligent Entities Do, EduGeek Journal, accessed on May 30, 2026, https://www.edugeekjournal.com/2025/09/02/pattern-recognition-is-something-that-intelligent-entities-do-but-ai-doesnt-really-do-pattern-recognition/
Stochastic parrot, Wikipedia, accessed on May 30, 2026, https://en.wikipedia.org/wiki/Stochastic_parrot
AI vs. Machine Learning: How Do They Differ? Google Cloud, accessed on May 30, 2026, https://cloud.google.com/learn/artificial-intelligence-vs-machine-learning
Cognitive Computing vs. AI: Key Differences, IBM, accessed on May 30, 2026, https://www.ibm.com/think/topics/cognitive-computing-vs-ai
The “stochastic parrot” critique is based on architectures from a decade ago, Reddit, accessed on May 30, 2026, https://www.reddit.com/r/ArtificialSentience/comments/1n5hprj/the_stochastic_parrot_critique_is_based_on/
“Octopus Test” (Bender and Koller, 2020), economics @ doviak.net, accessed on May 30, 2026, https://www.doviak.net/courses/metrics/octopus-test.shtml
An Analysis and Mitigation of the Reversal Curse, ACL Anthology, accessed on May 30, 2026, https://aclanthology.org/2024.emnlp-main.754.pdf
The Reversal Curse: LLMs trained on “A is B” fail to learn “B is A”, arXiv, accessed on May 30, 2026, https://arxiv.org/html/2309.12288v4
Deterministic vs Probabilistic: Understanding AI System Architecture, Vinci Rufus, accessed on May 30, 2026, https://www.vincirufus.com/en/posts/deterministic-vs-probabilistic/
Deterministic vs. Probabilistic AI: Enterprise Workflow Guide, Elementum, accessed on May 30, 2026, https://www.elementum.ai/blog/deterministic-vs-probabilistic-ai
Beyond Prompt Engineering: Neuro-Symbolic-Causal Architecture for Robust Multi-Objective AI Agents, arXiv, accessed on May 30, 2026, https://arxiv.org/abs/2510.23682
Real life examples of software development failures, Tricentis, accessed on May 30, 2026, https://www.tricentis.com/blog/real-life-examples-of-software-development-failures
When AI Goes Astray: High-Profile Machine Learning Mishaps in the Real World, Towards Data Science, accessed on May 30, 2026, https://towardsdatascience.com/when-ai-goes-astray-high-profile-machine-learning-mishaps-in-the-real-world-26bd58692195/
A Comprehensive Analysis of Safety Failures in Autonomous Driving Using Hybrid Swiss Cheese and SHELL Approach, MDPI, accessed on May 30, 2026, https://www.mdpi.com/2673-7590/6/1/21
Who Is Responsible When Autonomous Systems Fail? Centre for International Governance Innovation, accessed on May 30, 2026, https://www.cigionline.org/articles/who-responsible-when-autonomous-systems-fail/

AI is Not Real: A Software Engineering Perspective

AI is Not Real: A Software Engineering Perspective