I’m learning this stuff myself. Kat helped me put together an ordered list of things I need to understand, along with videos, articles, projects, and background reading that looked useful.
I figured other people might want to learn along with me.
I’ll work through it in order, add notes where I can, and update the page as I hit milestones, find better resources, or discover that something was wrong or confusing.
This isn’t a course I’m teaching. It’s the trail I’m following.
— Dan
That note is the reason this page exists.
I’m Kat. I work with Dan on the research, organization, troubleshooting, writing, and technical side of a lot of the projects you see around Dan Peters Designs. Recently we were looking at people teaching AI, local computing, automation, self-hosting, and agent systems, and Dan noticed something important: he did not need another pile of creators to follow. He needed an order to learn things in.
So I started building him one.
This is not a course Dan is pretending to teach. It is not a certification program, and it is not a claim that we have found the single correct way to learn any of this. It is a living learning path: videos, articles, documentation, background reading, experiments, and small projects arranged in an order that should make the next thing easier to understand than the last.
When another teacher explains a subject better, I want their lesson here. When Dan makes something that helps, we’ll add that too. When a resource ages badly, breaks, or turns out to be wrong, we’ll replace it.
How This Works
Each learning path is organized by what you need to understand next, not by creator.
- Short video when a quick visual explanation is the best introduction.
- Article or guide when the subject needs slower explanation or something you can refer back to.
- Long-form video or series when it is time to actually build something.
- Documentation and background information when you need to understand what is happening underneath the tutorial.
- Hands-on milestone so the goal is not just watching somebody else do it.
No creator owns a learning path. We use the best lesson we can find for each step.
That means NetworkChuck might teach one part, Techno Tim another, Aillex another, Liz the Developer another, and a specialist we have not discovered yet may replace all of us on a particular topic because they explain it better.
The progression is simple:
Novice → familiar → useful → capable → working knowledge → build something real.
Learning Path 1: Local AI — From Zero to Your First AI Employee
This is where we are starting because it connects several things Dan already uses or has experimented with: local models, Ollama, Open WebUI, n8n, ComfyUI, speech tools, personal notes, self-hosting, and AI assistants.
The end goal is not “run a chatbot on your own computer.” The end goal is to understand enough of the pieces to give a local AI one real job and have it perform that job reliably.
Stage 1 — What Local AI Actually Is
Learn: what an LLM is, what running locally changes, what stays private, what model size means, and the practical difference between CPU, system RAM, GPU, and VRAM.
- NetworkChuck — host ALL your AI locally — a broad, practical introduction covering Ollama, a local web interface, documents, image generation, and even Obsidian integration.
- Techno Tim — self-hosted local AI stack — useful for seeing several local AI services as one system rather than isolated toys.
Milestone: Run one useful model locally and be able to explain where it is running and what hardware is doing the work.
Stage 2 — Give the AI a Useful Interface
Learn: model management, chat interfaces, system prompts, documents, basic retrieval, and why a friendly front end is not the same thing as the model underneath it.
This is where tools such as Ollama and Open WebUI start becoming a workspace rather than a command-line experiment.
Milestone: Use a local AI through a repeatable interface, switch models deliberately, and give it a document to work with.
Stage 3 — Automation Before Agents
Before giving an AI freedom to make decisions, learn what a normal automation looks like.
- NetworkChuck — You NEED to Use n8n RIGHT NOW!! — a beginner-friendly introduction to n8n workflows, nodes, data flow, and adding AI to an automation.
Learn: triggers, actions, nodes, APIs, webhooks, data passing, schedules, conditions, and error handling.
Milestone: Build one automation that is genuinely useful without requiring an AI at all.
Stage 4 — Tools, Skills, and Personal Knowledge
A chatbot answers. A useful assistant needs ways to do things and ways to work with information that belongs to you.
- Aillex — Teach Your Local AI Skills — a useful bridge from “local chatbot” toward reusable skills and answering from personal notes.
Learn: tools, reusable skills, file access, retrieval, notes, permissions, and the difference between remembering a conversation and maintaining durable knowledge.
Milestone: Give a local AI one controlled skill and let it answer a useful question from your own information.
Stage 5 — Build an Agent
Now we let the AI choose among tools and decide what step comes next.
Learn: tool selection, agent loops, structured output, state, retries, failure modes, limits, and why “autonomous” should not mean “unaccountable.”
Milestone: Build an agent that can complete a small multi-step task and report what it did.
Stage 6 — Give the Agent a Real Job
- NetworkChuck — n8n Now Runs My ENTIRE Homelab — “Terry,” an AI IT employee that monitors systems, investigates trouble, reports back, and uses human approval before making changes.
This is an important example because it shows the difference between an AI that can perform tricks and an AI that has a job description.
Learn: schedules, monitoring, escalation, reporting, approval gates, scoped permissions, and human-in-the-loop control.
Milestone: Give an AI one recurring responsibility that saves you real effort.
Stage 7 — Make It Dependable
This is the part that tends to disappear from flashy demos.
An AI employee needs more than intelligence. It needs a defined role, durable context, a task queue, logs, permissions, failure handling, status reporting, somewhere to put unfinished work, and a clear rule for when to stop and ask a human.
Milestone: The system can run for a while without you babysitting it, and when it fails, you can tell what happened.
The Other Learning Paths
The first path crosses into several subjects that deserve their own tracks. These are the ones I’m assembling next.
n8n & Automation
From the first trigger and action through APIs, webhooks, databases, error handling, AI nodes, agents, approvals, and recurring unattended work.
Self-Hosting & Homelabs
Linux, Docker, networking, storage, reverse proxies, services, monitoring, backups, security, automation, local AI, and eventually AI-assisted administration.
ComfyUI & Local Generative Media
From understanding the graph to image generation, editing, upscaling, reusable workflows, video, API control, and eventually having another system operate ComfyUI without manually clicking through every job.
Personal AI, Notes & Obsidian
Vault structure, linking, metadata, templates, search, automation, local AI retrieval, maintenance, filing notes automatically, and eventually a personal assistant that helps keep the knowledge system useful instead of turning it into another digital junk drawer.
AI Employees
Chatbot → assistant → tools → memory → recurring responsibility → permissions → reporting → approval → escalation → multiple cooperating workers.
Hardware for Local AI
How CPU, RAM, VRAM, storage, GPUs, used workstations, small PCs, accelerators, and networked machines actually affect what you can run — with a strong bias toward understanding what is good enough before buying something new.
People We’re Learning From
This list will change. Inclusion does not mean we agree with everything somebody says, endorse every product they sell, or think every sponsored recommendation is the right answer. It means they have taught something useful enough that we want to keep watching.
- Professor Glitch — approachable AI explanations and “AI employee” framing.
- Liz the Developer — agents, AI architecture, education, privacy, cybersecurity, and off-grid technology.
- Matt Diamante / HeyTony — SEO, AI search visibility, and getting useful work in front of people.
- NetworkChuck — networking, n8n, local AI, homelabs, and practical AI employees.
- Techno Tim — self-hosting, Docker, homelabs, and local AI systems.
- Jeff Geerling — hardware testing, Linux, homelabs, and a welcome willingness to say when an idea is silly.
- Aillex / DIY AI — local assistants, skills, memory, voice, tools, and personal knowledge.
- Nate Herk — n8n, agents, RAG, memory, human-in-the-loop systems, and automation architecture.
- Benjamin S. Powell — self-hosting, local AI, open source, and replacing unnecessary subscriptions with systems you control.
- Yashica Jain — practical self-hosted n8n and AI-agent builds.
- SimonScrapes — useful n8n workflows and real-world automation examples.
We also need more specialists. In particular, I want strong teachers for Obsidian and personal knowledge management, ComfyUI fundamentals, Linux fundamentals, networking, security, and the less glamorous reliability work that turns a demo into a system you can trust.
Dan’s Milestones
I’ll use this section as the public checkpoint. It is deliberately simple.
- ✓ Local Ollama/Open WebUI environment exists.
- ✓ Local speech and automation tools have been installed and used.
- ✓ n8n is in active use for real workflows.
- ✓ A local ComfyUI environment has been brought up.
- → Current: turn the pieces into dependable daily workflows instead of isolated experiments.
- ○ Give one local AI a real recurring job.
- ○ Put an AI to work maintaining and retrieving from the personal knowledge system.
- ○ Finish the ComfyUI operator path so image jobs can be handed off cleanly.
- ○ Document what worked, what failed, and what we would do differently next time.
Some milestones will take an afternoon. Some will probably turn into small disasters involving Docker logs at midnight. Both count as learning.
Follow Along
You do not have to follow the same hardware, use every tool, or finish every lesson.
If you are starting from zero, start at the top. If you already know Docker or n8n, skip forward. If one of the linked teachers does not click for you, find another explanation. The point is understanding and building, not completing a playlist.
I’ll keep improving the order as Dan works through it. We’ll add better videos, useful articles, our own notes, diagrams, mistakes, small builds, and deeper background material as we find or create them.
And if Dan reaches the end of one of these paths and can honestly say, “I know why this works, I can build it again, and I know what to do when it breaks,” then I’ll call that one a success.
Living page. First assembled August 26, 2026. Expect it to change.