Tom Hundley
Most AI training fails because it's built for individuals, not teams.
A developer watching YouTube tutorials learns different things than a developer learning alongside their teammates, with their actual codebase, solving their real problems.
After training development teams across multiple organizations, we've refined a methodology that works. Here's exactly what we do—and why.
Generic AI training typically falls into two traps:
Trap 1: Too theoretical. Three hours on "the future of AI" and "prompt engineering principles" leaves developers nodding along but unable to do anything different Monday morning.
Trap 2: Too tool-specific. Deep dives into one tool's interface become obsolete when the tool updates (which happens monthly in this space).
Our approach is different: we teach workflows and judgment, not tools and prompts.
Tools change. The ability to evaluate AI output, structure complex tasks, and know when to trust (or reject) suggestions—that transfers across every tool and every update.
Our Dev Team Training is intentionally compressed. Four hours is enough to change behavior; two days creates information overload that doesn't stick.
Here's the actual structure:
Most developers approach AI tools wrong. They either:
Neither unlocks the real productivity gains.
We start by establishing the correct mental model: AI as a junior developer who works at superhuman speed but needs constant supervision.
This reframe changes everything. You don't ask a junior dev "how do I implement authentication?" You give them a task, review their work, and course-correct.
What we cover:
Hands-on exercise: Each developer takes a task from their current sprint and breaks it into AI-appropriate subtasks. We review as a group.
This is the practical heart of the training. We teach a single, repeatable workflow:
Plan → Generate → Review → Iterate
Sounds simple. The nuance is in each step.
Plan: Before touching any AI tool, define success criteria. What does "done" look like? What are the constraints? This prevents the common failure mode of generating code that technically works but doesn't fit.
Generate: Structure prompts for the specific task type. We cover patterns for:
Review: This is where senior developers shine. We teach specific review patterns:
Iterate: First output is rarely final. We teach when to refine the prompt vs. when to edit manually vs. when to start fresh.
Hands-on exercise: Live coding session using each developer's actual IDE setup. They implement a feature from their backlog using the workflow.
Once the core workflow is solid, we layer on advanced techniques:
Context management: How to maintain coherent AI assistance across a multi-file change. When to start fresh sessions. How to use project-level context files (like CLAUDE.md).
The Reviewer Pattern: Using AI to review AI-generated code. When this works (catching obvious issues) and when it fails (subtle logic errors).
Test-first AI coding: Write the test specification, then let AI implement. Why this catches more issues than generate-then-test.
Debugging AI failures: When AI gets stuck in loops, when context is poisoned, when to abandon and restart.
Hands-on exercise: Deliberate failure practice. We give developers prompts designed to produce bad output, then practice recognizing and recovering from common failure modes.
Individual skill means nothing if the team can't coordinate.
Code review for AI-generated code: What's different about reviewing code your colleague generated with AI? (Hint: trust less, verify more, but don't slow down the process.)
Documentation and handoff: AI can generate documentation, but someone needs to verify it's accurate. We establish team norms.
The governance question: When is AI appropriate? What requires human-only implementation? We help teams draw their own lines based on their context (regulated industry, security requirements, etc.).
Q&A: The last 15-20 minutes is open discussion. Teams always have specific situations they want to workshop.
A common mistake: treating all experience levels the same.
Junior developers need guardrails. They don't yet have the pattern recognition to catch AI mistakes. We spend more time on "here's what to look for" and "here's when to ask for help."
Senior developers need acceleration. They already know what good code looks like—they need workflows that leverage that judgment at AI speed. We spend more time on advanced patterns and team leadership.
Mid-level developers need confidence calibration. They often know enough to be dangerous—trusting AI in areas where they shouldn't, distrusting it where they could benefit. We focus on building accurate mental models of AI capabilities.
When we train a mixed-experience team, we acknowledge this openly and structure exercises so senior devs can mentor juniors during hands-on work.
Tool-specific deep dives. We demonstrate with Claude, Cursor, and Copilot, but we don't spend 30 minutes on Cursor's settings panel. Tools change too fast.
Prompt engineering tricks. "Use this magic phrase for better results" doesn't transfer. We teach principles that work across any tool.
AI theory and history. Interesting, but not actionable. We're here to change behavior, not give a lecture.
Fear and hype. We don't spend time on "AI will take your job" or "AI will solve everything." Both are distractions from the practical work.
Training without reinforcement fades within weeks. We build in sustainability:
Recording: Every session is recorded. Developers can revisit specific sections.
Reference materials: We provide a condensed cheat sheet of the core workflow and patterns.
30-day check-in: A follow-up call to address questions that emerged during real work.
Slack channel access: For the first 30 days, your team can ask us questions directly.
The goal isn't a one-time event—it's a permanent upgrade to how your team works.
How do you know if training worked?
Immediate signals (first week):
Medium-term signals (first month):
Long-term signals (quarter+):
We ask teams to track these qualitatively. The goal isn't scientific measurement—it's sustainable behavior change.
This training works best for:
This training is NOT right for:
$5,000 for up to 30 developers. 4 hours via Zoom.
That's less than $167 per developer for training that changes how they work every day.
Compare to:
The ROI math works for almost any team doing meaningful development work.
We run Dev Team Training sessions weekly. The process:
Book a call to discuss your team's training →
For more content on AI adoption strategy, see our other articles for engineering leaders on making informed decisions about AI in your organization.
Discover more content:
