Vibe Coding Essentials: Build Apps with AI
Beginner specialization on shipping real apps with Copilot, Cursor, Claude Code, and ChatGPT.
Coding agents write fast. The new bottleneck is whether anyone's paying attention.
A running collection of writing, tutorials, and courses on agentic engineering: using AI coding agents to ship software. The agent does the typing. You stay the engineer, writing the briefs, reading the diff, making the calls.
Workflow, advice, and writing that isn't tied to one specific tool.
Beginner specialization on shipping real apps with Copilot, Cursor, Claude Code, and ChatGPT.
Multi-course path on orchestrating coding agents to build, ship, and maintain real applications.
Sabrina Goldfarb teaches prompting strategies that transfer across Cursor, Copilot, and Claude.
Multi-tool specialization on prompt engineering, AI-assisted editing, full-stack agents, and shipping production code.
Ray Villalobos on driver/navigator pair programming with agents — agentic modes, system prompts, responsible practice.
AI-assisted dev with Codex CLI, spec-driven development, TDD, and context engineering — the practice past basic vibe coding.
Simon Willison on tests, scaffolding, and review habits that make coding agents actually ship.
Plan-implement-verify loop: write a constitution and specs your coding agent can ship from.
Lovable's first pro vibe coder on PRD-driven workflows, parallel prototypes, and the 4×4 debugging method.
Use coding agents as throwaway research workers to answer library and POC questions fast.
How to actually fire off multiple agents at once across worktrees without losing the plot.
The Ralph loop: a bash while-loop with fresh context per iteration that ships specs into code overnight.
Walkthrough of Spec Kit: turn markdown specs into agent-built features across Copilot, Claude, Gemini.
Practitioner playbook: hand the agent a job, pick boring stacks, keep tools fast and observable.
Yegge's map of the six waves from autocomplete to agent fleets and how to ride them as a working dev.
The Feb 2025 post that named the practice: give in to the LLM, forget the code.
Quickstarts, walkthroughs, and tips for each tool.
Cross-tool workflow course: inline edits, markdown plans, background agents, MCP servers.
Hour-long livestream wiring three coding agents into one shipping workflow.
Long-form practitioner walkthroughs that build real apps end-to-end by voice in Cursor.
Long-running playlist on planning, building, and agent orchestration patterns for shipping with coding agents.
Official intro covering install paths, supported IDEs, and where Claude Code fits in your workflow.
Anthropic's distilled patterns for context, memory, subagents, and long-running tasks.
Free short course with Elie Schoppik covering subagents, GitHub integration, MCP, and Figma-to-app builds.
Walkthrough of Claude Code's loop, tool calls, and what makes its agentic design different from autocomplete.
Orchestrate Claude Code like a tech lead: Best-of-N, CLAUDE.md, parallel git branch workflows.
Install Codex CLI, sign in with ChatGPT or API key, and run your first repo-aware task.
Full CLI surface: approval modes, /model switching, screenshot input, and sandbox controls.
From install to first useful edit: codebase Q&A, inline edits, and reviewing agent output.
Bite-size lessons on AI foundations, coding with agents, and reviewing & testing agent diffs.
End-to-end beginner walkthrough of Cursor 2.0's Composer, Agent mode, and parallel-agents window.
Ten concrete prompts spanning refactors, tests, and migrations that show Cursor's strengths.
Download Windsurf and learn how Cascade plans multi-step edits across your project.
Beginner tour of Cascade, Supercomplete, and how Windsurf differs from Cursor on multi-file edits.
Spin up your first Lovable project, connect Supabase, and ship a working full-stack app.
Curated video library walking through auth, databases, payments, and deploys in Lovable.
End-to-end mobile build with Lovable, including App Store submission and review prep.
How Bolt's in-browser WebContainers run your prompted project end to end, no setup required.
Prompt-to-deployment walkthrough of a small full-stack app inside Bolt's browser environment.
Build a workout tracker with Bolt: UI prompts, Supabase wiring, and deploy to production.
Describe a UI, iterate with chat, then push the generated components into your Next.js repo.
Free Vercel lesson on prompting v0 to produce production-grade shadcn/ui components.
Reference for Plan mode, browser-based self-testing, and connecting Agent to external data.
Hands-on examples of prompting Replit Agent to build, test, and deploy a small web app.
Wire Replit Agent to a Neon Postgres database and ship a data-driven app from one prompt.
Onboard Devin, scope your first task well, and understand when to use it vs. an IDE agent.
How to brief Devin so it ships: task scoping, repo setup, knowledge files, and review habits.
Reference for Editor and Manager views, agent orchestration, and switching between Gemini and Claude.
Step-by-step codelab: install Antigravity, set up Agent Manager, and ship a first agentic project.
Connect Jules to a GitHub repo, submit your first async task, and review its PR.
Connect Jules to a repo, prompt refactors and unit tests, review the plan, publish branch, open PR.
Enable Copilot, choose an IDE, and try chat, inline suggestions, and the in-repo agent.
Prompt patterns, repo setup, and review habits that make Copilot's output trustworthy.
Install Copilot CLI, authenticate, and run your first terminal-driven prompts and code edits.
Sign in, configure chat participants, and try Copilot's edits and agent modes inside VS Code.
Practical walkthrough of Copilot's three chat modes with concrete "reach for this when" examples.
Four-course Microsoft path on shipping code with GitHub Copilot across VS Code workflows.
Eight-course path on prompting Copilot for reviews, tests, refactors, and secure development.
Free six-unit module on driving Copilot Agent Mode to build, refactor, and fix codebases.
Install aider with pipx, point it at Claude or GPT, and start pairing in your terminal.
Full reference for repo maps, model selection, edit formats, and Git-backed commit flow.
Curated community videos showing real refactors, test-writing, and multi-file edits with Aider.
Install Cline in VS Code, pick a provider, and use Plan/Act mode to control agentic edits.
Walkthrough of Cline's Plan/Act split, browser tool use, and approval-gated terminal commands.
Nine concrete tasks, from bugfix to refactor, showing Cline's tool-use patterns in practice.
Overview of Continue's Agent mode, context providers, and source-controlled config model.
Install the VS Code or JetBrains extension, pick a model, and run your first Agent task.
Configure Continue to run fully local with Ollama, including autocomplete and chat models.
Reference for Roo's multi-mode agents, custom instructions, and per-mode model routing.
Install Roo Code from VS Marketplace or Open VSX and pick a provider for your first task.
Seven hands-on tasks showing Roo's Architect, Code, and Ask modes on a real project.
Install the terminal agent, connect a provider, and run build vs. plan agents on your repo.
Source repo for OpenCode with config examples, LSP setup notes, and provider matrix.
Step-by-step setup from install to AGENTS.md, with model switching and first real tasks.
Install Goose desktop or CLI, connect a model, and add extensions for your workflow.
Practical tour of Goose extensions for shell, Git, and browser automation, fully local.
Toggle Agent Mode, hand off multi-step shell tasks, and inspect Warp's auto-correcting plans.
Overview of Warp's natural-language CLI: chained commands, output reading, and model choice.
Hands-on walk through Agent Mode, workflows, and shell suggestions on real day-to-day tasks.
Open Zed's agent panel, add @-context, and follow the agent's edits in real time.
How Zed wires up providers, edit prediction, inline assistant, and external agents.
Run Claude Agent, Gemini CLI, or Codex inside Zed's agent panel via the ACP adapter.
Video walkthrough of Zed's Agent Panel: configuring providers, prompting edits, and reviewing change hunks.
Install Kiro, sign in, and learn its spec-first flow: requirements, design, and tasks files.
Build a feature end-to-end in Kiro: generate the spec triad and let the agent execute tasks.
Install the droid CLI, sign in, and run your first specialized droid against a repo.
Overview of Factory's droid IDE: parallel droids, review flow, and SDLC coverage.
Mental model for delegating to droids: scoping, briefing, and accepting work products.
Official open-source repo for the Gemini terminal agent — install, configure, and contribute.
Jack Wotherspoon (Google) on context management, MCP servers, and multi-step workflows with Gemini CLI.
Google Cloud's installation-through-advanced walkthrough of Gemini CLI for real coding workflows.
Set up Devin, connect GitHub, prompt it to modernize a repo, monitor execution, and ship the PR.
Ray Villalobos walks pro devs through Claude Code setup, slash commands, and GitHub PR flows.
Writers, builders, and YouTubers worth a follow.
Newsletters and podcasts that cover what's shipping each week.
Short answers grounded in the work of practitioners shipping with coding agents today.
It's the practice of using AI coding agents to ship software while staying the engineer. You decide what gets built. You write the briefs. You read the diffs. The agent handles the typing and most of the rote work. The thinking part stays yours. Karpathy framed it as orchestrating agents and acting as oversight: you're not writing the code directly 99% of the time, but you're still responsible for it.
AI pair programming in its classic Copilot-autocomplete sense is real-time and granular: you're at the keyboard, the AI suggests the next line or block, you accept or reject. The human stays the primary author. Agentic engineering is delegation. You write a brief, the agent does the work end-to-end (often asynchronously), and you review the result. The agent's the author. You're the director who decided what gets built and verifies it did. Modern Copilot ships both modes now, so the line lives in how you use it.
Source: GitHub Copilot documentation
Same tools, different relationship to the code. Vibe coding is Karpathy's casual mode: describe what you want, let the agent run, don't really read the diff. Fine for low-stakes work where being wrong is cheap. Agentic engineering is what you do when the code matters: when it handles secrets, money, or other people's decisions. Same tools. Different stakes.
Source: Simon Willison
Pick one tool and stay with it for a week. The picks worth starting with: Claude Code or Codex if you live in the terminal, Cursor for a dedicated AI-native editor, or VS Code with the Claude Code, Codex, or GitHub Copilot extensions if you want to stay in your current setup. Pick a small task you already know how to do. Watch the agent attempt it. Read every line of the diff. Anthropic's recommendation: explore first, then plan, then code. Start with scope you can verify quickly before expanding what you delegate.
Three habits matter most. Write briefs the agent can actually use: what you want, what context it can use, what done looks like. Keep tasks small and feedback loops fast (Anthropic's own team puts 2–3× quality on tight feedback loops alone). Read every diff. The agent's worst failures don't look like errors. They look like plausible code that does the wrong thing.
Anything where being subtly wrong is expensive. Security-critical changes. Migrations. Cross-cutting refactors in code you don't fully understand. Work where "looks right" isn't sufficient. Scoped tasks inside well-tested boundaries are where agents pay off the most. Anthropic's 2026 trends report saw the same pattern across teams: engineers delegate work that's easily verifiable or low-stakes and keep the conceptually difficult work for themselves.
Almost never on production. The point of agentic engineering is that someone (you) understood what was supposed to happen. If you didn't read the PR, no one did. Auto-merge is fine on scratch repos, generated config, throwaway prototypes. The line is whether anyone else's data, time, or trust depends on the code. GitHub's own guidance for the Coding Agent era keeps a human review gate on anything touching production.
Source: GitHub Engineering
It's converging within categories. Among terminal agents (Claude Code, Codex, OpenCode), among editor agents (Cursor, Windsurf), and among async cloud agents (Devin, Jules), the tools are doing very similar things. Pick whatever fits your workflow. Try a second one a week later. The bigger lever is on the human side: how well you brief, how carefully you review, how small you keep the tasks.
Source: Armin Ronacher: A Year of Vibes
Original writing coming.
Smarter Dev walkthroughs, tips, and short courses on agentic engineering will land here as they're written.
Join the Discord to be notifiedLast updated