Claude Code is the tool that finally makes supply chain data science accessible \u2014 even if you’ve never written a line of code. And if you have<\/em> written code, it can compress hours of repetitive data work into minutes of conversation.<\/p>\n This guide organizes everything you need \u2014 from installation to advanced parallel workflows \u2014 into three difficulty levels. Start where you’re comfortable, and level up when you’re ready.<\/p>\n Let’s clear up a common confusion. Claude Code is not<\/strong> a chatbot in your browser. It’s not ChatGPT with a different logo. It’s a full agentic AI that runs inside your terminal \u2014 the same terminal where you run Think of it as hiring a very fast, very patient junior developer who never sleeps and has read every Stack Overflow answer ever written. You give it instructions in plain English, it reads your code, proposes changes, and \u2014 with your permission \u2014 makes them.<\/p>\n The key differences from browser-based AI:<\/p>\n Open your terminal and run:<\/p>\n That’s it. One line. No Docker, no virtual environments, no configuration files. On macOS you can also use You’ll authenticate with your Anthropic account on first launch, and you’re in. A blinking cursor awaits your first instruction.<\/p>\n Don’t overthink this. Start simple:<\/p>\n 1. Ask a question:<\/strong><\/p>\n Claude Code will list your files. It’s the world’s most overqualified 2. Read and explain a file:<\/strong><\/p>\n This is where it gets useful fast. Claude Code doesn’t just dump the contents \u2014 it analyzes the structure, identifies column types, flags potential data quality issues, and suggests what analyses you could run.<\/p>\n 3. Get help:<\/strong><\/p>\n Lists all available slash commands. Bookmark this mentally \u2014 you’ll use 4. Clear the conversation:<\/strong><\/p>\n Starts fresh. Use this when you’re switching topics or when Claude Code seems confused. It’s the equivalent of closing and reopening a browser tab.<\/p>\n 5. Ask for something useful:<\/strong><\/p>\n This is the moment when things click. Claude Code will write the R script, explain what it does, and \u2014 if you allow it \u2014 save the file and even run it. What used to take an hour of Googling and Stack Overflow copy-pasting now takes 30 seconds.<\/p>\n Claude Code works in any terminal, but a quick setup makes the experience dramatically better.<\/p>\n The Shift+Enter problem:<\/strong> In most terminals, pressing Enter sends your message immediately. That’s fine for one-liners, but when you want to write multi-line prompts (and you will), you need Shift+Enter for newlines. iTerm2, WezTerm, Ghostty, and Kitty support this natively. For other terminals:<\/p>\n This configures your terminal to handle multi-line input properly.<\/p>\n Enable notifications<\/strong> so you know when a long-running task finishes. In iTerm2: Settings > Profiles > Terminal > Notification Center Alerts, then filter by "escape sequence." Now you can switch to another tab while Claude Code works, and it’ll ping you when it’s done.<\/p>\n Here’s a concrete scenario. You have a messy Excel export of purchase orders \u2014 inconsistent date formats, supplier names with typos, missing unit prices. Normally this is a 2-hour cleanup job. With Claude Code:<\/p>\n Claude Code will write a Python or R script to do exactly this, explain each transformation, and execute it. Your 2-hour cleanup job becomes a 5-minute conversation \u2014 most of which is reviewing the output.<\/p>\n This is where you stop using Claude Code as a fancy autocomplete and start using it as an actual workflow partner. The productivity difference between Beginner and Intermediate is easily 3-5x.<\/p>\n Every effective Claude Code session follows this four-step cycle. It’s simple enough to memorize and powerful enough to handle any task.<\/p>\n Step 1 \u2014 Explore.<\/strong> Before Claude Code writes a single line, it needs to understand the landscape. Ask it to read relevant files, understand the codebase structure, and identify patterns. Good exploration prompts:<\/p>\n Step 2 \u2014 Plan.<\/strong> Press Shift+Tab twice<\/strong> to enter Plan Mode. (One press activates Auto-Accept mode \u2014 the opposite of what you want here.) In Plan Mode, Claude Code proposes an implementation plan but doesn’t execute anything. You review, adjust, and approve before a single file is touched. This is critical for non-trivial tasks \u2014 it prevents Claude Code from charging off in the wrong direction.<\/p>\n In Plan Mode, Claude Code will:<\/p>\n Press Shift+Tab twice again to iterate on the plan. When you’re satisfied, approve it, and Claude Code executes the entire plan in one shot.<\/p>\n Step 3 \u2014 Build.<\/strong> Claude Code makes the changes. If you’ve set up verification (more on that below), it automatically runs tests after each change to catch regressions immediately.<\/p>\n Step 4 \u2014 Commit.<\/strong> Claude Code can create git commits with meaningful messages, push branches, and even open pull requests. The entire cycle \u2014 explore, plan, build, commit \u2014 can happen in a single session.<\/p>\n This is the single most important intermediate skill. A Here’s what a good CLAUDE.md looks like for a supply chain analytics project:<\/p>\n Key principles for CLAUDE.md:<\/p>\n Run Claude Code has a 200,000-token context window \u2014 enormous, but not infinite. Long sessions accumulate context, and eventually the window fills up. When that happens, performance degrades: Claude Code loses track of earlier decisions, repeats itself, or forgets file contents.<\/p>\n Two essential tools:<\/p>\n The intermediate trick: one task, one session.<\/strong> Don’t ask Claude Code to refactor your forecasting module, then debug an unrelated data loader, then write documentation \u2014 all in one session. Each topic accumulates context, and by the third task you’re deep in the window with conflicting contexts. Start a new session for each distinct task.<\/p>\n Instead of describing files, reference them directly:<\/p>\n The This is Boris Cherny’s number one tip, and he says it delivers "2-3x the quality of the final result." The idea is simple: tell Claude Code to verify its own work.<\/p>\n Even more powerful: challenge Claude Code to find flaws in its own work:<\/p>\n This adversarial verification catches bugs that a simple "write the code" prompt would miss. The code isn’t just generated \u2014 it’s stress-tested before you ever review it.<\/p>\n For quick analysis, pipe data straight into Claude Code from the command line:<\/p>\n This turns Claude Code into a command-line analyst that takes raw data or output and returns structured insights. Combined with cron jobs or scheduled scripts, you can build automated analysis pipelines.<\/p>\n Two flags that change everything:<\/p>\n Also useful: Fair warning: this section gets more technical. The Beginner and Intermediate levels are useful for anyone \u2014 supply chain analyst, operations manager, or occasional scripter. The Advanced level assumes you’re comfortable with git, terminal workflows, and JSON configuration files. If that’s not you yet, bookmark this section and come back when Intermediate feels easy.<\/p>\n This is where Boris’s 250-PRs-per-month workflow lives. The techniques here compound on everything from Beginner and Intermediate. Individually, each one adds 20-30% efficiency. Together, they multiply.<\/p>\n This is Boris’s secret weapon. Instead of working on one task at a time, he runs 5+ Claude Code sessions simultaneously, each in its own git worktree \u2014 an isolated copy of the repository with its own branch.<\/p>\n Now open a terminal in each worktree and launch Running five parallel sessions won’t give you a clean 15x multiplier \u2014 review overhead and merge resolution are real \u2014 but the throughput gains are dramatic enough that Boris Cherny ships 250+ PRs a month.<\/p>\n The key insight: your bottleneck shifts from writing code to reviewing code.<\/strong> You become a technical director \u2014 setting direction, reviewing output, and merging results \u2014 rather than an individual contributor hunched over a keyboard.<\/p>\n Subagents are Claude Code sessions that run inside your main session. Each gets its own isolated 200k-token context window, works autonomously, and returns only a summary to the parent session. Think of them as specialist consultants you bring in for specific tasks.<\/p>\n Define custom subagents in Now you can invoke this specialist any time:<\/p>\n The subagent reads the code, runs the validation, and reports back with findings. Your main context window stays clean.<\/p>\n Boris’s personal subagent toolkit includes a code-simplifier (reduces complexity), a build-validator (ensures everything compiles), a verify-app (runs end-to-end tests), and a code-architect (reviews design patterns). Each one eliminates a category of bugs without cluttering the main session.<\/p>\n Skills are reusable prompts stored in Create Now every Monday morning:<\/p>\n One command. Full report. No manual steps, no forgotten procedures. Your weekly reporting workflow becomes as simple as pressing Enter.<\/p>\n Hooks are shell commands that run automatically at specific points in Claude Code’s workflow. They’re deterministic \u2014 they fire every time, without Claude Code having to remember.<\/p>\n Common use cases:<\/p>\n Boris uses a PostToolUse hook that auto-formats code after any edit:<\/p>\n Every time Claude Code writes or edits a file, it automatically gets formatted. No manual step, no forgotten formatting, no messy diffs in code review.<\/p>\n Model Context Protocol (MCP) servers connect Claude Code to external tools \u2014 Slack, databases, monitoring systems, and more. Configure them in Now Claude Code can query your database directly:<\/p>\n One prompt. Database query. Analysis. Slack notification. What used to be a multi-tool, multi-tab, multi-hour process is now a single sentence.<\/p>\n Claude Code doesn’t require a human at the keyboard. The This opens up automation possibilities that go far beyond interactive coding:<\/p>\n When running Claude Code with more autonomy, security matters. Two critical tools:<\/p>\n This lets Claude Code run Boris specifically recommends No tool review is complete without discussing where it falls short. Claude Code is powerful, but it has real limitations:<\/p>\n The kitchen sink trap.<\/strong> The most common failure mode is cramming too many unrelated tasks into one session. Each topic eats context, and by the fifth task the AI is juggling too many threads. The fix: one task per session, use The trust-then-verify gap.<\/strong> Claude Code generates confident-sounding code that is usually<\/em> correct \u2014 but "usually" isn’t always. Without verification loops (tests, manual review, backtests), bugs slip through. The fix: always include verification in your prompts.<\/p>\n The over-specified CLAUDE.md.<\/strong> A 500-line CLAUDE.md with every edge case documented sounds thorough. In practice, it wastes context tokens and confuses priorities. The fix: keep CLAUDE.md under 200 lines, use IMPORTANT sparingly, and prune ruthlessly.<\/p>\n Infinite exploration.<\/strong> Claude Code can spend its entire context window exploring your codebase without ever making a change. The fix: set clear boundaries. "Read only these 3 files" is better than "Understand the entire project."<\/p>\n Complex multi-file refactors.<\/strong> While Claude Code handles individual file changes brilliantly, large-scale refactors across dozens of files can produce inconsistent results. The fix: break large refactors into smaller, testable chunks and use parallel worktrees.<\/p>\n Everything above applies to any developer. But here’s why this tool is particularly transformative for supply chain and operations management \u2014 a field drowning in data but chronically short on data engineering talent.<\/p>\n MRP parameter auditing at scale.<\/strong> Export your item master from SAP, Oracle, or Business Central. Pipe the CSV into Claude Code and ask: "Flag every item where the safety stock covers less than 1x the lead time demand, and every item where the reorder point hasn’t been updated in over 12 months."<\/em> What used to require a consultant engagement and weeks of analysis becomes a 15-minute conversation with actionable output \u2014 a prioritized list of parameter misalignments ranked by inventory cost impact.<\/p>\n Demand sensing from unstructured signals.<\/strong> Connect Claude Code to your Slack workspace via MCP, and ask it to scan procurement and sales channels for mentions of supply disruptions, customer complaints, or unusual order patterns. It can synthesize those signals into a daily briefing that your planning team reviews every morning \u2014 a lightweight demand sensing layer that costs nothing but an MCP configuration.<\/p>\n Supplier performance dashboards from raw ERP data.<\/strong> Describe the KPIs you need \u2014 on-time delivery rate, quality rejection rate, lead time variability by supplier \u2014 and Claude Code builds the full analytics pipeline: data extraction query, R transformation script, ggplot visualizations, and a self-contained HTML dashboard. The interactive dashboard for this post<\/a> was built exactly this way.<\/p>\n S&OP report automation.<\/strong> Monthly sales and operations planning reports follow the same structure every cycle \u2014 demand vs. forecast accuracy, inventory turns by product family, capacity utilization, and exception flags. Package the entire report generation as a Claude Code skill: one slash command pulls the data, runs the analysis, generates the charts, and saves the executive summary. Your team spends time interpreting<\/em> the report instead of building<\/em> it.<\/p>\n Shared team conventions via CLAUDE.md.<\/strong> Your supply chain analytics team has conventions \u2014 date formats, standard KPI definitions, approved data sources, naming rules for planning parameters. Encode these in a shared Explore the full command reference yourself \u2014 search commands, filter by difficulty level, and build your own quick-reference cards.<\/p>\n![\"Three](\"https:\/\/inphronesys.com\/wp-content\/uploads\/2026\/03\/cc_difficulty_levels-2.png\")
<\/p>\nBeginner Level \u2014 Your First Week with Claude Code<\/h2>\n
What Claude Code Actually Is (and Isn’t)<\/h3>\n
git<\/code>, python<\/code>, or Rscript<\/code>. It can read your files, write code, run commands, search your codebase, and execute multi-step tasks autonomously.<\/p>\n\n\n
\n \nFeature<\/th>\n Claude.ai (Browser)<\/th>\n Claude Code (Terminal)<\/th>\n<\/tr>\n<\/thead>\n \n Reads your local files<\/td>\n No<\/td>\n Yes<\/td>\n<\/tr>\n \n Edits your code directly<\/td>\n No<\/td>\n Yes<\/td>\n<\/tr>\n \n Runs shell commands<\/td>\n No<\/td>\n Yes<\/td>\n<\/tr>\n \n Manages git workflows<\/td>\n No<\/td>\n Yes<\/td>\n<\/tr>\n \n Context window<\/td>\n 200k tokens<\/td>\n 200k tokens<\/td>\n<\/tr>\n \n Best for<\/td>\n Research, writing, chat<\/td>\n Coding, automation, analysis<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Installation: 60 Seconds to Your First Session<\/h3>\n
curl -fsSL https:\/\/claude.ai\/install.sh | bash\n<\/code><\/pre>\nbrew install --cask claude-code<\/code>. Then launch Claude Code by typing:<\/p>\nclaude\n<\/code><\/pre>\nYour First Five Commands<\/h3>\n
What files are in the current directory?\n<\/code><\/pre>\nls<\/code> command, but it’ll also explain<\/em> what it finds.<\/p>\nRead the file data\/procurement_q1.csv and tell me what it contains\n<\/code><\/pre>\n\/help\n<\/code><\/pre>\n\/help<\/code> more than you think for the first few days.<\/p>\n\/clear\n<\/code><\/pre>\nWrite an R script that reads procurement_q1.csv, calculates spend by supplier, and creates a Pareto chart\n<\/code><\/pre>\nTerminal Setup: Small Config, Big Difference<\/h3>\n
\/terminal-setup\n<\/code><\/pre>\nThe Supply Chain Quick Win<\/h3>\n
Read data\/PO_export_march.xlsx and clean it up:\n- Standardize date columns to YYYY-MM-DD\n- Fuzzy-match supplier names and consolidate duplicates\n- Flag rows with missing unit prices\n- Save as cleaned_PO_march.csv\n<\/code><\/pre>\nIntermediate Level \u2014 Becoming Productive<\/h2>\n
![\"The](\"https:\/\/inphronesys.com\/wp-content\/uploads\/2026\/03\/cc_workflow_diagram-2.png\")
<\/p>\nThe Golden Workflow: Explore, Plan, Build, Commit<\/h3>\n
Read the files in src\/inventory\/ and explain the architecture\n<\/code><\/pre>\nWhat forecasting methods are currently implemented in this project?\n<\/code><\/pre>\n\n
Your First CLAUDE.md: The Project Brain<\/h3>\n
CLAUDE.md<\/code> file at the root of your project is a persistent instruction file that Claude Code reads at the start of every session. It’s your project’s brain \u2014 the institutional knowledge that makes Claude Code productive from the first prompt instead of requiring 10 minutes of context-setting.<\/p>\n# CLAUDE.md\n\n## Project\nSupply chain demand forecasting using R. Data in data\/, scripts in src\/, outputs in reports\/.\n\n## Commands\n- Run tests: Rscript tests\/run_all.R\n- Generate report: Rscript src\/weekly_report.R\n- Lint R code: lintr::lint_dir("src\/")\n\n## Conventions\n- Use tidyverse style (pipes, tibbles, snake_case)\n- All date columns: YYYY-MM-DD format\n- ggplot theme: theme_minimal() with base_size = 13\n- Save plots at 800x500px, white background\n\n## IMPORTANT\n- Never overwrite raw data files in data\/raw\/\n- Always validate forecasts against the holdout set before reporting accuracy\n<\/code><\/pre>\n\n
\/init<\/code> to have Claude Code generate a starter CLAUDE.md by analyzing your project. Then refine it yourself.<\/p>\nContext Management: The 200k Skill<\/h3>\n
![\"Context](\"https:\/\/inphronesys.com\/wp-content\/uploads\/2026\/03\/cc_context_management-2.png\")
<\/p>\n\/compact<\/code><\/strong> \u2014 Compresses the conversation history, keeping key decisions and outcomes while discarding the verbose middle. Use this proactively when you notice the conversation getting long, before<\/em> performance degrades. It’s like taking concise meeting notes and starting from the summary.<\/p>\n\/clear<\/code><\/strong> \u2014 Nuclear option. Wipes the entire context and starts fresh. Use this when switching to a completely different task, or when \/compact<\/code> isn’t enough.<\/p>\nThe @-Reference Power Move<\/h3>\n
Look at @src\/forecast.R and @src\/inventory.R \u2014 refactor the shared helper functions into a new @src\/utils.R\n<\/code><\/pre>\n@<\/code> syntax tells Claude Code exactly which files you mean. No ambiguity, no wasted context searching for the right files. You can also reference URLs:<\/p>\nImplement the algorithm described at @https:\/\/otexts.com\/fpp3\/ets.html\n<\/code><\/pre>\nVerification Loops: Trust but Verify<\/h3>\n
After making changes, run Rscript tests\/run_all.R and fix any failures\n<\/code><\/pre>\nImplement the new forecasting method, then prove to me it works by running it on the test dataset and showing the MAPE\n<\/code><\/pre>\nGrill me on these changes. What could go wrong? What edge cases did we miss?\n<\/code><\/pre>\nPiping Data Directly<\/h3>\n
cat data\/demand_forecast.csv | claude "Analyze this demand data. Identify seasonality, trend, and any anomalies. Suggest the best forecasting method."\n<\/code><\/pre>\nRscript src\/model_comparison.R 2>&1 | claude "These are the results of 5 forecasting models. Which one should we deploy and why?"\n<\/code><\/pre>\nSession Management: Pick Up Where You Left Off<\/h3>\n
\n
--continue<\/code><\/strong> \u2014 Resumes the most recent session. You closed the terminal, went to lunch, and came back? claude --continue<\/code> picks up exactly where you left off.<\/li>\n--resume<\/code><\/strong> \u2014 Shows a list of recent sessions and lets you choose which to resume.<\/li>\n<\/ul>\n\/rename "Demand Forecasting Refactor"<\/code> gives your session a meaningful name so you can find it later.<\/p>\nAdvanced Level \u2014 10x Productivity<\/h2>\n
![\"Productivity](\"https:\/\/inphronesys.com\/wp-content\/uploads\/2026\/03\/cc_productivity_curve-2.png\")
<\/p>\nParallel Sessions with Git Worktrees<\/h3>\n
# Create a worktree for each task\ngit worktree add ..\/forecast-refactor -b feature\/forecast-refactor\ngit worktree add ..\/dashboard-update -b feature\/dashboard-update\ngit worktree add ..\/data-pipeline -b feature\/data-pipeline\n<\/code><\/pre>\nclaude<\/code>. Each session has its own 200k-token context window, its own branch, and its own working directory. They can’t interfere with each other. While one session refactors your forecasting code, another builds a dashboard, and a third restructures your data pipeline.<\/p>\nCustom Subagents: Your AI Team<\/h3>\n
.claude\/agents\/<\/code>:<\/p>\n# .claude\/agents\/forecast-validator.md\n\nYou are a supply chain forecast validation specialist.\n\n## Your Mission\nValidate demand forecasts by:\n1. Running backtests against holdout data\n2. Computing accuracy metrics (MAPE, RMSE, bias)\n3. Checking for common errors (data leakage, overfitting, seasonal misalignment)\n4. Comparing against naive benchmarks\n\n## Rules\n- Always compute accuracy on the HOLDOUT set, never the training set\n- Flag any forecast with MAPE > 30% for manual review\n- Include a confidence interval assessment\n<\/code><\/pre>\nUse the forecast-validator agent to check the new ETS model in src\/forecast_ets.R\n<\/code><\/pre>\nSkills and Slash Commands: One-Key Workflows<\/h3>\n
.claude\/skills\/<\/code> that you invoke with slash commands. They turn multi-step workflows into one-liners.<\/p>\n.claude\/skills\/weekly-forecast.md<\/code>:<\/p>\n---\nname: weekly-forecast\ndescription: Generate this week's demand forecast report\n---\n\n1. Read the latest demand data from data\/demand_latest.csv\n2. Run the ETS forecast model in src\/forecast_ets.R\n3. Compare against the moving average baseline\n4. Generate the accuracy comparison table\n5. Create the executive summary chart\n6. Save the report as reports\/forecast_YYYY-MM-DD.html\n<\/code><\/pre>\n\/weekly-forecast\n<\/code><\/pre>\nHooks: Automated Quality Gates<\/h3>\n
\n
{\n "hooks": {\n "PostToolUse": [\n {\n "matcher": "Edit|Write",\n "hooks": [\n {\n "type": "command",\n "command": "Rscript -e 'styler::style_file(\\"$CLAUDE_FILE\\")' || true"\n }\n ]\n }\n ]\n }\n}\n<\/code><\/pre>\nMCP Servers: Claude Code Meets Your Stack<\/h3>\n
.mcp.json<\/code>:<\/p>\n{\n "mcpServers": {\n "postgres": {\n "command": "mcp-server-postgres",\n "args": ["postgresql:\/\/user:pass@localhost\/supply_chain_db"]\n },\n "slack": {\n "command": "mcp-server-slack",\n "env": { "SLACK_TOKEN": "xoxb-..." }\n }\n }\n}\n<\/code><\/pre>\nQuery the supply_chain_db for all purchase orders from Q1 where the supplier lead time exceeded the contracted SLA. Summarize the results and post a report to the #procurement-alerts Slack channel.\n<\/code><\/pre>\nNon-Interactive Mode: CI\/CD Pipelines<\/h3>\n
-p<\/code> flag runs it non-interactively:<\/p>\nclaude -p "Read src\/forecast.R and add input validation for the date parameters. Run the tests afterward." --output-format json\n<\/code><\/pre>\n\n
# Fan-out: update all forecast config files in parallel\nfor config in configs\/forecast_*.yaml; do\n claude -p "Update $config to use the new API endpoint format" &\ndone\nwait\n<\/code><\/pre>\nPermissions and Sandboxing: Safe Automation<\/h3>\n
\/permissions<\/code><\/strong> \u2014 Opens a viewer that shows which tools Claude Code is allowed to use without asking. You can review and manage permissions interactively. To pre-configure allowlists, add them to .claude\/settings.json<\/code>:<\/p>\n{\n "permissions": {\n "allowedTools": [\n "Bash(git add:*)",\n "Bash(git commit:*)",\n "Bash(git push:*)",\n "Bash(Rscript:*)"\n ]\n }\n}\n<\/code><\/pre>\ngit<\/code> and Rscript<\/code> commands without prompting you each time \u2014 while still blocking everything else.<\/p>\n\/sandbox<\/code><\/strong> \u2014 Enables OS-level sandboxing that prevents Claude Code from accessing files or network resources outside the project directory. This is essential for CI\/CD pipelines where Claude Code runs unattended.<\/p>\n\/permissions<\/code> over the --dangerously-skip-permissions<\/code> flag. The allowlist approach gives you speed without sacrificing safety.<\/p>\nWhere It Breaks: Honest Limitations<\/h2>\n
\/compact<\/code> proactively, and start new sessions early rather than late.<\/p>\nThe Supply Chain Professional’s Playbook<\/h2>\n
CLAUDE.md<\/code> checked into your team’s repository. Every team member’s Claude Code session automatically follows the same rules, producing consistent output regardless of who runs the analysis.<\/p>\nInteractive Dashboard<\/h2>\n