SkillBridge Training · live network · v0.3 (3 weeks old)

Learn how AI thinks by stepping
inside a neural network you can touch.

A small learning studio for absolute beginners. No prior code, no abstract math walls — you'll move from a single neuron to your first image classifier, one activation at a time.

~24h
guided sessions
9
core concepts
3 wks
since launch
0 → 1
your first model
cursor → modulates synapses
scroll → activate next layer

Modules emerge before introductions.

We won't bury the course under a brand story. Here are the nine knowledge nodes you'll travel through, in roughly the order their signals fire.

  • node · 01 concept

    What is Artificial Intelligence?

    Where 'AI' actually lives in software you already use — and where it doesn't.

    weight 0.92 · bias 0.38
  • node · 02 mental model

    Neural Networks, gently

    Neurons, layers, signals. A working mental model before any code.

    weight 0.88 · bias 0.31
  • node · 03 build

    The Perceptron

    The smallest decision-maker. We build one by hand.

    weight 0.99 · bias 0.24
  • node · 04 data

    Training Data

    Why data shape matters more than model size when you're starting.

    weight 0.42 · bias 0.12
  • node · 05 math, lightly

    Loss Functions

    How a network knows it's wrong — and what it does about it.

    weight 0.48 · bias 0.09
  • node · 06 build

    Your First Simple Model

    End-to-end: data in, prediction out, in a single notebook.

    weight 0.85 · bias 0.18
  • node · 07 vision

    Image Classification Basics

    Pixels → features → a model that can tell cats from not-cats.

    weight 0.76 · bias 0.22
  • node · 08 language

    Text Examples

    Tokens, embeddings, and tiny language tasks you can run yourself.

    weight 0.63 · bias 0.15
  • node · 09 lab

    Google Colab Exercises

    Free GPU notebooks. No setup. Just open and learn.

    weight 0.57 · bias 0.33
layer 02 · forward pass

The learning roadmap, traced as a signal.

node://roadmap
week 1

Sense the shape of AI

Build intuition. Watch a perceptron learn AND, OR, then XOR fail spectacularly.

week 2

Data, loss, gradient

Three words that sound scary and aren't. We meet each one with a slider, not a chalkboard.

week 3

Your first real model

A small image classifier in Colab. You'll watch its loss curve breathe.

week 4

Pick a path

Vision, text, or a tiny personal project — guided, not graded.

layer 03 · mechanics

How a neural network actually works.

node: //neurons
input hidden output

A neuron takes numbers, multiplies them by weights, adds a bias, and squashes the result. That's it. Everything else is repetition.

A layer is many neurons in parallel. A network is layers stacked so each one reads the previous one's opinion.

Training is the loop: predict, measure how wrong, nudge every weight a little in a better direction, repeat — often millions of times.

predict → loss → gradient → nudge → predict …

layer 04 · interactive

AI Concepts Playground.

Drag the sliders. This single neuron fires only when its inputs and weights agree. Same arithmetic that powers the largest models alive — just smaller.

node://playground
z = w₁·x₁ + w₂·x₂ + b = 0.000
y = σ(z) = 0.500
x₁ input 0.60
x₂ input 0.30
w₁ weight 1.40
w₂ weight -0.80
bias b 0.10

layer 05 · activations[]

Student projects, as fired nodes.

node://projects

These aren't case studies. They're notebooks beginners actually finished. Each one is a node that lit up after the right inputs.

  • PJ-01 activated

    Cat vs. Not-Cat

    1-layer model on a 200-image set. Accuracy curve drawn live in Colab.

    acc 0.86
    open ↗
  • PJ-02 activated

    Tip-Sentiment

    Tiny logistic model classifying restaurant reviews as 👍 or 👎.

    f1 0.78
    open ↗
  • PJ-03 activated

    Hand-drawn Digits

    MNIST with a 2-layer net, end-to-end in one notebook.

    acc 0.94
    open ↗
  • PJ-04 activated

    XOR, finally

    Why one neuron can't do it, and what changes when you add a hidden layer.

    loss ↓
    open ↗
  • PJ-05 activated

    Spam Sieve

    Text → bag-of-words → tiny classifier. Watch the false positives.

    prec 0.81
    open ↗
  • PJ-06 activated

    Pixel Painter

    Generate a 16×16 image from a noise vector. Your first generative toy.

    epoch 50
    open ↗
layer 06 · output vector node://outputs

Outputs from real learners.

We're three weeks old. These are early beta students whose models successfully converged — and whose confidence did too.

  • PJ-03 → Ana D. weight +0.92

    "I built a digit recognizer the second weekend. Not a tutorial copy — I actually understood the layers."


  • PJ-01 → Marcus L. weight +0.88

    "First time math felt like a tool, not a wall. The perceptron page broke it open for me."


  • PJ-05 → Reem K. weight +0.81

    "Plain language, no hype. Three weeks in, I shipped a spam filter on my own emails."


  • PJ-06 → Iván R. weight +0.79

    "I'd bounced off two huge AI courses before this. The pacing here is humane."


