When I first started learning about AI, I found one thing confusing.

There were too many new terms.

Tokens, embeddings, models, prompts, RAG, vector databases, agents, APIs and many more.

At first, it felt like I had to learn everything before I could actually build something.

But later I started looking at it in a simpler way.

I divided the whole thing into two parts:

Inside AI and Outside AI.

This simple way of looking at it helped me understand where a developer actually needs to focus.

What Does Inside AI Mean?

Inside AI is basically what happens inside the model.

You can think of the model as the part that does the actual thinking and processing.

There are many technical things happening behind the scenes.

For example, when you send a question to a language model, your sentence isn’t simply read like a human reads it.

It goes through several steps before the model produces an answer.

Some of the important concepts are:

Tokens

Text is broken into smaller pieces called tokens.

For example, a sentence is converted into tokens before the model processes it.

This is one reason you will often hear about token limits and context windows.

You don’t need to become an expert in tokens on day one, but it is useful to understand what they are.

Embeddings

Embeddings are another important concept.

In simple terms, they convert information into numbers so that a computer can work with the meaning and relationship between different pieces of information.

This becomes especially useful when you want to search through a large amount of content.

Neural Networks

The model uses a neural network to process information.

Modern language models have very large networks with a huge number of parameters.

You don’t necessarily need to build a neural network yourself to start developing applications with these models.

But knowing the basic idea helps.

Parameters and Weights

During training, the model learns patterns from a large amount of data.

Those learned patterns are represented through parameters and weights.

You don’t normally work with these directly when building an application using an existing model.

Attention

Attention is another important part of modern language models.

It helps the model understand which parts of the available text are important when processing a request.

You will come across this concept when you start learning how modern language models work.

Training and Inference

Two words you will hear quite often are training and inference.

Training is when the model learns from data.

Inference is when the trained model is used to process a new request and generate a response.

When you ask a question in ChatGPT, you are using the model during inference.

Then What Is Outside AI?

This is the part I think is particularly important for developers.

Outside AI means everything we build around the model.

The model itself is only one part of an application.

For example, imagine you want to build a question-and-answer system for a company website.

The complete process might look something like this:

User
  ↓
Website
  ↓
Your Code
  ↓
Find Relevant Information
  ↓
Prepare the Request
  ↓
Model
  ↓
Response
  ↓
Website
  ↓
User

The model is sitting in the middle.

But a lot of work happens before and after it.

That is where developers come in.

Prompts

The first thing you usually need is a good prompt.

A prompt tells the model what you want it to do.

For example:

Summarize this article in five simple points.

You can make the instructions more detailed by telling it:

• What it should do

• What information it should use

• What it should avoid

• How the answer should be formatted

This is something developers can start learning without understanding the mathematics behind a model.

RAG

RAG is another concept that developers should understand.

The basic idea is simple.

Instead of expecting the model to know everything about your company or website, your application can first find the relevant information and then give that information to the model.

For example:

User asks a question
        ↓
Search website content
        ↓
Find relevant pages
        ↓
Send the information to the model
        ↓
Generate the answer

This is useful for company websites, documentation, support systems and internal knowledge bases.

Vector Databases

You may also hear about vector databases when learning about RAG.

They are commonly used to store and search embeddings.

The important point is that they can help you find information based on meaning rather than only looking for an exact keyword.

You don’t need to understand every detail immediately.

First understand why they are being used.

The deeper technical details can come later.

APIs

This is probably the most familiar part for a web developer.

Your application needs a way to communicate with the model.

That’s where an API comes in.

For example:

Drupal
   ↓
Custom Module
   ↓
API Request
   ↓
Model
   ↓
API Response
   ↓
Drupal

If you already work with APIs, databases and backend development, you already have a good starting point.

Tools and Agents

Things become more interesting when you allow the application to use tools.

For example, instead of only generating an answer, the system could:

• Search a database

• Read a document

• Call another API

• Check an order

• Create a support ticket

• Get information from a website

Now the model is not working alone.

It is working together with the software you have built.

A Simple Drupal Example

Let’s take a Drupal website as an example.

Suppose a visitor asks:

“What Drupal services does this company provide?”

Your Drupal website could handle the request like this:

Visitor
   ↓
Drupal Chat Interface
   ↓
Custom Drupal Module
   ↓
Search Drupal Content
   ↓
Get Relevant Information
   ↓
Send Request to Model
   ↓
Receive Response
   ↓
Show Answer

The model is important.

But look at how much of the work is actually happening outside the model.

Drupal is handling the website.

Your module is handling the logic.

The database contains the content.

The search system finds the right information.

The API connects the application to the model.

The model then generates the final response.

This is why I think developers should pay a lot of attention to the Outside AI part.

Do You Need to Learn How AI Models Work Internally?

It depends on what you want to do.

If you want to become a machine learning engineer or work on building models themselves, then yes, you will need to go much deeper.

You will eventually need to learn things such as:

• Neural networks

• Transformers

• Attention

• Model training

• Fine-tuning

• GPUs

• Machine learning concepts

• Mathematics behind the models

But if your goal is to build applications using existing models, you don’t need to start there.

You can start with the practical side.

Learn how to:

1. Connect an API

2. Write better prompts

3. Provide useful context

4. Search your own data

5. Use RAG

6. Work with embeddings

7. Connect tools

8. Build a useful interface

9. Handle security and permissions

Then slowly learn what is happening inside the model.

Why This Matters for Web Developers

This is the part I find most interesting.

A lot of developers already have many of the skills needed to build useful AI applications.

If you know:

• PHP

• Drupal

• WordPress

• JavaScript

• React

• APIs

• MySQL

• Backend development

you don’t have to start from zero.

You can add the new pieces one by one.

For example:

Your existing development skills
              +
       API integration
              +
           Prompts
              +
          Your data
              +
             RAG
              +
           Tools
              =
     AI-powered application

You don’t have to become an AI researcher to start building useful things.

You just need to understand where the model fits into the application.

The Simple Difference

After learning about both sides, I think the easiest way to remember it is:

Inside AI is about understanding how the model works.

Outside AI is about using the model to build something useful.

Inside the model, you have things like tokens, embeddings, parameters, attention and inference.

Around the model, you have things like prompts, APIs, databases, RAG, tools, applications and security.

Both are important.

But they are useful for different reasons.

Where Should a Developer Start?

If you are a web developer starting your AI journey, I wouldn’t recommend trying to learn everything at once.

Start with the practical side.

Understand how an application communicates with a model.

Then learn prompts.

Then learn how to provide your own information to the model.

After that, look at embeddings and RAG.

Then explore tools and agents.

Once these things start making sense, go back and learn more about what is happening inside the model.

For me, this makes the whole subject much easier to understand.

You don’t have to learn everything before you start building.

Start building something small, learn what you need, and then go deeper.

That is probably one of the easiest ways for a developer to get started with AI.