Don't just use AI. Learn to build with it.
From zero to building & selling AI solutions. Learn how AI really works, build real projects with modern AI tools, put them live, and finish with a portfolio. No coding experience needed to start.
What you'll learn
You learn by building.
No months of unnecessary theory. Every weekend you work with modern AI tools and build something real, step by step.
- AI, Machine Learning & LLM fundamentals
- Prompt engineering and writing specs
- AI-powered websites & chatbots
- Vibe coding with AI coding agents
- Python + AI APIs
- RAG-based AI applications
- AI automation with n8n
- Deploying live AI projects
- Production-grade RAG systems
- AI agents & tool calling
- MCP, memory & multi-agent systems
- AI testing, evaluation & safety
- FastAPI, Docker & production deployment
Course outline
Every weekend, in order.
2 parts • 16 weekends • 32 recorded videos • 16 live classes
Part 1AI Foundations & Coding Agents
Understand how LLMs actually work, direct a coding agent properly, write a real specification, and ship three projects. Complete on its own.
8 weekends • 2 months
- What AI, machine learning and LLMs really are, in plain language, no maths
- Tokens, context window and knowledge cut-off, and why each one matters to you
- Temperature and sampling: controlling how random the output is
- Cache hits and cost: how to spend less for the same result
- When to trust an LLM and when not to
- Choosing the right model for the job
You build: A custom AI assistant for a real business, plus a cost comparison across three models
Homework: Find three tasks where the AI gives you a wrong answer. Write down why you think it failed.
- Prompting properly: role, context, examples, output format
- Writing a specification: the problem, the user, and what success looks like
- Why a clear spec produces a better result than a clever prompt
- No-code AI builders (Lovable / Replit): turning a spec into a working website
- Publishing and sharing a live link
You build: Your first live website with a working chatbot, from a written spec, not a guess
Homework: Write a one-page spec for your own idea, then build it.
- Setting up a coding agent (Cursor / Claude Code)
- The professional workflow: Plan → Execute → Deploy & Monitor, and why it loops back
- Breaking a task into verifiable steps
- Choosing autonomy level: back-and-forth, delegating a chunk, or setting a goal
- Giving the agent the right context: decisions, feedback, changed assumptions
- Running it safely: permissions, and avoiding data loss
You build: Your first real working script, planned properly, not vibe-coded blindly
Homework: Build one small tool. Submit your plan document alongside the code.
- How an agent actually works: a harness wrapped around an LLM
- Spotting failure modes: over-engineering, skipped verification, stopping early, risky file changes
- Reviewing agent output: testing user flows, asking for screenshots as evidence
- Standing context files (CLAUDE.md / AGENTS.md) so the agent knows your codebase
- Cleaning up agent-generated mess before it becomes permanent
- Why "run agents for hours" is social media hype, not practice
You build: A reviewed, cleaned-up project with its own context file, the way professionals work
Homework: Take last week's tool and review it properly. List everything the agent got wrong.
- What an API is, explained simply
- API keys, keeping them safe, and controlling spending
- Connecting your code to an AI model
- Structured output: forcing the AI to return clean, usable data every time
- Tool calling: giving the model a calculator, a search, a database
You build: A working AI tool that runs on your machine and returns reliable, structured results
Homework: Add one new tool to your assistant and prove it works.
- Why the model does not know your company's information
- Embeddings and AI search, explained without maths
- Turning PDFs, price lists, policies and FAQs into something an AI can use
- Deciding what goes in the prompt versus what the AI should fetch
- Stopping made-up answers
Project A: A chatbot that answers questions from a real business's documents
Homework: Rebuild it with a real PDF from a real local business.
- Workflow automation with n8n: trigger → AI thinks → action happens
- Connecting AI to Google Sheets, Gmail and WhatsApp
- Fallbacks: what happens when a step fails, so the whole thing does not crash
- Deploying your project (Railway / Vercel / Render)
- Environment variables, spending limits, and testing before a client sees it
Project B: A live automation with a real URL that anyone can open
Homework: Deploy Project A and Project B. Share both links.
- Product sense: what a user actually needs, not what sounds impressive
- Choosing one niche: clinics, property, restaurants or e-commerce
- The method that works: build the demo first, pitch second
- Recording a 2-minute screen video that sells for you
- Pricing, proposals, LinkedIn profile and portfolio setup
- High-agency ownership: spotting problems and proposing solutions
- Presentation of all student projects
Project C: A working demo built for one real local business, plus a live portfolio
Homework: Send your demo to five real businesses.
After Part 1 you will have: 3 completed projects • 2 live URLs • a portfolio • a client-ready demo video
Part 2AI Engineering & Production
For students who finished Part 1. Move from "it works on my laptop" to systems that are reliable, measured and production-ready.
8 weekends • 2 months
- Why fundamentals matter more, not less, now that agents write the code
- The trade-offs an agent silently makes: latency, availability, consistency, reliability, cost
- Frontend basics: components, caching, rendering
- Backend basics: API design, authentication, session and state management
- Asynchronous processing, data persistence and testing
You build: A proper front-end plus back-end version of your Part 1 project
- Access patterns: how the data will be used, how often, and by whom
- Choosing storage: relational tables, documents, key-value, graphs
- Transactions and concurrency: what breaks when two people act at once
- Keeping data clean, consistent and fresh
- Privacy, governance and compliance
- Why your AI is only as good as the data architecture behind it
You build: A real database behind your AI application, designed on purpose
- Chunking strategies, and why bad chunking quietly ruins your answers
- Choosing an embedding model
- Vector index vs knowledge graph vs semantic layer
- Hybrid search and reranking for much better retrieval
- Building a data pipeline that keeps everything fresh
- When RAG is the wrong answer and something simpler is better
You build: A properly indexed, refreshable knowledge base, not a tutorial demo
The single highest-value weekend of the course: the trait that most separates people who are great at building AI systems.
- Reading traces and outputs: what is actually happening inside your system
- Error analysis: finding out why it fails, not just that it failed
- Choosing your eval type: code checks, LLM-as-a-judge, human-in-the-loop
- Building your own test set from real failures
- Evaluating your evals: is your test itself correct?
- Running the loop continuously: evaluate, fix, evaluate, fix
You build: A full evaluation suite that proves your system works, the strongest single item in an AI portfolio
- Workflows (a defined sequence) vs an agent harness (the LLM decides the next step)
- Which steps to chain, which to run in parallel
- When to use plain code instead of an LLM call
- Tool calling and the agent loop, with limits that stop runaway cost
- Giving agents access through MCP, CLI and sandboxes
- Designing fallbacks for every step
You build: A working agent that completes a multi-step task and degrades gracefully when something fails
- Memory architecture: how an agent remembers across conversations
- Managing context in long sessions without overflowing
- Single agent vs multi-agent, and when multi-agent is just extra complexity
- Guardrails, adversarial inputs, prompt injection, preventing data exfiltration
- What is next: voice agents, computer-use agents, generative UI
You build: An agent with memory, guardrails, and a documented security review
- Observability: knowing what your system did with real users, and why
- Tracking performance and detecting drift over time
- Handling model failures and security incidents
- Testing strategy: unit and integration tests, regression testing, CI/CD
- Designing for failure: graceful degradation, minimising blast radius
- "Shift left" security: thinking about it at the start, not the end
- Optimising cost and latency: model choice, simplification, caching
You build: A monitored, tested, cost-controlled deployment with alerts that actually fire
- System decomposition: breaking a system into sensible parts
- Monolith vs microservices, and choosing a tech stack
- Architecture as a moving target: prototype, production and scale
- Shaping the build: prototype → MVP → shipping in small batches
- Business sense: market size, unit economics, why projects get funded or killed
- Explaining to non-technical people what is and is not feasible
- Final capstone presentation, CV and portfolio review
Capstone: One complete, deployed, evaluated AI system you can put at the top of your CV
After Part 2 you will have: Production-level grounding • an agent with guardrails • a real evaluation suite • a monitored deployment • a deployed capstone
Curriculum based on the AI Engineering Skills Map by Andrew Ng (DeepLearning.AI).
Stop being only an AI user. Start becoming an AI builder.
Part 1 starts Sunday, 27 September 2026. Live class every Sunday at 10:00 AM.
- No coding needed to start
- API keys included
- Every class recorded
No course can guarantee a job or income. Real skills, real projects and a strong portfolio give you something valuable to build your career on.