If you have been writing C, C++ and Python for fifteen years, you have already survived several hype cycles. You have also learned the instinct that matters most right now: trust nothing you have not measured.
Keep that instinct. In a field experiment with 758 BCG consultants, people using AI on tasks inside its capabilities completed 12.2% more tasks, 25.1% faster, with about 40% higher quality. On a task just outside those capabilities, people using AI got the right answer roughly 60–70% of the time, against 84% for those working without it [S0]. The researchers called the boundary the jagged frontier: uneven, invisible, and different for every kind of task.
Software has its own jagged frontier. This plan is about mapping it for your work, then going one level deeper than most developers bother to: understanding what the models are doing underneath, shipping AI features with real tests, and running models efficiently on hardware you control. That last part is where a C/C++ background stops being "legacy" and becomes a genuine edge.
Time: about 5 hours a week for 8 weeks. Cost: everything in the core path is free. Assumption: you are an expert programmer with little formal machine-learning background.
#include <vector>
int sum_first_two(std::vector<int>& v) {
int& first = v[0];
v.push_back(42); // may reallocate
return first + v[1]; // is `first` still valid?
}
(The second answer should mention that push_back can reallocate and leave first dangling, which is undefined behaviour.) Whatever happened, you now have your first data point on the frontier, from your own codebase rather than from a vendor's demo.
| What you already have | Where it pays off |
|---|---|
| C/C++, memory, SIMD, threads | Inference engineering: llama.cpp is LLM inference in plain C/C++ with integer quantization from 1.5 to 8 bits [S17]; ONNX Runtime [S18] and the PyTorch C++ frontend [S19] put models inside native applications |
| Python | Every ML library and course in this plan |
| Debugging instinct | Reading model failures as data, not as magic |
| Testing discipline | Evals: regression tests for non-deterministic systems |
| Code review | Reviewing AI-generated code, now a daily skill |
| Production scars | Timeouts, retries, cost caps, observability for AI features |
The job: make an AI assistant a genuine productivity gain on real code, not a source of plausible-looking bugs.
First, the mental model (1 hour): watch Andrej Karpathy's Intro to Large Language Models [S1]. It explains, without hand-waving, what a model is, how it is trained and why it fails the way it does.
Build: use an approved assistant, for example GitHub Copilot [S2] or Claude Code [S3], on five real tasks in a non-confidential codebase. Run every task the same way:
Field notes from practice:
Checkpoint: a one-page frontier map for your own codebase: tasks where the assistant is reliably helpful, tasks where it needs close review, and tasks where you no longer use it. Back each entry with your log.
The trap experienced people fall into: accepting a large, confident diff because it compiles and the happy-path test passes.
The job: understand what "the model learned" means mechanically, so you can reason about behaviour instead of guessing.
Build:
Value type with add, multiply, tanh and backward. Train the same small network on the same data as the Python version.Why this matters for a senior engineer: after this sprint, words like gradient, loss, overfitting and learning rate stop being vocabulary and become things you have debugged.
Checkpoint: C++ and Python gradients match within floating-point tolerance, and you can explain backpropagation by pointing at your own code.
If you prefer a structured course: fast.ai's Practical Deep Learning for Coders is free and code-first, and says a year of coding experience is enough [S8]. Coursera's Machine Learning Specialization [S9] and Deep Learning Specialization [S10] are thorough but paid; Coursera's FAQ states the Deep Learning Specialization cannot be taken for free, though financial aid is available.
The trap: watching the videos at 2x speed without typing the code. The understanding comes from the bugs you hit.
The job: build something useful with a model API and hold it to the same standard as any production component.
Optional theory first: Karpathy's Let's build GPT [S11], then the original transformer paper, Attention Is All You Need [S12]. The paper reads much better after you have seen the code.
Learn the API surface: Anthropic's free courses on GitHub [S13] cover API basics, prompting and tool use; the free Hugging Face LLM course [S14] covers open models. Read Building Effective AI Agents [S15], which distinguishes fixed workflows (code decides the steps) from agents (the model decides), and recommends the simplest option that works.
Build: a command-line tool that takes a C or C++ compiler error, or a diff, and returns structured JSON: likely cause, explanation and suggested fix.
Checkpoint: one command runs the eval suite and prints a score, and you have a table showing how at least one change moved it.
The trap: iterating on prompts by feel. Without the eval set you are tuning to the last example you looked at.
The job: run models on hardware you control and understand the real trade-offs, then share what you learned.
Build:
Capstone (choose one):
Teach-back: give a 20-minute brown-bag session to your team. Show your frontier map, your benchmark table and one eval that surprised you. Teaching is the fastest way to find the gaps in your own understanding, and it makes you the person colleagues ask.
Suggested scorecard (illustrative, not an industry standard):
| Criterion | Weight |
|---|---|
| Works end to end, reproducibly | 25% |
| Evaluation quality: real cases, honest results | 25% |
| Engineering quality: tests, errors, limits | 20% |
| Security: untrusted input and output handled | 15% |
| Clarity of the write-up and trade-offs | 15% |
Use only approved tools, and never put proprietary code into unapproved services. Check model and dataset licences. Review AI-generated code for security and licensing like any other contribution. Treat prompts and outputs as untrusted. This plan builds skills; it does not promise a job, promotion or salary outcome.
Last checked 10 October 2026. Prices and free-access policies change; check each page before enrolling. If you only open three: Karpathy's LLM talk [S1], Zero to Hero [S5] and llama.cpp [S17].
Core path (all free)
| Resource | Why it is on this list | When |
|---|---|---|
| Centaurs and Cyborgs on the Jagged Frontier (Ethan Mollick, study co-author) [S0] | Evidence on where AI helps and hurts expert work | Day 1 |
| Karpathy: Intro to Large Language Models (YouTube) [S1] | The clearest one-hour mental model | Week 1 |
| Anthropic: Prompt engineering overview [S4] | Success criteria and tests before prompts | Week 1 |
| Karpathy: Neural Networks: Zero to Hero (YouTube) [S5] and notebooks [S6] | Build neural networks from scratch | Weeks 3–4 |
| 3Blue1Brown: Neural networks (YouTube) [S7] | Visual intuition for backpropagation | Weeks 3–4 |
| Anthropic courses on GitHub [S13] | API, prompting and tool-use notebooks | Week 5 |
| Hugging Face LLM course [S14] | Open models and the Transformers library | Week 5 |
| Anthropic: Building Effective AI Agents [S15] | When (and when not) to build agents | Week 5 |
| OWASP Top 10 for LLM Applications [S16] | The security checklist for AI features | Week 6 |
| llama.cpp [S17] | LLM inference in plain C/C++ | Week 7 |
Tools
| Resource | Note |
|---|---|
| GitHub Copilot documentation [S2] | AI pair programming; pricing varies |
| Claude Code documentation [S3] | Agentic coding in the terminal; pricing varies |
| ONNX Runtime C++ guide [S18] | Run models from C++ |
| PyTorch C++ frontend [S19] | PyTorch without Python |
Optional depth (some paid)
| Resource | Cost | Why |
|---|---|---|
| Karpathy: Let's build GPT (YouTube) [S11] | Free | Transformers in code |
| Attention Is All You Need [S12] | Free | The original transformer paper |
| fast.ai: Practical Deep Learning for Coders [S8] | Free | Structured, code-first course |
| Coursera: Machine Learning Specialization [S9] | Paid | Andrew Ng's foundations, in Python |
| Coursera: Deep Learning Specialization [S10] | Paid, financial aid available | Deeper structured deep learning |
| Udemy: LLM Engineering (Ed Donner) [S20] | Paid, frequent discounts | 8-week project course; public companion repo |
| DeepLearning.AI: ChatGPT Prompt Engineering for Developers [S21] | Check current access | Short API-focused intro |
| Google Machine Learning Crash Course [S22] | Free to access online | ML basics through to an intro to LLMs |
| MIT 6.S191 Introduction to Deep Learning [S23] | Free | University lectures and labs |
| Dive into Deep Learning [S24] | Free online book | Code-heavy textbook |
Written by Chetan Gabhane. Last updated 10 October 2026. Spotted an error or a broken link? Contact me.