Vibe Coding & AI-Assisted Development Training

AI coding tools range from simple autocomplete to systems that plan and execute multi-step tasks with little supervision. This module places vibe coding on that spectrum and marks where the term stops meaning anything useful. The group then picks a stack that fits its actual codebase instead of whichever tool is loudest this month.

• Cursor, Claude Code, Copilot, Windsurf, Lovable, and v0 on one map
• What autocomplete and chat modes do well, plus agent modes
• Vibe coding versus spec-first building: where the line actually sits
• Choosing the right stack
• When an assistant helps, and when it just gets in the way
• Safe defaults for tool access and data boundaries

A way to build with an assistant instead of hoping the first draft is right. Write a clear spec, prompt in short iterative loops, keep enough context that the assistant remembers the whole feature, and notice the moment a session goes sideways. Practiced on a working feature end to end.

• Turning a task into a spec the model can build against
• Prompting in loops, generating, reviewing, and correcting
• Managing context so the assistant keeps the full picture
• Reading and steering the code the model writes rather than accepting it
• Signs a session is failing, and how to recover it
• A team prompt library

The gap between code that runs on one machine and code that's safe to ship. The group reviews AI-generated code for correctness and security. It restores the test discipline that speed erodes, then tackles comprehension debt before it compounds.

• Reviewing AI-written code as rigorously as a human pull request
• Keeping test discipline when nobody typed the code by hand
• Failure modes AI-generated code introduces, and how to catch them
• Comprehension debt, and understanding code before depending on it
• Fitting AI-assisted work into version control and CI
• Where the production line gets drawn

A distinct track for people who are not engineers. Product managers, analysts, and operations staff learn to build internal tools and prototypes with Lovable and v0 inside guardrails, then hand production work to engineering without creating a mess.

• Building a working internal tool from a prompt with Lovable or v0
• What non-developers can safely build, and what they can't
• Data and access boundaries, including where a prototype has to stop
• Testing an idea as a prototype before asking engineering to build it
• Handing off a prototype so engineering can finish it properly
• Knowing when to stop and bring in a developer

Turning trained individuals into a team that uses AI-assisted development well. A rollout playbook brings loose adoption under control and protects IP and data. It also gives leaders a way to see measurable impact.

• A rollout path: pilot, champions, then scale
• Writing an AI-coding usage policy people will follow
• IP and licensing rules, plus data boundaries for generated code
• Containing ungoverned use without banning the tools
• Measuring impact beyond lines of code or seat counts
• Keeping standards after the trainers leave

Each team completes a working internal tool, feature, or prototype with end-to-end instructor review, then leaves with a written playbook for building with AI.

• Scoping a build the team can finish in the session
• Building it with the workflow from the earlier modules
• Live instructor review
• Turning the session into a team playbook
• A first 90-day plan for wider rollout