⚙
Hardware Plan
What to buy, and when
Your iMac M1 with 8GB RAM is sufficient for all four phases of this plan. Hardware upgrades are driven by workflow need, not enthusiasm. Here's the honest timeline.
Now — Before Week 1
LaCie Rugged as overflow storage
Move Photos library and large files onto it to free up internal SSD space. The LaCie is a spinning HDD — use it for storage only, not for running code projects. Cost: €0, you already own it.
Phases 1–3 · Weeks 1–14
No new hardware needed
Your iMac handles Python scripts, VS Code, Git, and Claude Code comfortably. 8GB RAM is tight but workable for the project scope in this plan. The bottleneck will be disk space, not compute — hence freeing up space now.
Phase 4 · Weeks 15–20
Optional: external SSD (~€80–120)
When running Flask server + database + Claude Code + browser simultaneously, 8GB RAM will feel constrained. An external SSD (Samsung T7 or similar, USB-C) gives you fast overflow storage for project files if your internal drive fills up again. Not mandatory — evaluate when you get there.
Phase 4+ · Revised Jul 2026
The always-on machine — rationale retired
The original plan here was a Mac mini as a dedicated always-on machine to SSH into for unattended agents. That rationale is obsolete: Claude Code now runs cloud-side sessions you can start and monitor from the desktop or mobile app, and Remote Control reaches your local machine from your phone. The workflow the Mac mini was meant to enable exists without buying anything. Revisit local hardware only if a concrete local-compute need appears that cloud sessions can't cover — don't pre-commit to a purchase for a predicted workflow.
Not needed for your goals
Cloud VMs, Docker, NAS, extra RAM
These solve problems you won't have at this scale. Advisory automation is low-volume and reasoning-heavy — Claude Code cloud sessions handle it with zero infrastructure. Don't buy infrastructure speculatively.
Goal: reach genuine fluency — enough to evaluate, direct, and modify AI-built tools, and to advise clients from experience rather than speculation.
Honest caveat: Claude Code is a multiplier. Let it write for you too early and it produces code you can't evaluate. The first 6 weeks feel slow. That's the foundation. Don't skip it.
Ph 1
Python Foundations
Weeks 1–6 · Claude Code in read-only
Building the evaluation threshold. Until you can read code and roughly assess whether it's right, letting Claude Code write for you is a liability, not an asset. Letting it explain is not — plan mode is read-only and now the best available tutor, because it reasons over your actual files rather than pasted snippets.
Rule (revised Jul 2026): Claude Code in plan mode only this phase — it reads, explains, and reviews your code; it writes nothing. You type every line yourself. Use it to ask "explain this error", "review what I wrote", "why is this structured this way". Same evaluation threshold as the original no-Claude-Code rule, better instrument. One item from the Phase 2 setup list moves forward to Week 1: npm install -g @anthropic-ai/claude-code (Node.js first if needed).
Daily structure
- Weekdays (1 hr): 20 min read/watch · 30 min type and run code yourself — no copy-paste · 10 min break something and fix it
- Weekends (3 hrs/day): Sat: build a small project from the week's concepts · Sun: refactor it, add one new feature
Spec before code — even now. Every project from the Phase 1 briefing summariser onward starts with a 1-page written spec: what it does, what it doesn't, what success looks like. You're writing the code yourself at this stage so it feels redundant. The point is to build the muscle before Phase 3, where spec quality becomes the bottleneck for everything Claude Code produces.
Curriculum
Wk 1–2The basics
- Variables, strings, integers, booleans
- Print statements and f-strings
- If / elif / else
- Lists and loops (for, while)
Wk 3–4Functions & files
- Writing and calling functions
- Parameters and return values
- Reading and writing text files
- Reading CSV files with the csv module
Wk 5–6Real data & APIs
- Dictionaries — the most important data structure for your goals
- JSON — what it is, reading and writing it
- The requests library — calling an external API
- Error handling with try/except
Phase 1 Project
Client briefing summariser
A script that reads a CSV of client names, industries, and notes, then outputs a formatted text summary for each client. Run it in your terminal. Show it to someone. If they find it useful, you've passed.
specPythonfile I/OCSVreal data
📚 Reference — not yet
Skip the video courses in Phase 1
Nick's 4-hour course assumes you can already read code. Watching it now would be like reading a navigation manual before you've learned to drive. Come back to it in Phase 3. (Note as of Jul 2026: the product has changed enough since the course was recorded that the docs at code.claude.com/docs are now the primary reference throughout this plan; the course is conceptual supplement.)
Ph 2
Shell, Git & Environment
Weeks 7–8 · Full environment
Not programming — infrastructure. The scaffolding every real project needs.
3 daysShell essentials
- pwd — where am I?
- ls — what's here?
- cd — move around
- mkdir — create a folder
- cp / mv / rm — copy, move, delete
4 daysGit fundamentals
Mental model: Git takes snapshots, not deltas. Every commit is a full save point — your undo button when Claude Code goes wrong.
Pro Git Ch. 1–3 (free at git-scm.com/book)
- git init · git add . · git commit -m "msg"
- git log · git branch · git checkout
Pro Git Ch. 1–3 (free at git-scm.com/book)
1 dayFull environment setup
Install in this order:
- Homebrew: brew.sh
- Python 3: brew install python
- VS Code + Python extension (code.visualstudio.com)
- Git: brew install git
- Node.js: brew install node
- Claude Code: npm install -g @anthropic-ai/claude-code (already installed in Week 1 if you followed the Phase 1 rule)
📚 Reference — Week 8
Docs: Getting started + Quickstart
Primary: read the Claude Code overview and quickstart at code.claude.com/docs — setup, running in the terminal, the basic session loop. The docs track the current product; recorded courses don't. Supplement: Nick's opening chapters if you want to watch someone fluent drive it, skipping any sections on IDEs you don't use.
docs primarysetupterminal basics
Ph 3
First Claude Code Projects
Weeks 9–14 · Directed building
You direct, Claude Code executes. The bottleneck in working with Claude Code isn't writing code — it's managing what context Claude has when it writes. The operating rule: before accepting any file it produces, read it. If you can't explain a section, ask before moving on.
The core loop: Claude Code writes code → you read every line → ask about anything unclear → only then accept and move on.
Wk 9–10Get comfortable with Claude Code
- Always start inside a Git repo — commit before every Claude Code session
- Use Plan Mode first for anything touching more than 2–3 files
- Set up your CLAUDE.md — the file that tells Claude Code about your project
- Keep CLAUDE.md under 500 lines; add rules only when Claude repeats the same mistake 2–3 times
- Check /context regularly — see what's actually consuming the window before it becomes a problem
📚 Reference — Week 9
Docs: CLAUDE.md, memory & settings
Primary: the docs pages on memory (CLAUDE.md), global vs project settings, and the .claude/ directory. Read before setting up your first project. Supplement: Nick's CLAUDE.md section — his "project brain" mental model remains exactly right even where the config surfaces have moved.
CLAUDE.mdglobal vs local configproject structure
📚 Reference — Week 10
Docs: Permission modes (now six)
Primary: the permission-modes docs page. The spectrum has grown since the course was recorded — default (ask), acceptEdits, plan, auto (a classifier reviews each action; research preview), dontAsk, and bypassPermissions. You'll live in plan and default this phase; auto is Phase 4+ territory. Recorded course sections on this UI are stale — skip them. Plan mode remains your primary tool for anything non-trivial.
plan modepermission modessafety
Phase 3a · Weeks 11–12
Proposal first-draft generator
Feed it a client name, industry, and 3–5 bullet points. It outputs a structured Word-ready proposal draft.
specmulti-file projectstemplatingfile I/O
📚 Reference — Week 12
Docs: Context management
Once you've shipped the proposal generator, read the context-management docs. You'll understand them practically now that you've hit context limitations yourself. Supplement: Nick's context section — his explanation of context rot is conceptually durable even where the specific commands have changed.
context managementtoken usagesession hygiene
Phase 3b · Weeks 13–14
Meeting notes → action item extractor
Paste raw meeting notes, get back a structured list of owners, actions, and deadlines. Your first direct use of the Anthropic API — calling Claude as a service from Python.
specAnthropic APIenv variablesprompting as programming
📚 Reference — Week 14
Docs: Skills (and where MCP still fits)
You've now hit your first genuinely recurring workflow — the API-calling pattern in the meeting notes tool. That's the trigger to create your first skill. Read the skills docs, then build one: a meeting-notes-extraction skill you can invoke any time. The "Skills over MCP" argument (Zhang & Murag, David Gomes) has consolidated since this plan was written — skills are now the established extensibility pattern across Claude Code and Cowork, with MCP as the connector layer for external services rather than the primary way to teach Claude workflows.
skillsrecurring workflowsMCP as connectors
Ph 4
First Deployed Product
Weeks 15–20 · Full assistance mode
Building something with a real user interface, deployed on the internet. Full Claude Code assistance — your job is understanding and modifying, not originating.
Phase 4 Project
MøllerBeck client intake form
A web page where a prospective client fills in their company, situation, and goals. On submit, it emails you a formatted briefing note. Real product, deployed on the internet.
FlaskHTML formemail (SendGrid)Netlifydeployment
Stack note (Jul 2026): Deploy to Netlify — Claude Code deploys to it directly, and it's already in your toolchain. Railway/Render remain fine alternates. Flask stays because this phase is about web anatomy — request/response, state, deployment — not because it's the shortest path. Know the boundary: a lightweight internal tool now ships as a Claude artifact with persistent storage, no deployment at all. If you ever can't say why this project needs the full stack, that's the boundary talking. SendGrid still works for transactional email, though platform integrations increasingly cover this.
📚 Reference — Week 15
Docs: Common workflows · Watch: a full Plan Mode build
Primary: the common-workflows section of the docs for how to structure a multi-phase build. Supplement: watch Nick build a full-stack platform using Plan Mode — the closest analogue to your intake form build, and the planning approach maps directly even where the UI has moved. Watch before you start, not after.
plan mode buildsfull-stackdeployment
📚 Reference — Week 18 · Reframed
Multi-agent: the contested debate (still contested)
You won't build multi-agent systems for MøllerBeck — advisory work is low-volume and reasoning-heavy, and a single Claude Code instance handles it. But you need to discuss the pattern with clients evaluating it. The debate hasn't resolved; orchestration has just gotten cheaper, which makes the naive "more agents = more output" framing more tempting, not less. The live question in mid-2026: multi-agent orchestration vs a single agent with strong context and skills — for most reasoning-heavy work, the second wins. Read the skeptics: Maggie Appleton's "Two Dozen Agents, Zero Alignment", Sandipan Bhaumik on multi-agent reality vs demos, Luke Alvoeiro on probability degradation at scale. Then skim Nick's sub-agents section as the practitioner counterweight. The point isn't to build — it's to evaluate when a client says "we're building a multi-agent system."
contested findingsadvisory fluencywhen not to build
📚 Nick's AI Agents course — Week 20
AI Agents Full Course (2 hrs) — watch in full
This is the capstone watch. By Week 20 you have a deployed product and real experience. This course on agent workflows, multi-agent orchestration, and the broader agentic landscape will now read as a map of where to go next — not abstract theory.
agent workflowsorchestrationwhat's next
Hardware — this phase
By Week 15–20 you may feel RAM pressure (8GB). If it's slowing you down, an external SSD for project files (€80–120) buys headroom. There is no hardware decision point after Week 20 anymore — unattended automation runs via Claude Code cloud sessions, monitored from your phone. See the Hardware Plan section.
↓
Milestones
How to know you're on track
Now60GB+ free on iMac internal drive
Wk 2Can write a loop and a function without help
Wk 4Can read and modify someone else's simple Python script
Wk 6Phase 1 project shipped and used at least once for real work
Wk 8Git repo with meaningful history. Full environment set up. Claude Code docs quickstart read.
Wk 10CLAUDE.md set up. Have used Plan Mode at least once.
Wk 12Proposal generator running. Have read every line of the code.
Wk 16Meeting notes tool live. Have called the Anthropic API directly.
Wk 20Client intake form deployed. Shown to at least one real person.
Mo 5+Begin unattended automation layer via Claude Code cloud sessions. Local hardware only if a concrete need appears.
📖
Parallel Reading Track
1–2 hrs/week throughout
The conceptual layer that makes the technical work meaningful to your clients.
1
Co-Intelligence
Most grounded practitioner take on AI in knowledge work.
2
Anthropic Economic Impact Research
What the people building these tools actually believe about impact.
3
Stanford 120k Developers Study + METR Research
The most empirically grounded data on AI coding productivity. Findings are real but uneven and contested. Read directly, not summaries. This is what calibrates your advisory claims away from vendor marketing — pair it with the Anthropic research above to triangulate.
4
Benedict Evans Newsletter
Technology and business strategy. Sharp, non-hype perspective.
5
Empire of AI
Rigorous reported account of OpenAI and the AI industry — labor, energy, governance, supply chain. The critical counterweight to vendor marketing. Pair with the Anthropic research to triangulate. Dip-in rather than cover-to-cover.
6
The Pragmatic Programmer
Mindset, not tutorial. Read slowly alongside the technical work.
Concepts to discuss fluently by month 4
The first four are now table stakes — your CEO clients have heard them from three vendors. Differentiation is in the second group.
- What an LLM actually is — probabilistic next-token prediction, not retrieval
- What "context window" means and why it matters for business tools
- The difference between automation (rule-based) and AI augmentation (probabilistic)
- Why hallucination happens and what that means for advisory work
Where the advisory bar actually sits (Jul 2026)
- Agentic workflows — what changes when the model acts rather than answers, and how to evaluate agent output
- Skills vs MCP connectors — teaching the model workflows vs connecting it to systems, and why the distinction matters for a client's build decisions
- Context management as the real bottleneck — why "the model isn't smart enough" is usually the wrong diagnosis
- Model tiers and what they're for — matching capability (and cost) to the task rather than defaulting to the largest
- When not to automate — failure modes at scale, and the org-design question underneath every "should we build agents" conversation
- Where Cowork-class tools sit — agentic work for non-technical teams, which is what most of your clients' organizations actually are