Speak logic, get software.
You don't need to memorise syntax to build things any more. With AI you describe the logic in plain English and the machine writes the code — and helps you debug it. But the real skill isn't typing prompts; it's validating, securing and orchestrating what comes back. This class takes you from typist to architect.
Describe, not type
Turn plain-language logic into working components.
Debug with AI
Use the model as a tireless pair-programmer and reviewer.
Confident wrong code
AI writes plausible bugs and imaginary packages. Verify everything.
True or false?
"If AI-written code compiles and the demo works, it's safe to ship." True or false?
The dev toolkit
You don't need an engineering degree to start — you need to know the shapes of the tools. Most people run a hybrid: a fast in-editor assistant for everyday edits plus an autonomous agent for bigger jobs.
Cursor
An AI-native code editor — inline suggestions, codebase-aware chat and an agent mode. A common daily driver.
Claude Code
A terminal agent for multi-step jobs; extensible via MCP to reach your tools and data.
GitHub Copilot
Solid completion and chat across many editors; best value entry point, wired into GitHub.
A chat model
Claude/GPT/Gemini as a pair-programmer for reasoning, explaining and planning before you write.
Context engineering & MCP
An AI is only as good as what it can see. The biggest quality lever isn't a clever prompt — it's getting the right code, docs and data into the model's window.
Feed what's relevant
Don't dump the whole repo. Give the relevant files and interfaces; summarise the rest.
Model Context Protocol
An open standard connecting the model to external tools — APIs, databases, live docs — turning a chatbot into an agent wired into real systems.
Rules files
Give the tool a standing brief — conventions, do/don't — so every session starts aligned.
Retrieval & indexing
Use the tool's index so it pulls the right symbols on demand instead of guessing.
English → code
Click a plain-English request and watch the AI "type" working code. Notice how a clear, specific request maps cleanly to structured code — vague intent would produce vague output.
Agentic coding & TDD
Agentic workflows
Agents can plan, edit many files, run commands and check their own work. The clearer your spec and acceptance criteria, the better they perform — vague intent produces confident nonsense.
Tests first
Ask for the tests before the code — edge cases and integration paths. The tests become the spec the AI must satisfy, and your proof it worked.
Natural-language logic
Describe behaviour in plain text to scaffold components fast — then review and harden like any code.
AI as detective
Paste the stack trace and repro steps; let the model form hypotheses and propose minimal fixes you confirm.
Agentic coding shifts your effort from writing to specifying and supervising. Your value is knowing whether the output is right, safe and well-built — and owning that call.
Refactoring a legacy script
Priya volunteers for a mutual-aid group and inherited a tangled donation-tracking script no one understands.
"Just fix it"
She asked an agent to "make this better." It rewrote everything at once, broke the CSV export, and she couldn't tell what changed.
Spec + tests + small steps
She had the AI write tests for the current behaviour first, then refactor in small steps behind those tests, reviewing each diff.
The win wasn't the AI's cleverness — it was Priya's process: tests as a safety net, incremental change, and a human reviewing every diff. That's engineering; the AI just typed faster.
Pick your setup
Tools shift fast. Find which AI coding setup fits a beginner and note one safety practice it encourages.
What to look up
"Cursor vs Copilot vs Claude Code" · "AI coding for beginners" · "MCP servers list".
Write an agentic brief
Turn a vague request — "build me a sign-up form" — into a strong brief: the stack, the requirements, tests first, and acceptance criteria, with a dependency guardrail.
Success rubric — tap to expand
Needs work: repeats the vague request.
Getting there: adds a stack but no tests or acceptance criteria.
Solid: stack + requirements + tests, but no dependency guardrail.
Excellent: stack, security requirements, a TDD order, a "flag new dependencies" rule, and clear acceptance criteria.
Quiz — 5 questions
Spot the fake package
AI sometimes invents plausible-but-fake dependencies — and attackers register those names with malware ("slopsquatting"). One of these install lines points to a package that doesn't really exist. Click the one you'd never install without checking.
Trusting confident code
Fluent, well-formatted code can still be wrong. Fix: run it and read it — confidence is not correctness.
Auto-installing deps
Running suggested installs blind. Fix: verify every package is real, maintained and widely used.
Big-bang rewrites
Letting an agent rewrite everything at once. Fix: refactor incrementally behind tests.
Skipping review
Merging unread AI diffs. Fix: a human reviews and owns the merge — always.
Typist to architect
If anyone can now generate code, what becomes more valuable — and what becomes less? Where would you refuse to ship AI code without a human who deeply understands it?
You can direct code now — and, more importantly, judge it. Next, we tackle the hardest medium: generative video.