
The lecture starts with real work: you take one task you repeat every week, write the four roles behind it, put a real name against each one, and find the role nobody owns yet.
This course is built from five disciplines: prompt engineering, agent design, projects and skills, AI in daily work and code-level agents.
The map of the course
A simple dictionary for reading lectures from other fields as agent work
Three questions to ask after every lecture
A short self-diagnostic that shows which sections to watch first
Download the Agent Handover Map and fill in one line after each lecture.
Role, context, task, examples, constraints, format, validation
Four classic frameworks — RISEN, CRISPE, CREATE, RTF — and when each fits
Why role and context account for most of the answer quality
Few-shot examples, and the validation block that makes the model check itself
Chain-of-thought, and what it actually adds
Self-consistency: five answers, and picking the reliable one
Tree-of-thoughts for a decision with several criteria
ReAct, where the model chooses its own steps and tools
The shift from prompt engineering to context engineering
Projects: an assistant loaded with your own documents and rules
Custom instructions and system prompts — set once, works after
Retrieval explained without an API or a developer, and memory across sessions
The difference between the three, and what can be handed over end to end
Multi-step workflows where one output becomes the next input
The Model Context Protocol and tool use: reading mail, calendar and sheets
n8n as a visual no-code builder, and where a human has to stay in the loop
The difference between an AI system, a prompt and an agent
The components: model, triggers, memory, actions
The platforms available for building one
How an agent differs from a chatbot, in practice rather than in marketing
The products in this category and what they actually do
Screening, replying, drafting
The limitations and risks, including bias and missing context
Integrating with the systems you already run
Assistants built on a general model against dedicated products
Answering repeat questions, assigning tasks, guiding someone through a first week
Integrating with Notion, Trello and Slack
Building one on top of a general assistant
The products in this category
Individual paths, knowledge checks, generating material
The difference between an AI tutor and a learning platform
Choosing and testing one
The products available
Analysing one-to-ones, tracking goals, coaching prompts
Using them alongside objectives, reviews and development plans
Running a review with agent support
The products in this category
Chat support, collecting feedback, explaining policy
The assistant as a first line rather than a replacement
Deploying one into a messenger
The products in this category
Predicting departures and flagging strain early
Training on internal data, and the care that requires
Modelling a forecast
Choosing a platform
Agent architecture: goal, memory, actions, interface
Building one for a single real task
The final project: an agent that is actually yours
Chat, desktop and code environments compared, and which plan you need
Where Projects, Skills, plugins and MCP connectors sit
Installing the desktop app and enabling an official plugin
Connecting Drive, mail and chat, and building a shared knowledge base
Custom instructions and a knowledge base for one working area
Writing SKILL.md for four custom skills
Taking apart an official slash command and adapting it
One input, several finished outputs
Customising an official command to your own process
Skills that generate packs, plans and checklists
Self-service through a knowledge base
Provisioning that runs through connectors rather than by hand
Skills for self-assessment and translating rough notes into structure
Preparation skills that compress a day into an hour
A knowledge base of frameworks the model applies consistently
Where the model checks quality rather than writing for you
Gap analysis across a team
Generating a personal path for a quarter
Building a micro-course with text, examples and a test
Keeping generated content consistent with your own voice
Adapting an official analysis command to your own framework
A skill that flags outliers in a dataset
Document generation with a signature route through a connector
A calculator skill using your own formulas
Customising a lookup command against a full knowledge base
A triage skill that classifies and routes a case
A drafting skill, and a helpdesk skill
Letting people query it directly from chat, and handling only what is left
Building the final analytics project
Packing every skill from the course into a single plugin
The manifest file and folder structure
Publishing through a private marketplace or a repository, and the install guide
Mapping your own tasks into categories and finding the leverage
The cycle: augment, then automate, then architect
The stack: chat, projects, skills, desktop, connectors
Your first project as persistent context, and the data that must never go in
The points in a process where you can actually intervene
Generating a specification from a business need
Screening at volume with a scorecard and explicit red flags
Building a structured interview kit, and the anonymisation step first
Preparing for a conversation in five minutes rather than an hour
The model as a quality checker rather than an author
Analysing distribution and flagging bias
Frameworks turned into prompts, and rehearsing a difficult conversation
This course contains the use of artificial intelligence.
You have been using AI for a year. It answers well. It has never once done anything while you were away from the keyboard.
Where the gap is
Between writing a good prompt and having something that runs on its own there are four steps, and almost everyone stops at the first. You get a useful answer, paste it somewhere, and do the same thing again next week. The vocabulary does not help: agent, workflow, MCP, skill, plugin and orchestration all get used interchangeably by people selling things, so it is genuinely unclear what you are supposed to build, in what order, or whether any of it needs a developer. It does not. But it does need the four steps in sequence, and the gap between them is where the time goes.
What this course covers
Thirty-three lessons through all four. The prompt as a construction first: seven blocks including the validation block most people skip, four classic frameworks, chain-of-thought and self-consistency, tree-of-thoughts for multi-criteria decisions, ReAct where the model chooses its own steps, then the shift to context engineering — projects, custom instructions, retrieval without a developer, and memory across sessions. Then what agents currently do: the components of one, the platforms, real products across six categories with their limitations stated, and building one from scratch. Then the platform layer in depth: where projects, skills, plugins and connectors sit, writing SKILL file, adapting official commands, and packing everything you built into a single distributable plugin with a manifest. Then production: auditing your own week to find the leverage, the augment-automate-architect cycle, data boundaries, building a skill live, connector security, scheduled tasks, cross-application workflows, Computer Use, and proving the time saved. Finally code-level agents: browser work, working across your applications, report agents, unattended automations with checks and rollbacks, and orchestrating five agents with context handoff and an audit log.
A note on the examples
The worked examples come from a people-function context — screening a stack of CVs, building an onboarding pack, assembling a weekly report. That is deliberate: it is a domain with enough repetitive document work to demonstrate a full cycle from prompt to plugin. Nothing about the techniques is specific to it. Seven-block prompts, tree-of-thoughts, MCP, SKILL file, n8n, scheduled tasks and multi-agent handoff behave identically whatever the task is. Also worth knowing: this course names specific products and versions, and some of those will look different in a year. The principles underneath — prompt architecture, the prompt-workflow-agent distinction, human in the loop, data boundaries — will not.
Who is teaching this
I am Mike. I built the people system at Preply as it became a unicorn, and I have worked at Wargaming, iDeals and Alfa-Bank. More than 1.6 million students have enrolled in my courses across 185 countries, and over 150,000 specialists have gone through my programmes. I hold PHRi and SHRM-CP certifications and represent HRCI in more than ten countries.
What is included
Lifetime access to all 33 lessons
Active instructor support in the Q&A section
A Udemy Certificate of Completion
Working material: the seven-block prompt, four prompt frameworks, SKILL file templates, connector safety checklist, scheduled automation patterns, the multi-agent handoff model, a 90-day roadmap
Everything built without writing code
Where to start
Name one thing you do every week that produces a document from other documents. That is the task this course automates, and by the end it should be running on a schedule without you. Enrol now and start today.