Artificial intelligence (AI) is the field of computer science that builds systems able to do tasks that normally need human intelligence: understanding language, recognizing images, making predictions and making decisions.
Modern AI doesn't follow a long list of hand-written rules. It learns patterns from data and then applies those patterns to new input. A spam filter learns what spam looks like; a chatbot such as ChatGPT, Claude or Copilot learns how language works from enormous amounts of text. Reduced to one line, AI is software that learns from data to predict, generate or decide.
If you need a precise definition, the OECD's is the one the EU AI Act builds on: an AI system is a machine-based system that, for explicit or implicit objectives, infers from the input it receives how to generate outputs such as predictions, content, recommendations or decisions that can influence physical or virtual environments.
The one idea behind modern AI
With traditional software, a developer writes the rules and decides every step. With machine learning, you supply examples and the system works out the rules itself:
Traditional programming
Rules + Data → Program → Answers
Machine learning (most modern AI)
Data + Answers → Training → Model (learned rules)
New data → Model → Predictions
Fraud detection, self-driving cars and ChatGPT are all variations on that picture.
The vocabulary around it is nested, with each term a subset of the one above:
Artificial Intelligence (AI)
└── Machine Learning (ML): learns from data
└── Deep Learning: ML with many-layered neural networks
└── Generative AI: deep learning that creates new content
└── Large Language Models (LLMs): generative AI for text and code
So every LLM is AI, but not all AI is an LLM, and not all AI is even machine learning. A chess engine that searches moves using hand-written rules is AI, and so is a rule-based expert system, but neither learns from data. Our article on the difference between AI, machine learning and deep learning goes further into where the boundaries sit.
How we got here
AI is older than most people assume, and its history runs in cycles of excitement and disappointment. Alan Turing published "Computing Machinery and Intelligence" in 1950, proposing what became known as the Turing test. At the Dartmouth workshop in 1956, John McCarthy and colleagues used the term "artificial intelligence" and the research field was born. Frank Rosenblatt's perceptron, an early artificial neural network, followed in 1958.
The 1980s brought expert systems, rule-based programs used in business and medicine. But the 1970s and late 1980s were also the "AI winters", when funding dropped because early promises weren't met. IBM's Deep Blue beat world chess champion Garry Kasparov in 1997.
The modern era starts in 2012, when AlexNet won the ImageNet competition by a large margin and deep learning took off. DeepMind's AlphaGo beat Lee Sedol at Go in 2016. In 2017, Google researchers published "Attention Is All You Need", introducing the Transformer architecture behind today's LLMs, and in 2022 OpenAI released ChatGPT and generative AI went mainstream. From 2024 to 2026 the story has been reasoning models, AI agents that use tools and run multi-step tasks, on-device AI on PCs with NPUs, and the first comprehensive AI law, the EU AI Act.
How AI actually works
Most AI you use today is machine learning, so start there and build up.
Machine learning: adjusting numbers until the answers are right
Machine learning trains a model on data. A model is a mathematical function with adjustable numbers called parameters, or weights, and training means nudging those parameters until the model's outputs match the expected answers as closely as possible:
Collect labelled data (emails marked spam / not spam)
↓
Model makes a prediction
↓
Compare prediction with the correct answer (loss)
↓
Adjust parameters to reduce the error
↓
Repeat thousands or millions of times
↓
Trained model ready for new emails
That loop comes in three main styles. Supervised learning learns from labelled examples, and it's behind spam filters, price prediction and image classification. Unsupervised learning finds structure in unlabelled data, which is useful for customer segmentation and anomaly detection. Reinforcement learning learns by trial and error from rewards; it's used in game-playing AI and robotics, and to fine-tune chatbots through reinforcement learning from human feedback (RLHF).
Neural networks and deep learning
A neural network is a machine learning model built from layers of simple units called neurons. Each neuron multiplies its inputs by weights, adds them up and passes the result through a simple function.
Input layer Hidden layers Output layer
(pixels) → [neurons] → [neurons] → ("cat": 0.94)
("dog": 0.06)
Deep learning just means neural networks with many layers. Early layers learn simple features, such as edges in an image, and deeper layers combine them into complex ones: eyes, faces, whole objects. It needs a lot of data and a lot of computing power, which is why GPUs and other AI accelerators became so important.
Large language models
A large language model is a deep neural network, usually a Transformer, trained on very large amounts of text and code. Its basic job is surprisingly modest: predict the next token, meaning a word or part of a word.
Prompt: "The capital of France is"
↓
Text is split into tokens
↓
Transformer layers use attention to weigh every token against the others
↓
Model outputs a probability for each possible next token
↓
" Paris" is chosen, appended, and the process repeats
At enough scale, next-token prediction produces models that can write, summarize, translate, answer questions and write code. They're then fine-tuned with human feedback to follow instructions and to be helpful and safe. Our explainer on how a large language model works covers this in more depth.
Generative AI isn't only text. Image models (diffusion models) and audio, music and video generators work on the same principle: learn the patterns of the training data, then produce new content that follows them.
One more distinction matters as soon as you build anything. Training is where the model learns its parameters; it's done once or occasionally, it's very expensive, and it runs on large GPU clusters. Inference is using the trained model to answer new inputs. It happens every time someone uses the model, and it runs in the cloud, on servers, or on devices with an NPU. As an application developer you'll spend almost all your time on the inference side.
Types of AI, and which ones exist
AI is usually classified two ways: by capability, meaning how general it is, and by functionality, meaning how it handles memory and understanding.
Type | What it means | Exists today? |
|---|
Narrow AI (ANI, weak AI) | Performs specific tasks, sometimes better than humans, but cannot transfer that skill freely to unrelated tasks | Yes. All AI in production today, including LLMs, is generally classed as narrow AI. |
Artificial General Intelligence (AGI) | Matches human ability across virtually any intellectual task, and learns new tasks the way people do | No. It is a research goal, and experts disagree on how to define it, how to measure it, and when or whether it will arrive. |
Artificial Superintelligence (ASI) | Exceeds human ability in every domain | No. It is hypothetical. |
Modern LLMs are far broader than older narrow systems, which is why the line between "narrow" and "general" is now actively debated. ChatGPT, for instance, is still considered narrow AI: it lacks human-level general intelligence and makes factual mistakes. As of October 2026, there's no widely accepted evidence that any system has reached AGI.
You'll also see AI split into four functional types. The framework, popularized by researcher Arend Hintze in 2016, is a teaching device rather than a technical standard, and only the first two types exist. Reactive machines respond to the current input with no memory of the past; Deep Blue is the classic example. Limited-memory systems use recent data or context to decide, like self-driving perception systems or a chatbot using the conversation so far. Theory-of-mind AI would genuinely understand that others have beliefs, emotions and intentions, and self-aware AI would have consciousness and a sense of self. Both are hypothetical, and there's no scientific consensus that the last one can be built.
Where you already use it
AI is inside products you use every day, often invisibly. For developers, the most visible use is in software development itself: code completion, code review, test generation, and coding agents that fix bugs and open pull requests. Businesses use it for customer support chatbots, document summarization, forecasting and meeting notes. In healthcare it's medical image analysis, drug discovery and clinical documentation, and in finance, fraud detection, credit risk and algorithmic trading. Netflix, Amazon and YouTube recommendations, search ranking and dynamic pricing are all AI, as are driver assistance and route optimization, voice assistants, photo enhancement, live captions, translation, spam filters, and the threat, phishing and log-analysis tools in security.
What it's good at, and where it goes wrong
The benefits are real. AI automates repetitive work such as drafting, summarizing, data entry and boilerplate code. It analyzes far more data than people can, such as millions of transactions checked for fraud. Speech-to-text, image descriptions and real-time translation help people with disabilities and people facing language barriers. It's speeding up research in areas such as protein structure prediction and materials science, and it answers at any hour.
The risks are just as real. Generative AI hallucinates: it produces confident answers that are false, so anything important needs verifying. Models absorb the biases in their training data and can treat groups of people unfairly. Sensitive data can leak through prompts, logs or training data, and there are new attack surfaces in prompt injection, jailbreaks, AI-generated phishing and deepfakes. Some tasks get automated away and many roles change. People over-rely on output they haven't checked. And training and running large models takes significant power and hardware.
None of that means "don't use AI". It means keep a human accountable, test your system, and protect your data.
The EU AI Act timeline
The EU AI Act is the first comprehensive AI law. It sorts AI systems by risk into four tiers: unacceptable (banned), high (strict requirements), limited (transparency duties) and minimal (no new obligations). It also has specific rules for general-purpose AI (GPAI) models such as large LLMs.
In 2026 the EU adopted the "AI Omnibus", which pushed back the high-risk deadlines and added a new prohibition. Based on the European Commission's AI Act page, these are the dates that matter:
Date | What applies |
|---|
1 August 2024 | The AI Act enters into force |
2 February 2025 | Bans on unacceptable-risk practices (for example social scoring and manipulative AI) and AI literacy duties begin |
2 August 2025 | Governance rules and obligations for general-purpose AI models apply |
27 July 2026 | The AI Omnibus amendments enter into force |
2 August 2026 | Most of the Act applies, including the transparency rules (for example disclosing AI interactions and labelling AI-generated content) |
2 December 2026 | New ban on AI systems that generate non-consensual intimate imagery or child sexual abuse material (added by the Omnibus) |
2 December 2027 | High-risk rules for stand-alone systems in sensitive areas (Annex III), such as hiring, credit scoring and education |
2 August 2028 | High-risk rules for AI embedded in regulated products (Annex I), such as medical devices and machinery |
Other regions take different approaches, from sector-specific rules and executive guidance to voluntary frameworks such as the NIST AI Risk Management Framework in the United States. If you build AI products for EU users, check the Act's requirements against your use case early, not after launch.
Learning AI as a developer
You don't need a PhD to build useful AI applications. A developer can build a working LLM-powered app in a few weeks; solid machine learning fundamentals usually take several months of steady practice, and research-level depth takes years. This is the order I'd learn things in:
- Python basics. Most AI tooling, tutorials and research code is in Python. C# developers can build AI apps in .NET, but Python lets you read the examples.
- The core math at an intuitive level: vectors, matrices, probability and the idea of gradients. You need intuition, not proofs.
- Classic models. Build a classifier and a regression model with scikit-learn (Python) or ML.NET (C#), and learn train/test splits, overfitting and metrics.
- Deep learning. Train a small neural network with PyTorch until layers, loss functions and backpropagation make sense.
- Building with LLMs. Call a model API, write good prompts, use structured output and tool calling, and build retrieval-augmented generation (RAG) over your own documents.
- Agents and evaluation. Learn tool use, the Model Context Protocol (MCP), and how to test AI output against evaluation sets.
- AI security and responsibility: prompt injection, data privacy and bias testing.
The most common beginner mistake is skipping straight to step five, picking up an LLM framework without knowing what a model, a token or an embedding is. The others are close behind: testing a model on the data it was trained on, which makes it look better than it is; trusting output without verification, especially facts, numbers and code; pasting secrets or customer data into prompts without checking the provider's data policy; and building an agent before you have any way to tell whether its answers are correct.
Your first AI call in C#
The Microsoft.Extensions.AI libraries give .NET a single IChatClient interface that works across many providers. This example from the Microsoft Learn IChatClient documentation talks to a model running locally in Ollama, so you don't need an API key:
dotnet new console -n FirstAi
cd FirstAi
dotnet add package Microsoft.Extensions.AI
dotnet add package OllamaSharp
using Microsoft.Extensions.AI;
using OllamaSharp;
IChatClient client = new OllamaApiClient(
new Uri("http://localhost:11434/"), "phi3:mini");
Console.WriteLine(await client.GetResponseAsync("What is AI?"));
Install Ollama, run ollama pull phi3:mini, then dotnet run. Because your code depends on IChatClient rather than a vendor SDK, you can later switch to OpenAI, Azure OpenAI or another provider without rewriting your app logic.
Your first machine learning model in Python
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = RandomForestClassifier()
model.fit(X_train, y_train) # training
print(model.score(X_test, y_test)) # accuracy on unseen data
Those few lines contain the whole machine learning loop: data, training, and evaluation on data the model hasn't seen.
As for whether AI will replace programmers: it already writes a lot of code, but developers still define requirements, design systems, review output and take responsibility for what ships. The work is shifting toward directing and verifying AI tools. The developers who learn to do that well get more productive, and the two small programs above are a reasonable first step.
Arun PottiPosted Nov 12, 2026, 10:51 PM
Great article.