Field-guide course · Advanced
Building and automating
Vibe coding, coding agents, the API layer, no-code pipelines, and models that run on your own machine.
6 lessons · For: You want AI that works without you in the room — apps, coding agents, pipelines, and private models — whether or not you call yourself technical. · Product details last reviewed July 2026
Everything to this point happens with you in the chair. This course is about the layer beyond: software you create by describing it, coding agents that implement real changes in real codebases, pipelines that run scheduled and unattended, and open models that run entirely on hardware you own.
The through-line is the same discipline the study guides teach at E4: autonomy is granted per task, verified by design, and revoked the moment the evidence says so. Builders do not get to skip the checking competency — they get to industrialize it.
- Lesson 1
From assistant to agent
An agent, stripped of hype, is a model given a goal, tools, and permission to loop: try, observe, adjust, repeat — until done. That loop is what separates "draft me an email" from "watch this inbox and handle the routine ones." It is also exactly where the risk moves: an assistant's mistake costs you a bad draft; an unsupervised agent's mistake compounds silently until something customer-visible breaks.
So the first builder's skill is not technical — it is writing the autonomy spec. For any workflow you want to hand off: what may the agent do alone, what requires your sign-off, and how would you detect a silent failure within a day? The "Putting it together" guide's question — where does human review sit, and why there? — stops being an exam scenario here and becomes your architecture.
Try it this week
Choose one workflow you would love to hand off. Write its autonomy spec: allowed actions, sign-off gates, and the detection mechanism for silent failure. If you cannot write the third section, the workflow is not ready for an agent.
- Lesson 2
Software you describe: vibe coding
A wave of tools now turns plain-language descriptions into working, deployed applications: Replit's agent builds and hosts full apps from a conversation; Lovable and Bolt.new specialize in getting a product idea live in an afternoon; Vercel's v0 generates polished interfaces from a prompt. For internal tools, prototypes, and personal utilities, these are astonishing — the form-to-spreadsheet tool your team needed for years now costs one focused hour.
The honest boundary: a prototype is not a product. The moment real users, real customer data, or real money flow through what you built, the unglamorous engineering — security, backups, access control, maintenance — becomes real, whether or not you can see it. The professional pattern is to vibe-code the proof, learn from it, and involve engineering before it quietly becomes infrastructure. Naming that boundary out loud is what separates the builder from the liability.
In the toolbox
Replit
Replit · Free tier; Core ~$25/mo
Describe an app; the agent builds, runs, and hosts it in one place. The strongest all-in-one for non-engineers shipping real utilities.
Lovable
Lovable · Free tier; from ~$25/mo
Prompt-to-product with database and auth wiring included. Built for getting a working web app live fast.
v0
Vercel · Free tier; paid from ~$20/mo
Generates high-quality web interfaces from descriptions. The designer-taste option, especially for front-ends handed to real developers.
Bolt.new
StackBlitz · Free tier; paid from ~$20/mo
Full-stack apps built and edited in the browser from prompts. Fast iteration loop, good for prototypes that need to feel real.
Try it this week
Build one internal utility this week — a calculator, a form-to-sheet tool, a small dashboard — and give it to exactly one colleague. Run it for two weeks and write down where it strains; that list is the prototype-to-product boundary, observed firsthand.
- Lesson 3
Coding agents for real codebases
For working engineers, coding agents crossed from autocomplete to colleague. Claude Code runs in the terminal and works a codebase the way a developer does — reading files, making multi-file changes, running tests, iterating on failures. OpenAI's Codex works the same territory with deep ChatGPT integration; Cursor is the agent-native editor; GitHub Copilot, the incumbent, now spans autocomplete to autonomous pull requests. Google's Gemini CLI covers the terminal for the Gemini ecosystem.
The working method matters more than the tool choice. The engineers getting multiples out of these agents write the brief first (the change, the constraints, what done looks like — "Asking well," E4), let the agent implement, and then review the diff like a senior engineer reviewing a fast, talented, occasionally overconfident junior: every line, before merge. Tests are the agent-era non-negotiable — they are the mechanical half of "Checking the work," and agents both write and run them. Merging unreviewed agent code is how teams learn this lesson expensively.
In the toolbox
Claude Code
Anthropic · Included with Pro/Max plans or API billing
The agentic coding benchmark: terminal-native, multi-file, test-running. Strongest on sustained, complex changes to real codebases.
Cursor
Anysphere · Free tier; Pro ~$20/mo
The AI-native editor — agent capabilities woven into the IDE, with your choice of frontier models underneath.
GitHub Copilot
Microsoft / GitHub · Free tier; Pro ~$10/mo
The incumbent, from inline completion to an autonomous coding agent that opens pull requests. Often the enterprise-approved path.
Codex
OpenAI · Included with ChatGPT paid plans
OpenAI's coding agent, in the terminal and the cloud — delegate a task, get back a reviewed-ready diff.
Try it this week
Take one small real bug or feature. Write the brief before touching the tool: intended change, constraints, definition of done. Let an agent implement it, review every line of the diff, and require a passing test. Compare the elapsed time — including your review — with doing it by hand.
- Lesson 4
The API layer
Subscriptions buy conversations; APIs buy the model itself, callable from code, priced per token. That changes the economics completely. Frontier models cost real money per million tokens, but each provider's small models — the Haiku, mini, and Flash tiers — cost radically less, often by a factor of ten or more. At volume, the "Choosing the right model" guide's routing judgment becomes literal architecture: the cheap model handles the bulk, the expensive model handles the exceptions, and the spread is your margin.
When does the API beat the subscription? Volume (the same operation on ten thousand items), integration (AI inside your product or internal systems), and control (pinned models, structured outputs, audit logs). For interactive work, subscriptions stay the better deal — a heavy chat month costs a fraction of the same tokens metered. Most builders end up with both, and aggregators like OpenRouter let you address every major model through one account while you find your fit.
In the toolbox
Anthropic API
Anthropic · Pay per token
Claude's model family programmatically — Opus for the hard slice, Haiku for volume. The Workbench makes first calls approachable.
OpenAI API
OpenAI · Pay per token
The GPT family plus image, voice, and embedding models. The broadest surface and the largest ecosystem of examples.
Gemini API / AI Studio
Google · Generous free tier; pay per token
AI Studio is the gentlest on-ramp in the industry — experiment free in the browser, export working code when it does what you want.
OpenRouter
OpenRouter · Pay per token, small markup
One API key for every major model, with live price and performance comparison. The pragmatic way to stay provider-agnostic.
Try it this week
Price your highest-volume text task at small-model API rates: tokens per item × items per month × price. Put that number next to the hours it currently consumes. That single multiplication is the business case, and it usually surprises in one direction or the other.
- Lesson 5
Pipelines with judgment built in
Between chat and custom code sits the automation layer: Zapier and Make connect thousands of apps with AI steps dropped in anywhere — ticket arrives, model classifies and drafts, human approves, reply sends. n8n offers the same pattern self-hosted, for when data must stay inside your walls. This is where "Putting it together" stops being a diagram and starts running at 3 a.m.
Design rules from production scar tissue: constrain the model step's output to a strict format so downstream steps cannot receive an essay when they expect a category; log every input and output, because you cannot debug what you did not record; sample the outputs on a schedule — ten a week, read by a human, forever; and gate anything irreversible or customer-visible behind an approval. That is "Checking the work" E4 — verification designed into the workflow — implemented in a no-code editor.
In the toolbox
Zapier
Zapier · Free tier; paid from ~$20/mo
The broadest app-to-app connector, with AI steps and agents built in. The fastest path from "this is manual" to "this runs itself."
Make
Make · Free tier; paid from ~$9/mo
Visual, branching workflow builder — more control than Zapier for complex flows, at a steeper learning curve.
n8n
n8n · Free self-hosted; cloud from ~$24/mo
Open-source automation you can run on your own infrastructure — the answer when the data in the pipeline cannot leave.
Try it this week
Automate one real workflow with an LLM step in it. Before switching it on, write the schema its output must match, where the human gate sits, and your weekly sampling ritual. Run it for a month and keep score: errors caught by the gate versus errors caught by the sample.
- Lesson 6
Local and open-weight models
The open-weight world — Meta's Llama, Mistral, Alibaba's Qwen, DeepSeek, OpenAI's gpt-oss — runs on hardware you own. Ollama makes it a one-line install; LM Studio wraps the same idea in a friendly desktop app. A capable model answering on your laptop, no internet, no account, no data leaving the machine, is a genuinely different proposition from everything else in this library.
The honest tradeoff: models that fit on a laptop trail the frontier, noticeably, on hard reasoning. The fit is tasks where privacy or volume outweighs peak intelligence — summarizing documents you would never paste into a cloud tool, classification at scale, drafting where good-enough is enough, and any regulated context where "the data never left" is the requirement. Treat local models as a tier in your portfolio with a specific job, not a cause. The same model-task fit judgment applies; the weights just live in your house.
In the toolbox
Ollama
Ollama · Free, open source
The standard for running open models locally — one command to download and chat with Llama, Qwen, Mistral, and dozens more.
LM Studio
LM Studio · Free for personal use
A polished desktop app for discovering, downloading, and chatting with local models. The gentlest on-ramp to the open-weight world.
Open model families
Meta (Llama) · Mistral · Alibaba (Qwen) · DeepSeek · OpenAI (gpt-oss) · Free weights, permissive licenses vary
The models themselves. Small versions run on laptops; larger ones need serious hardware or a rented GPU — capability scales with both.
Try it this week
Install Ollama or LM Studio, pull a small model, and run one genuinely private task — notes you would never upload, a personal document. Then run the same task on your usual assistant and write three sentences on the quality gap and whether the privacy was worth it. That is a portfolio decision, made with evidence.
Where next
You can now build, automate, and run models on your own terms. One course remains: Choosing your stack — making the whole portfolio deliberate, from subscriptions to data controls to the discipline of staying current without churning.
The products above change; the judgment the exam scores does not. The study guides teach that durable layer, and the free check scores you on it in about fifteen minutes.