Here’s a timeline worth looking at.
Your organization decides in January to run an AI training program for developers. You hire consultants, design a curriculum, and schedule cohorts. By the time the last developer finishes in October, the tools covered in week one are already two generations behind.
This isn’t hypothetical. In 2025, the gap between Copilot’s original autocomplete and agentic tools that complete entire features autonomously was roughly eight months. Training programs designed for one generation of tools are obsolete before they finish shipping.
You Can’t Learn to Swim by Studying the Pool
Nobody has ever become a better swimmer by studying fluid dynamics. You can read about drag coefficients, laminar flow, and the physics of buoyancy. You can memorize stroke mechanics from a textbook. None of it will help you when you get in the water, because the skill is entirely in the doing — in the thousands of small adjustments your body makes before your brain catches up.
AI tools are the same.
You don’t get good at using Claude Code by reading documentation about Claude Code. You get good at it by using Claude Code — badly at first, then less badly, then well. You develop instincts for where it’s useful and where it hallucinates. You figure out how to write specifications that produce good output. You notice when to trust it and when to check its work. None of that is transferable through a course.
The organization wants to know if developers are actually learning. So it measures training completion rates. Developers complete the training. The organization declares success.
But training completion measures training completion, not capability. A developer who finished a GitHub Copilot course six months ago and hasn’t touched it since passes that metric. A developer who spends their weekends experimenting with whatever launched on Thursday fails it — because there’s no course to complete.
The teams most capable with AI tools are generally the ones who didn’t wait for permission.
Three Generations, Twelve Months
This is roughly how 2025 went:
Early 2025 — Copilots. Autocomplete suggestions. Train developers to write good comments, review output.
Mid-2025 — Conversational agents. Chat-based coding partners. Train developers to prompt effectively and iterate.
Late 2025 — Autonomous agents. Entire features completed from a specification. Train developers to… supervise code they didn’t write across thirty files?
Each generation requires different skills. Gen 1 training teaches nothing useful for Gen 3 workflows. A course on “how to use GitHub Copilot” is not preparation for evaluating whether a 2,000-line autonomous agent output is architecturally sound.
Who Adapts and Who Doesn’t
The developers who consistently adapt fastest share a profile: strong technical fundamentals, active presence in communities where tools get discussed (Hacker News, technical Twitter, newsletters like TLDR), and a habit of trying things within days of launch. They don’t wait for corporate guidance. They experiment on their own time because the tools are genuinely interesting to them.
Formal training programs don’t produce this. They produce developers who have completed the training.
The uncomfortable version of this observation: if your team needs a program to get them using AI tools, there’s a harder question underneath. Why does your culture require permission to experiment? That’s the thing worth fixing — not the training content.
What Actually Works
Build conditions for self-directed learning rather than programming curricula.
Tool budgets — $100 to $200 per engineer per month — so people can try things without approvals. Protected time, four hours a week, off the project timeline. Slack channels where engineers share what they’re testing. Monthly demos that are optional and low-stakes. No required adoption, no standardization mandates.
The maintenance cost of this is two to four hours a week for whoever runs the channel. The alternative is 480 to 720 hours of curriculum design per training cycle, for content that’s stale by launch.
The skill that compounds over a career isn’t proficiency with any specific tool. It’s learning velocity — the ability to pick up whatever comes next faster than competitors do.
Copilot knowledge is obsolete in six months. Learning velocity doesn’t expire.
The Imagile Approach
We use AI to build software and it writes most of our code. We also know exactly what we’re looking for because we’ve built modern systems without it. That combination — strong fundamentals plus willingness to use whatever tool is best today — is what lets us move fast without producing output we can’t defend.
We don’t run training programs. We hire engineers who don’t need them.
If your organization is asking whether to build an AI training program, I’d reframe the question: are you trying to build capability, or are you trying to demonstrate that you’re taking AI seriously? Those require different interventions. Only one of them involves a syllabus.