layer 07 · trajectory

A typical student trajectory.

node://journey Day 1: open a notebook Day 3: a working perceptron Day 7: first loss curve Day 14: an image model Day 21: a project you wrote.

layer 08 · historical context

An interactive AI timeline.

  1. 1943
    McCulloch–Pitts neuron

    The first mathematical idea of a neuron, on paper.

  2. 1958
    Perceptron

    Rosenblatt builds a learning machine — yes, the one you used above.

  3. 1986
    Backpropagation

    Networks finally learn deep representations efficiently.

  4. 2012
    AlexNet

    Deep learning wins ImageNet. Vision changes overnight.

  5. 2017
    Transformers

    Attention reshapes language modeling — the seed of modern LLMs.

  6. Now
    You

    An interactive moment where understanding becomes accessible.

layer 09 · practice lab

What a Colab session actually looks like.

lesson-06_first-model.ipynb  ·  python 3  ·  GPU runtime
# Step 6: train a tiny image classifier
import torch, torch.nn as nn
from torchvision import datasets, transforms

train  = datasets.MNIST(".", download=True, train=True, transform=transforms.ToTensor())
loader = torch.utils.data.DataLoader(train, batch_size=64, shuffle=True)

net  = nn.Sequential(nn.Flatten(), nn.Linear(28*28, 64), nn.ReLU(), nn.Linear(64, 10))
opt  = torch.optim.Adam(net.parameters(), lr=1e-3)
loss = nn.CrossEntropyLoss()

for epoch in range(3):
    for x, y in loader:
        opt.zero_grad()
        loss(net(x), y).backward()
        opt.step()
    print(f"epoch {epoch} → ok")  # you'll watch the loss number drop
layer 10 · network evolution

Four evolution stages — pick where to start.

Each plan is a stage in a small network growing up. Start at one neuron; upgrade as your curiosity adds layers.

stage · S1single neuron

Starter Access

$29 / one-time
  • Full video course access
  • Basic AI & neural-network explanations
  • Perceptron introduction
  • Lifetime access
stage · S2first hidden layer

Standard Course

$79 / one-time
  • Everything in Starter
  • Google Colab exercises
  • Simple image & text models
  • Homework assignments
  • Completion certificate
most chosen pathway
stage · S3multi-layer network

Pro Learning Path

$149 / one-time
  • Everything in Standard
  • Additional practice projects
  • Build your first AI model project
  • Assignment review
  • Basic Q&A support
stage · S4fine-tuned

Premium Mentorship

$299 / one-time
  • Everything in Pro
  • 1:1 online session
  • Project reviews
  • Personalized AI learning plan
  • AI career guidance
Certificate PDF $15
Extra Practice Pack $25
AI Career Roadmap $49
Community Access (Discord/Telegram) $10/mo
node://resources
  • resource · 01

    AI in plain English

    A 12-min companion read written for total beginners.

  • resource · 02

    Glossary of 40 terms

    Words you'll meet — defined once, in a sentence each.

  • resource · 03

    Cheat-sheet PDF

    One page. The whole training loop, visually.

  • resource · 04

    Beginner notebook pack

    Five Colab notebooks you can open immediately.

layer 12 · latest emissions

Latest AI insights.

node://insights
  • fundamentals

    Why your first model should be embarrassingly small

    Big networks hide the lessons. Start tiny and you'll understand the gradient.

    → read note
  • vision

    Pixels are just numbers in a costume

    How a black-and-white digit becomes a vector your model can read.

    → read note
  • career

    What 'know AI' actually means in 2026

    Hiring signals from real listings — what beginners are expected to demonstrate.

    → read note
Layer 13 · Queries
node://faq

Frequently asked questions.

  • No. The first week is about intuition. Code shows up by week two, and only in small, friendly notebooks.

  • Multiplication, addition, and a curve that squashes numbers. That's enough to begin. Anything heavier appears optionally and visually.

  • Fair. We're upfront: we're a young studio, not a global academy. We make that obvious so your expectations match reality. Lifetime access protects you if we keep improving.

  • Yes, from Standard upward. It says you finished the work — not that you're suddenly an engineer. We don't oversell it.

  • 14-day refund window on any plan, no questions, as long as you actually try the first module.

layer 14 · the studio

A small studio, three weeks in.

SkillBridge Training is a young online learning studio. We launched three weeks ago with a single bet: most "intro to AI" material is written for people who already half-understand it.

We're building the course we wish we'd had — calm, visual, and honest about what's hard. We're not an academy. We're not the future of education. We're a small team, careful with your time, iterating in public.

If you finish a module and something still feels foggy, that's a bug in our explanation, not in you. Write us. We'll fix it in the next pass.

node://studio
studio snapshot
  • age3 weeks
  • teamsmall, hands-on
  • focusAI for beginners
  • stylevisual + practical
  • promiseno overclaims
layer 15 · terminal node

The final node — say hello.

node://contact
✓ signal received — we'll be in touch soon.
direct channels
network status
modules
online
lab
online
studio
online