06 — Failure Modes¶
Seven ways this specific arc dies. Not generic “learn to code” pitfalls — the exact seven that hit a returning-dev, applied-ML-targeted, moonlighting engineer at Zoho, in India, in 2026.
Each mode has: a name, a description, an early signal, an escape route, and a hard rule you commit to in advance so the escape does not require willpower in the moment.
Do not read this file once. Re-read it at the start of every phase transition (P0→P1, P1→P2, …) — seven times over the 13 months. Each phase has a favourite failure mode; awareness at the boundary matters.
1. Tutorial Hell¶
Description. You watch Cherno. You watch mCoding. You watch a CppCon talk. You feel productive. You have not touched an editor. At W4 you have consumed 40 hours of video and shipped 0 lines of code.
Why it hits you specifically. Two years of AI-assisted coding has softened the muscle that translates “I understand this concept” into “I can type this from scratch.” Video feels like the safe on-ramp back. It is not. Video is validation of prior code experience, not a substitute for it.
Early signal. End of W2, and you have watched more than 3 videos totalling more than 90 minutes but committed less than 100 lines of C++ to a repo.
Escape route. Rung 1 (P0.1 wc clone) MUST be shipped by end of W3. No exceptions. If it means abandoning the entire refresh reading list to focus on typing code — do it.
Hard rule (commit to this now). Videos are dessert. You may watch one CppCon or Cherno video per week, on Sunday, only after the sprint’s core has shipped. Any other video watching in the arc counts as procrastination and is subtracted from your weekly hours ledger.
2. Compiler-Friction Paralysis¶
Description. Hour 1: linker error. Hour 2: still linker error. Hour 3: CMake generates the wrong toolchain. Hour 4: you close the laptop and don’t open it for four days. Motivation dies not from difficulty but from friction.
Why it hits you specifically. In Python and modern JS, dependencies just work. C++ toolchain configuration is a discipline in itself. Coming back after 2 years, you’ve forgotten which macOS-specific things bite you (libc++ vs libstdc++, homebrew clang vs Apple clang, xcode-select, pkg-config PATHs, Apple Silicon vs x86_64 arch mismatches).
Early signal. More than 90 minutes on any single toolchain problem in a session.
Escape route.
P0 file
03_common_pitfalls_returning_dev.md— read it W1, then again W3. It documents the 12 macOS+CMake potholes.Always build with
cmake --build build --verbose. The invisible commands are where the errors live.90-minute rule. If you have spent 90 minutes on a single toolchain problem, STOP. Post the problem to
#cpp-loungeon the C++ Discord (see../10_communities/). Or open a StackOverflow question with a minimal repro. Do not spend hour 3 alone.Have a working
hello_cmakescaffold repo you never touch. When a new project’s build breaks,diffyour CMakeLists againsthello_cmake.
Hard rule. No sprint core is a build-system task. Build systems are means. If your CORE for a sprint reduces to “get CMake working” — you have already lost that sprint. Cut to a g++ -std=c++20 main.cpp build until the language work is done, THEN adopt CMake.
3. AI Reliance Rebound (highest risk)¶
Description. You hit M2. You hit a hard bug in the small hash-map project. You are tired — it’s 10 PM after a Zoho day. You open Cursor “just to check what’s going on.” It generates a working answer in 20 seconds. You accept it. You commit it. The next night, the same. Within two weeks you are back to the same relationship with AI that got you here in the first place.
Why it hits you specifically. This is literally the muscle you’re trying to rebuild. Your brain has 2 years of reward association with “open AI → dopamine hit.” The M2 bug hits at the exact energy-low moment.
Early signal. Any of:
You cannot recall, without looking, what functions you wrote in the past week.
Over 30% of code in a session came from AI autocomplete.
You feel “productive” but cannot explain a chunk of code you shipped 3 days ago.
Escape route.
The typed-once rule. Every line of C++ in your committed repos must have been typed by you at least once. Reading AI output, understanding it, closing the tab, and typing it yourself is fine — that is learning. Accepting an AI diff into your file is not.
AI phase rules:
M1 (P0): NO AI. None. Not Copilot, not Cursor, not ChatGPT for code. Disabled at editor level. Google is fine. cppreference is fine.
M2–M6: AI allowed to explain. Ask it “why does this segfault?” — fine. Ask it “write me a hash map” — not fine.
M7–M13: AI allowed to scaffold boring things (build system, README templates, arg-parsing boilerplate) that you have already typed by hand at least once before in the arc.
The 2-min rule. Before opening AI on a hard bug, spend 2 minutes stating the bug in writing (in your lab notebook). Write the hypothesis. THEN open AI — and only to explain, not to fix. Half the time you’ll solve it before finishing the writeup.
Hard rule. For M1, Copilot / Cursor / Codeium are uninstalled from your editor. Not just disabled — uninstalled. Physical friction matters at this stage.
4. DSA Over-Optimisation¶
Description. You start P2 (DSA in C++). LeetCode gamifies well. Discord/subreddit peers are grinding Codeforces. You get sucked in. You spend M4–M6 doing 3 problems a day and drop the applied-ML target. At M9 you have LeetCode 800/1000 rating and no ML C++ project shipped.
Why it hits you specifically. LeetCode is a comfort zone — clear rules, immediate feedback, definite progress. Applied ML C++ (P5) is ambiguous, project-based, and lonely. Your brain will pull toward LeetCode.
Early signal.
End of W16 (M4) and P4 has not started.
More than 70% of a week’s hours went to LeetCode.
You’ve done more than 20 problems this week.
Escape route. Hard cap:
60 problems / month during P2 (M4–M5).
NeetCode 150 is the ceiling. Not NeetCode 250, not 300. When you hit 150 solved OR when M5 ends — whichever comes first — you MOVE ON, regardless of unsolved count.
Zero LeetCode from M7 onwards until study loop starts (M11). study prep resurrects it — M6–M10 it stays dead.
Hard rule. LeetCode / Codeforces browser tab is closed and the site is blocked (via a hosts file entry or Cold Turkey) during P3, P4, P5, P6. Physical block. Not “I will resist.”
5. Trying To Learn EVERY C++ Feature¶
Description. You discover C++20 modules. You want to master them. You discover coroutines. You want to write a coroutine-based scheduler. You hear about C++26 reflection. You spend a weekend reading proposals. Your rung is late.
Why it hits you specifically. The intellectual thrill of “a new language feature” is real, and it is the exact same trap that got you to be an eternal student instead of a shipping engineer. C++ is a language you can spend a lifetime not shipping.
Early signal. You’ve read 3+ blog posts about a language feature you don’t need for the current rung.
Escape route. Phase gating:
C++20 is the target. Every rung is built in C++20. Do not chase C++23 features unless a specific rung requires them and they save real code.
C++23 additions are opt-in.
std::print,std::expected,std::mdspan, ranges improvements — use where they save code, ignore where they don’t.C++26 is know-it-exists-only. Read one summary blog post at end of arc (M13). Do not read proposals in-arc.
Modules: skip. Cmake support in 2026 is still uneven, ecosystem is not there. Header/inline is fine for the entire arc.
Coroutines: skip unless P3 rung 4 (concurrency) explicitly calls for them and the compiler support is smooth. Otherwise you’re writing a coroutine scheduler and calling it “learning.”
Hard rule. No rung requirement is added mid-sprint. If you discover a new feature you want to use, note it in IDEAS.md and consider it for a future rung. Current rung stays on its original spec.
6. The Zoho Creep¶
Description. Q3 push at Zoho. A big release. On-call rotation. Suddenly 8 PM becomes 10 PM. Saturday afternoon becomes a “just one thing” that eats until 6 PM. Two sprints in a row you’re at 4 hours instead of 11. Then three. The roadmap dies not with a bang but with a gradient.
Why it hits you specifically. Indian tech culture (and Zoho specifically has product cycles that ramp hard) does not naturally protect evenings. The default is that work fills all available time, and the roadmap is invisible to your manager.
Early signal. 3 consecutive weeks below 8 hours. Or: any single week below 4 hours.
Escape route.
Hard boundary: 7 PM, 4 nights a week. Phone in another room. Slack logged out. Zoho stops existing 7 PM – 6:30 AM those 4 nights. Pick the 4 nights in advance each Sunday.
The half-Saturday rule. Saturday 9 AM – 1 PM is non-negotiable study time. Not “if nothing else comes up.” Non-negotiable in the same category as sleep. Weddings, family emergencies, illness are the only exceptions. Regular work is not.
The Zoho-conversation trigger. If TWO sprints get eaten by Zoho work, you have an explicit conversation with yourself: is Zoho the current on-track career, or is the roadmap? Do not fake it. Write the answer in the lab notebook. If Zoho, cut roadmap scope by 30%. If roadmap, adjust Zoho engagement (say no to one thing).
See
08_health_burnout.mdfor the physical layer.
Hard rule. No roadmap work between 7 PM – 10 PM on the 4 protected nights. The 4 nights are for family / rest / hobby / sleep, not to be repurposed into roadmap work when Zoho is quiet. This is what keeps the arc sustainable.
7. Isolation Collapse¶
Description. You’re doing this alone. Nobody around you (at Zoho or in family) is learning C++ at your intensity. Twitter engineers look 10x more productive. You lose the sense that anyone will notice or care whether you ship. Motivation dies. You keep coding a bit but the fire fades. At M7 you look up and realise you haven’t posted anything in 8 weeks and haven’t talked to another engineer about C++ in longer.
Why it hits you specifically. Moonlighting is a lonely activity by nature. Bangalore/Chennai remote-work isolation is real. The subreddits and Discords exist but you have not joined them.
Early signal. No post shipped for 6+ weeks. No conversation with another C++ person for 4+ weeks. Sprint retro says “I don’t know if this matters.”
Escape route.
Ship rung 1 publicly by W3. Not to GitHub-in-private. Publicly. Post it to r/cpp weekly show-off. Someone will comment. That’s the first fire.
r/cpp weekly show-off: post something (even a tiny commit link) every 2 weeks minimum. Low bar. High return.
C++ Discord:
cpplangSlack + Together C++ Discord. Join in W1. Lurk W1–W2. Ask one question in W3. Answer someone else’s question in W4. By M2 you have 2–3 people you recognise.1 CppCon talk / week, Sunday. Take notes. Post the notes as a mini-thread. Tags:
#cppcon,#cpp. Speakers see it. Occasionally reply. Free network.In-person, optional but powerful: any Bangalore/Chennai C++ / low-level meetup that appears. Meetup.com filter for “C++” or “systems.” Attend even if you don’t talk. Presence changes something in you.
Hard rule. One outgoing signal per week. Post, comment, DM, meetup attendance. Any of them. Silence for 3 weeks in a row triggers the Sunday audit reset protocol.
The composite risk table¶
Mode |
Probability |
Highest-risk window |
Discipline file to re-read at the boundary |
|---|---|---|---|
1. Tutorial hell |
25% |
W1–W3 |
|
2. Compiler-friction paralysis |
30% |
W1–W4, W20–W24 |
|
3. AI reliance rebound |
40% |
M2–M3 valley |
this file, |
4. DSA over-optimisation |
15% |
M4–M6 |
|
5. Every C++ feature |
10% |
M5–M8 |
this file |
6. Zoho creep |
60% |
continuous |
|
7. Isolation collapse |
35% |
M5–M8 |
|
Zoho creep and AI rebound are the top-2 by a wide margin. Reread the corresponding pre-mortems every phase boundary.