Vibe Engineering with AI Coding Agents
A hands-on course that takes you from “what even is vibe coding?” to shipping real apps with an AI agent — and understanding exactly what is happening under the hood while it does. Taught at SMIT by Muhammad Uzair Khan.
Your class-by-class map
Read straight through, or jump to any topic. Every page stands on its own and links to the next.
See the magic, then name it
Generate a 3D game from a sentence, then build the mental map: the Missing Manual, vibe coding vs. agentic engineering, the eight stages of AI adoption, and where the money goes.
What’s under the hood
Tokens, memory, reasoning, tools and loops — the four tricks that turn autocomplete into an agent. Then context engineering, agents.md, and how professional workflows have evolved.
Build for real
Install the tools, write a great agents.md, and drive Cursor in YOLO mode to build a working Kanban board — planning, generating, testing, and iterating with feedback.
Choose your model, then YOLO
Pick the right model, learn the five “be the boss” principles, set up OpenRouter, and vibe-code a portfolio site with an AI digital twin — then review it with a second model.
Meet Claude Code — and its rivals
Install Claude Code in VS Code, learn the CLI — /init, /context, running tests — then run free and cheap models through OpenCode, AMP, OpenRouter and local Ollama.
Commands, workflow & autonomy
The everyday commands and shortcut keys, how sessions, checkpoints and Git keep you safe, real
--dangerously-skip-permissions YOLO mode, and Ralph loops that build for hours.
MCP, Skills & Plugins
The big three that supercharge Claude Code — connect other people’s tools with MCP, add expertise with skills, bundle it all with plugins — and a clear rule for when to use which.
Jira, MCP & FeatureDev
Run the full development lifecycle: read work from Jira, drive Claude Code through Anthropic’s disciplined FeatureDev process, ship a reviewed GitHub PR — and debug like a pro.
Build Pre-Legal end to end
Write a project CLAUDE.md and a custom Cerebras skill, plan V1 as Jira tickets, and build a multi-user AI legal-document SaaS — FastAPI, Next.js and SQLite — ticket by ticket.
Tie the whole course together
Step back and consolidate weeks one and two — the eight stages, the control↔autonomy dial, how LLMs really work, the pro toolkit, and a master cheat-sheet before the finale.
Controlled chaos: go multi-agent
Custom slash commands, sub-agents (with a Codex cameo), event-driven hooks, and your own plugin + marketplace — all on the FiNALLY trading-app capstone.
See it work — then understand what you saw
Instant gratification first, theory second. You’ll feel the power before you dissect it.
Welcome & your first build →
Meet Cursor and generate a playable 3D shooter from a single prompt — no code written.
The Missing Manual →
Why this course exists, who it’s for, vibe coding vs. agentic engineering, and the three surfaces.
Eight stages & the cost talk →
Steve Yegge’s ladder from ChatGPT to agent orchestration — and an honest word about AI spend.
The one heavy-theory day — and worth every minute
Understand the mechanics and every later trick makes sense. Experts: feel free to skim.
How LLMs actually work →
Tokens, the illusion of memory, reasoning, tools and loops — and a precise definition of an agent.
Context engineering →
System prompts, the context window, compacting, and the all-important agents.md file.
Workflows & choosing a model →
From micromanagement to Ralph Loops and swarms — plus reading artificialanalysis.ai.
Less talking, more doing
Tour the tools, then build and iterate on a genuine app with an agent at your side.
Tools, setup & agents.md →
Cursor, Copilot, Codex, Antigravity — install Node, clone the repo, and read a real agents.md line by line.
Build the Kanban app →
Plan mode, YOLO mode, watching the agent loop, and sharpening it with targeted feedback.
Do it yourself →
Jump straight to the hands-on lab and build it with your own hands.
Choose your model — then really build
Break the rules on purpose with a real YOLO build, then come back and own every line.
Choosing your model →
Two decisions, not one: the tool vs. the model. Fast frontier vs. top frontier — and when it’s safe to YOLO.
Be the boss →
The five principles for successful vibe coding — spec, start simple, iterate, challenge, handle frustration.
Responsible YOLO →
Two honest counterpoints, the “own the code” mantra, and setting up an OpenRouter API key.
The YOLO build →
Ship a Next.js portfolio site with an AI digital twin — then tutorial it and review it with a second model.
Karpathy & the MVP →
The tweets that named vibe coding, the workflow shift, and a balanced mindset for building for real.
Claude Code — and how to run any model
Install the tool that started it all, master the CLI, then explore every free and cheap alternative.
The rise of Claude Code →
Its history from a 2024 side project to Opus 4.5 — plus pricing, and installing it inside VS Code.
CLI: init, context & testing →
/login, /init and /context — then let Claude run your whole test suite.
OpenCode & free models →
Run genuinely free models like GLM 4.7, and connect any provider you like.
AMP, OpenRouter & Ollama →
Ad-supported credits, Claude Code pointed at OpenRouter, and models running locally.
Own the command line — then let it run
The everyday commands, how to move safely through a project, and living dangerously with YOLO and Ralph loops.
Commands, shortcuts & config →
Discover commands, the three C’s (context/compact/clear), shortcut keys, the .claude folder and the @ trick.
Sessions, checkpoints & Git →
Three ways to move through a project — and a workflow that actually keeps you safe.
Rewind & YOLO mode →
Drive a real rewind, then run --dangerously-skip-permissions without regret.
Ralph Loops →
Wrap a loop around the agent so it keeps building — autonomous coding on autopilot.
MCP, Skills & Plugins — an inflection point
Connect other people’s tools, add expertise as simple files, bundle it all up — and know exactly when to use which.
The big three & tools →
The map of MCP, Skills and Plugins — built on the one idea underneath: tools.
MCP under the hood →
Hosts, clients and servers; local vs remote; and how to find a server you can trust.
Adding MCP servers →
Equip Claude Code with Context7 docs and live market data — then remove them.
Skills — a simpler way →
Markdown instructions with progressive disclosure — light, simple, shareable.
Skills marketplaces & Agent Browser →
Find skills, then watch Claude Code drive a real browser on your machine.
Plugins & your setup →
Bundle it all behind marketplaces — and the rule for MCP vs Skills vs Plugins.
From a Jira ticket to a merged PR
Wire Jira and GitHub into Claude Code, run the disciplined FeatureDev process end to end, and learn to debug like a pro.
Workflow & Jira setup →
No more slides — set up the two-day project, a free Jira board, and your first ticket.
Connecting Jira (MCP) →
Add the Atlassian MCP server, log in with OAuth, and tame the re-auth gremlin.
GitHub repo, token & MCP →
A least-privilege token and the GitHub MCP server — then an issue → PR → merge loop.
FeatureDev & the 7 stages →
Anthropic’s plugin that marches Claude Code through a disciplined, staged build.
Autonomy: Jira to PR →
Two tickets, end to end — curate a dataset, then build a Next.js NDA app with 76 tests.
Debugging strategies →
A real playbook: snapshot, the copy-paste loop, the debug.md method, and the pro tips.
Ship Pre-Legal, ticket by ticket
The culmination of week two: a multi-user AI legal-document platform, built end to end with your own custom skill.
The SaaS blueprint →
How skills really work, and the two CLAUDE.md files — including a lean global one.
CLAUDE.md & a custom skill →
Write a strong project CLAUDE.md and author your own fast Cerebras skill.
Planning V1 tickets →
Plan the product as a clean backlog of tickets, PL-4 to PL-7, in the stakeholder’s voice.
Building features →
Ship the foundation and the AI chat — with an architecture review and a real design debate.
Testing with Cerebras →
Confirm the skill was used, test like a user, and expand to every document type.
Multi-user, polish & victory →
Add sign-in, the freemium surprise, an honest critique — and declare week-two victory.
Consolidate before the finale
No new tools — one clear mental map. The whole of weeks one and two, distilled and connected.
The journey so far →
The eight stages, the control↔autonomy dial, and the two mindsets that hold it all together.
Foundations recap →
How LLMs really work, the four tricks that make an agent, context engineering and CLAUDE.md.
The pro toolkit →
The Claude Code CLI, models & providers, the safety net, and the big three: MCP, skills, plugins.
Workflow & cheat-sheet →
The Jira→FeatureDev→PR loop, what we shipped, and a one-page master cheat-sheet + self-check.
Sub-agents, hooks, swarms & controlled chaos
Week three opens: go multi-agent on a real capstone project, automate with hooks, and ship your own plugin.
Controlled chaos →
The mindset for the finale: balancing chaos and control, and the map of pro techniques.
The FiNALLY project →
Set up the multi-agent trading capstone — plan.md, boundaries and a simple architecture.
Custom slash commands →
Make your own /commands with $ARGUMENTS — and how skills give you one for free.
Agents & sub-agents →
Delegate to sub-agents with isolated context — even run Codex as your reviewer.
Hooks & events →
Fire actions automatically on events — build a stop-hook that reviews your work.
Plugins & marketplaces →
Bundle commands, skills, agents & hooks into a plugin and share it via a marketplace.
Make YOLO safe: sandboxes & remote execution
Ring-fence Claude so it can run wild without risk — on your laptop, in Anthropic’s managed cloud, or on a rented sandbox box.
Sandboxing & why it’s juicy →
What sandboxing really means, beating approval fatigue, and the map of the three approaches.
The native sandbox →
A fast, OS-level box built into Claude Code via /sandbox — modes, a demo, the WSL catch.
Claude Code on the Web →
A managed cloud sandbox and the five ways to run remotely — including a GitHub issue tagged @claude.
Sprites.dev sandboxes →
Rent a fast, isolated cloud box and run any agent in safe full-YOLO.
Recap & cheat-sheet →
The blue/purple/yellow map, a decision table, every command, and a self-check.
Large codebases, and the frontier of agents
The rules of the road for big team repos — then a tour of the frontier: the Agent SDK, Cowork and OpenClaw.
Recap & the zero-shot demo →
Consolidate the toolkit, then a live market-data demo that ran perfectly first time.
Large team codebases →
Seven rules for using coding agents on a big, multi-person repo without the wheels coming off.
The Agent SDK →
Drive Claude Code from your own code — a tiny Python script builds a working game.
Claude Cowork →
Agentic AI for non-coders: turn a folder of receipts into a formatted expenses spreadsheet.
OpenClaw sidekick →
A personal AI on your computer, driven from Telegram — powerful, hyped, and genuinely risky.
Roll up your sleeves
Two guided, self-paced labs. No grade, no pressure — just reps. Both work on free tiers.
One prompt, one app →
Generate a working app from a single sentence, improve it with follow-ups, then run the same prompt twice and watch it diverge. Your first taste of non-determinism.
Write agents.md, build in YOLO →
Author a real agents.md, clone the starter, and drive Cursor through plan → build → test → feedback to ship a drag-and-drop Kanban board.
✓ By the end of these classes you can…
- Generate a working app from a single prompt and improve it through conversation.
- Explain what an LLM is doing — tokens, memory, reasoning, tools, loops — and define an “agent” precisely.
- Write a tight, effective
agents.mdand understand how the context window shapes results. - Choose deliberately between tools and models, and know when it’s safe to YOLO.
- Drive an AI-native IDE (Cursor) in plan and YOLO modes to build, review, and debug real applications.
- Ship a portfolio site with an AI digital twin via OpenRouter — and own every line of it.
- Install and drive Claude Code from the terminal — and run free or cheap models through OpenCode, AMP, OpenRouter and Ollama.
- Master the everyday commands, shortcut keys and the safety net of sessions, checkpoints and Git — and run YOLO and Ralph loops responsibly.
- Supercharge Claude Code with MCP servers, skills and plugins — and know exactly which to reach for.
- Consolidate the whole course into one mental model — the eight stages and the control↔autonomy dial.
- Go multi-agent with Claude Code: custom commands, sub-agents, hooks, and your own plugin + marketplace.
Everything here works for total beginners and seasoned engineers alike. If a section is obvious to you, put it on 2× and skim — there’s something for everyone. Use the ☾ button up top to switch between light and dark, and the left sidebar to jump around.