{"success":true,"course":{"all_concepts_covered":["Claude Code runs in your local project context","Structured prompts that produce clean diffs","Repo-level rules and reusable prompt blocks","Plan-then-execute workflow with model selection","PR-oriented collaboration and security scanning cues","Remote control as an interface to a host session"],"assembly_rationale":"The course sequence starts by establishing a correct operational model (Claude Code working in a local repo, producing edits you can review) because the pre-test showed confusion about GitHub as an editor and uncertainty about how AI changes land in files. The second segment is an add-on that reinforces the host/session mental model via remote control. Several required micro-concepts could not be covered because the provided segment library does not include dedicated instruction for CLI navigation, Git lifecycle, GitHub repo strategy, sandbox/permission controls, debugging/review loops, or AI API integration patterns.","average_segment_quality":6.1625,"concept_key":"CONCEPT#c5b12231488b293b3d856982e395caf0","considerations":["Video coverage is far below the 120-minute target due to limited available segments; additional high-quality segments are needed to meet the time budget.","Most of the refined-spec focus areas (CLI fundamentals, Git commit/push workflow, GitHub repo management, permission/sandboxing, iterative debugging, and AI API integration) are not adequately covered by the available segment set.","The remote-control segment is below the intermediate depth threshold and should be replaced when a deeper, workflow-focused authentication/session-management segment is available."],"course_id":"course_1773240074","created_at":"2026-03-11T14:50:47.440683+00:00","created_by":"James Stothard","description":"Learn a practical mental model for using Claude Code inside a local repository, turning intent into structured prompts that produce reviewable changes. You’ll also see how this connects to GitHub-style collaboration via diffs and PR-oriented habits, plus what “remote control” does and does not mean for your files and compute.","embedding_summary":"","estimated_total_duration_minutes":15.0,"final_learning_outcomes":["Explain, at a practical level, how Claude Code operates on local repository files and why that differs from a chat-only workflow.","Write structured prompts that constrain scope, specify acceptance criteria, and produce reviewable diffs.","Set up simple repo-level guidance (rules and reusable prompts) to make AI-assisted changes more consistent across sessions.","Choose a plan-then-execute approach (including model choice) to reduce rework and keep changes understandable.","Describe what Claude Code remote control does and does not do, especially where computation and file access actually occur."],"generated_at":"2026-03-11T14:49:44Z","generation_error":null,"generation_progress":100.0,"generation_status":"completed","generation_step":"completed","generation_time_seconds":148.55474257469177,"image_description":"A focused professional sitting at a desk with a laptop open, hands on keyboard, concentrating on a terminal-driven coding workflow. Next to the laptop is a small notebook with handwritten checkmarks and a pen, suggesting a structured plan-and-review process. On a second device, a smartphone lies on the desk to imply remote session handoff, but it’s not the main focus. The environment is a realistic home office or quiet workplace, with soft natural light and minimal clutter. The mood is calm, deliberate, and methodical, emphasizing controlled experimentation and careful review rather than hype. Key visual cues should suggest “local project work” and “versioned changes”: a terminal window feel, code context, and a sense of stepping through a checklist before sharing work.","image_url":"https://course-builder-course-thumbnails.s3.us-east-1.amazonaws.com/courses/course_1773240074/thumbnail.png","interleaved_practice":[{"difficulty":"mastery","correct_option_index":2.0,"question":"Claude Code proposes a change touching 18 files across your repo, including config and build scripts. You want to keep the change reviewable and reversible before it ever reaches a PR. Which prompt constraint is the best first move to reduce risk while still making progress?","option_explanations":["Incorrect: a stronger planning model can improve reasoning, but it doesn’t constrain file boundaries or diff size, so it doesn’t address the main risk.","Incorrect: parallel tasks can help exploration, but it increases cognitive load and still doesn’t enforce a constrained, reviewable diff.","Correct! File/directory boundaries plus small diffs and acceptance criteria create predictable, reviewable changes you can safely iterate on.","Incorrect: a summary helps comprehension after the fact, but the risky part is uncontrolled scope before review."],"options":["Switch to a stronger planning model and ask for an ultrathink response, so the change is more likely to be correct even if it’s large.","Queue multiple tasks in parallel so you can compare alternative implementations and pick the best one.","Explicitly restrict the scope to specific files or directories, and require a small, clean diff plus acceptance criteria before expanding scope.","Ask Claude Code to implement the full refactor, but require it to summarize what changed in plain language at the end."],"question_id":"q1_scope_diff_control","related_micro_concepts":["structured_prompts_claude_code","filesystem_project_layout","git_lifecycle_stage_commit_sync"],"discrimination_explanation":"Restricting scope and demanding a small diff with acceptance criteria directly controls blast radius and makes review/rollback feasible—this is the core safety lever of structured prompts. Stronger planning, summaries, or task queueing can help, but they do not prevent risky cross-repo edits from landing all at once."},{"difficulty":"mastery","correct_option_index":1.0,"question":"A teammate says, “We don’t need a local repo—GitHub is where Claude Code writes the code anyway.” Which response best corrects the mental model while keeping a PR-based workflow possible?","option_explanations":["Incorrect: the phone can control a session, but the host machine still owns the files and tools.","Correct! Claude Code works in your local project context on the host, and GitHub is for hosting/sharing history via commits and PRs.","Incorrect: GitHub is not an automatic write target for your working directory; versioning still relies on commits and pushes.","Incorrect: GitHub Actions can review/scan, but they are not where Claude Code primarily edits your project files."],"options":["Claude Code writes code in the phone app; your laptop is only used for viewing diffs after the fact.","Claude Code operates on files in your project directory on the host machine; GitHub is the remote place you push commits/PRs to after reviewing changes locally.","Claude Code writes directly to a cloud copy of your repo; committing locally is redundant if the AI is correct.","Claude Code runs in the GitHub web UI; cloning locally is optional, but only if you enable GitHub Actions first."],"question_id":"q2_local_vs_github_editor","related_micro_concepts":["structured_prompts_claude_code","github_repo_management_strategy","git_lifecycle_stage_commit_sync"],"discrimination_explanation":"The correct model is local-first: Claude Code edits the working files on the host machine inside the repo folder, and GitHub becomes relevant when you push commits and open PRs. The other choices confuse interface (web/phone) with execution location, or incorrectly imply GitHub is the editing runtime."},{"difficulty":"mastery","correct_option_index":2.0,"question":"You’re about to add a new feature and want Claude Code to minimize rework. You have access to a stronger “planning” model and a faster “execution” model. Which workflow best matches the plan-then-execute approach described in the course?","option_explanations":["Incorrect: planning is where higher reasoning pays off most; using the faster model there increases the chance of an unstable plan.","Incorrect: skipping the plan increases risk of uncontrolled scope and rework, even if the model is strong.","Correct! Strong planning first, then faster execution in small, reviewable increments, matches the intended workflow.","Incorrect: using only the stronger model can work, but it ignores the deliberate tradeoff of reserving expensive/slow reasoning for planning while keeping execution efficient."],"options":["Use the faster model for planning to move quickly, then switch to the stronger model for execution to ensure correctness.","Ask the stronger model to produce code directly in one pass, without a plan, to avoid overthinking.","Use the stronger model to create a structured plan and task breakdown, then switch to the faster model to implement the planned steps in small diffs.","Use only the stronger model end-to-end so you never risk a weaker model making edits."],"question_id":"q3_plan_then_execute_tradeoff","related_micro_concepts":["structured_prompts_claude_code","iterative_debugging_ai_code_review"],"discrimination_explanation":"Plan-then-execute is about using higher reasoning where it matters—requirements, constraints, and decomposition—then using a faster model to implement the plan in controlled steps. The distractors either invert the tradeoff or skip planning, increasing the chance of broad, hard-to-review edits."},{"difficulty":"mastery","correct_option_index":1.0,"question":"You want Claude Code to behave consistently across sessions and reduce the chance of policy drift (style, boundaries, and “don’t touch these files”). Which approach most directly creates persistent, repo-scoped guidance that travels with the project?","option_explanations":["Incorrect: remote control keeps you connected to a session, but it does not create versioned, shareable project rules.","Correct! Repo-scoped Markdown guidance (rules + reusable prompts) is the most direct way to make behavior consistent and reviewable in Git history.","Incorrect: merge checks can catch issues late, but they don’t provide the day-to-day instructions that prevent drift during edits.","Incorrect: planning helps structure work, but inferred standards are unreliable without explicit, persistent rules."],"options":["Rely on the phone app connection, because remote control preserves context better than local sessions.","Write repo-level rules in a Markdown file (for example, claw.md) and keep reusable instructions in prompt.md so guidance is versioned with the repository.","Use GitHub Actions to block merges; this guarantees Claude Code will follow your standards during implementation.","Turn on plan mode for every task; the model will infer your standards from the plan and won’t need explicit rules."],"question_id":"q4_repo_rules_vs_runtime_controls","related_micro_concepts":["structured_prompts_claude_code","github_repo_management_strategy"],"discrimination_explanation":"Repo-level rule and prompt files are explicit, persistent, and versioned—so they create consistent behavior even across new sessions or collaborators. Remote control and plan mode can help, but they don’t replace written standards. GitHub Actions can enforce checks at merge time, but they don’t guide behavior during implementation."},{"difficulty":"mastery","correct_option_index":3.0,"question":"You link a Claude Code session using “/remote-control” and continue from your phone while away from your laptop. A bug appears that requires running a local command against the repo. Which statement best describes what is actually running the tools and accessing the files in this setup?","option_explanations":["Incorrect: the segment emphasizes you’re controlling a real host session, not editing a separate cloud copy by default.","Incorrect: GitHub Actions can run checks on pushes/PRs, but they are not triggered by phone typing alone and do not replace the active host session.","Incorrect: the phone is not the execution environment for CLI tools in this workflow.","Correct! The host machine runs the session, tools, and file access; the phone is the interface to that same running context."],"options":["Anthropic’s cloud runs the tools and edits a cloud copy of your repo; your laptop is just a display.","GitHub runs the tools via Actions automatically whenever you type in the phone app.","The phone runs the tools, but the laptop holds the files; results sync back when you reconnect.","The host machine (laptop or server) runs the tools and accesses the repo; the phone is a controller interface to that same session."],"question_id":"q5_remote_control_what_runs_where","related_micro_concepts":["claude_code_setup_authentication","cli_local_dev_navigation"],"discrimination_explanation":"Remote control is an interface handoff, not a compute/location change. The host session still owns the filesystem and command execution. The distractors confuse where computation happens (phone/cloud/GitHub Actions) versus where the CLI session and repo actually live."},{"difficulty":"mastery","correct_option_index":0.0,"question":"You’re worried about accidentally leaking an API key while using Claude Code. You want a defense that helps even if someone makes a mistake in a local change. Which control best fits as a GitHub-side safety net mentioned alongside PR workflows?","option_explanations":["Correct! PR/check-based scanning is designed to catch issues like leaked keys before code is merged, acting as a last line of defense.","Incorrect: putting secrets in repo files is exactly what you’re trying to avoid; it increases leak risk.","Incorrect: remote control doesn’t inherently reduce secret exposure; it’s just an interface to the same host context.","Incorrect: model choice can affect quality, but it does not guarantee secrets won’t be exposed or committed."],"options":["Use PR-integrated automation (for example, checks or scanning) to flag leaked secrets or risky changes before merge.","Store secrets in prompt.md so Claude Code can reference them consistently without re-asking.","Only use remote control from your phone; mobile sessions are less likely to expose credentials.","Always do implementation with the strongest model; stronger models do not leak secrets."],"question_id":"q6_pr_security_scanning_vs_prompt_rules","related_micro_concepts":["github_repo_management_strategy","structured_prompts_claude_code"],"discrimination_explanation":"PR-side checks/scanning are a backstop: they detect problems at integration time even if a local workflow slips. The other options are either actively unsafe (putting secrets in repo text) or rely on false guarantees (model strength or phone usage)."}],"is_public":true,"key_decisions":["Segment 1 [3aKVArutiIU_36_570]: Selected first because it is the only segment that clearly teaches Claude Code as a local, repo-scoped workflow with structured planning, reusable rules, and reviewable changes.","Segment 2 [ocQ7ZKhHU5Q_19_353]: Included second as a limited, lower-depth fallback to strengthen the host-vs-client mental model and session continuity, even though it does not cover the core Git/GitHub plumbing in depth."],"micro_concepts":[{"prerequisites":[],"learning_outcomes":["Explain the difference between a project directory, user home directory, and system locations","Identify which files should be committed to a repo versus kept local (e.g., secrets, build artifacts)","Anticipate common permission-related failures and what they usually mean"],"difficulty_level":"beginner","concept_id":"filesystem_project_layout","name":"Project folders, paths, permissions","description":"Build a mental model of project directories, paths, and which files belong in a repository versus local-only machine state. Learn how OS permissions and hidden files influence what tools (including Claude Code) can safely read or modify.","sequence_order":0.0},{"prerequisites":["filesystem_project_layout"],"learning_outcomes":["Navigate between directories and understand where commands execute","Recognize the difference between shell, terminal, and a program running inside the terminal","Diagnose common local-run failures (wrong folder, missing dependency, permissions) at a high level"],"difficulty_level":"beginner","concept_id":"cli_local_dev_navigation","name":"CLI navigation for local development","description":"Use the terminal to navigate a codebase, inspect files, and run common project tasks without getting lost. Emphasizes repeatable workflows that AI tools can mirror when they execute local actions.","sequence_order":1.0},{"prerequisites":["cli_local_dev_navigation"],"learning_outcomes":["Explain what staging and committing represent in Git history","Choose when to commit versus when to keep iterating locally","Predict how local history and remote history diverge and reconcile"],"difficulty_level":"beginner","concept_id":"git_lifecycle_stage_commit_sync","name":"Git lifecycle: stage commit sync","description":"Learn the Git mental model for tracking changes through working directory, staging area, commits, and synchronization with a remote. Focus on making small, reviewable commits that support AI-assisted iteration.","sequence_order":2.0},{"prerequisites":["git_lifecycle_stage_commit_sync"],"learning_outcomes":["Differentiate Git (local history) from GitHub (remote hosting and collaboration)","Use branches and pull requests as the default integration mechanism","Describe how GitHub security features reduce the risk of leaking API keys or vulnerable dependencies"],"difficulty_level":"intermediate","concept_id":"github_repo_management_strategy","name":"GitHub repository management and strategy","description":"Set up and manage a GitHub repository so work is understandable, reviewable, and recoverable using branches and pull requests. Introduce repository security basics relevant to AI projects, including secret scanning and dependency alerts.","sequence_order":3.0},{"prerequisites":["cli_local_dev_navigation","github_repo_management_strategy"],"learning_outcomes":["Explain what Claude Code is doing locally versus what happens in the cloud","Choose an authentication approach and understand its billing implications","Connect Claude Code to a repository workflow in a way that supports PR-based work"],"difficulty_level":"intermediate","concept_id":"claude_code_setup_authentication","name":"Claude Code setup and authentication","description":"Configure Claude Code to work in your terminal and connect to your codebase, Git, and GitHub. Compare subscription-based login versus API-key authentication and how credential choice impacts cost and behavior.","sequence_order":4.0},{"prerequisites":["claude_code_setup_authentication"],"learning_outcomes":["Explain why permission prompts exist and what they protect against","Define a safe workspace boundary for an AI coding agent","Recognize prompt-injection risk patterns and apply simple mitigations"],"difficulty_level":"intermediate","concept_id":"claude_code_permissions_sandboxing","name":"AI workspace permissions and sandboxing","description":"Learn how Claude Code requests permission before editing files or executing actions, and how to keep changes scoped to the project directory. Cover threat models like prompt injection and safe defaults for local execution and network access.","sequence_order":5.0},{"prerequisites":["claude_code_setup_authentication","claude_code_permissions_sandboxing"],"learning_outcomes":["Write prompts that include scope, constraints, and acceptance criteria","Break a feature into agent-sized tasks that minimize risky changes","Request outputs that produce clean diffs and easy reviews"],"difficulty_level":"intermediate","concept_id":"structured_prompts_claude_code","name":"Structured prompts for Claude Code","description":"Turn a vague feature idea into a clear, testable request that an AI coding agent can implement in small steps. Practice specifying constraints, success criteria, and file boundaries so changes are predictable and reviewable.","sequence_order":6.0},{"prerequisites":["git_lifecycle_stage_commit_sync","github_repo_management_strategy","structured_prompts_claude_code"],"learning_outcomes":["Create a repeatable bug report that an AI agent can act on","Use a review checklist to catch accidental behavior changes","Decide when to accept, revise, or roll back an AI-generated change using Git/PRs"],"difficulty_level":"intermediate","concept_id":"iterative_debugging_ai_code_review","name":"Iterative debugging and AI code review","description":"Run a tight loop: reproduce an issue, capture evidence, ask for a targeted fix, and validate with tests before merging. Learn PR-based review habits that keep AI changes safe, explainable, and reversible.","sequence_order":7.0},{"prerequisites":["claude_code_permissions_sandboxing","cli_local_dev_navigation"],"learning_outcomes":["Explain why AI API calls typically belong on the backend, not in the browser","Identify the core moving parts of an AI feature: prompts, inputs, outputs, and guardrails","Plan for operational realities: retries, rate limits, logging, and cost monitoring"],"difficulty_level":"intermediate","concept_id":"api_integration_ai_platforms","name":"API integration for AI platforms","description":"Understand the client–server pattern for adding AI features: your app calls your backend, and your backend calls the Claude API using protected credentials. Cover request/response shape, streaming outputs, error handling, rate limits, and basic cost controls.","sequence_order":8.0}],"overall_coherence_score":7.3,"pedagogical_soundness_score":6.2,"prerequisites":["Comfort installing and opening developer tools","Basic ability to navigate folders in your OS","Basic understanding that accounts/keys control access","Willingness to review changes before saving or sharing"],"rejected_segments_rationale":"No additional segments were available to cover most required micro-concepts (filesystem/project layout, CLI navigation, Git lifecycle, GitHub repo management strategy in depth, Claude Code permission/sandbox controls, iterative debugging/PR review habits, and AI API integration fundamentals). As a result, the assembled course cannot reach the requested ~120 minutes or provide comprehensive coverage; it only covers the subset of outcomes supported by the provided segment library.","segment_thumbnail_urls":["https://i.ytimg.com/vi/3aKVArutiIU/maxresdefault.jpg","https://i.ytimg.com/vi_webp/ocQ7ZKhHU5Q/maxresdefault.webp"],"segments":[{"before_you_start":"This segment gives you a working mental model for Claude Code in a real project folder. You’ll learn how to plan work in small steps, set repo-level rules in Markdown, and ask for outputs that are easy to review and roll back.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1773240074/segments/3aKVArutiIU_36_570/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Starting Claude Code from terminal","Local-project workflow (Claude operates on your repo/files)","Model selection for planning vs execution (Opus vs Sonnet)","Structured prompting for project planning and build execution","Repository-level AI rules via claw.md (project memory)","Reusable prompts via prompt.md and @prompt.md execution","Debugging with full-codebase context and screenshots (UI/CSS example)","Task queueing / messaging queue for parallel-like workflow","Plan mode and adjustable reasoning depth (think / think hard / ultrathink)","Sub-agents for multi-perspective planning and delegated implementation","GitHub Actions integration for PR review and security scanning","AI-assisted pull request collaboration via tagging Claude"],"duration_seconds":533.5233529411764,"learning_outcomes":["Start a Claude Code session in a local project and understand that it edits local files (not just chat)","Choose an effective ‘plan then build’ workflow by switching models for planning vs execution","Create a repo ‘AI rules’ file (claw.md) to standardize coding/testing/branching/commit expectations","Create and reuse a stored prompt (prompt.md) and invoke it consistently during development","Use Claude Code for contextual debugging by providing UI evidence (e.g., screenshot) and letting it inspect the codebase","Use queueing to batch multiple small tasks for more efficient AI-assisted development","Request different depths of reasoning (think / think hard / ultrathink) and use plan mode appropriately","Describe how Claude can participate in GitHub collaboration via PR review automation and security scanning"],"micro_concept_id":"structured_prompts_claude_code","prerequisites":["Basic understanding of what a code repository/project folder is","Comfort opening a terminal and running a command","Very light familiarity with Markdown files (what .md means)","Basic idea of what a pull request (PR) is (helpful but not strictly required)"],"quality_score":6.75,"segment_id":"3aKVArutiIU_36_570","sequence_number":1.0,"title":"Turn Intent Into Reviewable Diffs","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"","overall_transition_score":10.0,"to_segment_id":"3aKVArutiIU_36_570","pedagogical_progression_score":10.0,"vocabulary_consistency_score":10.0,"knowledge_building_score":10.0,"transition_explanation":"N/A for first segment"},"url":"https://www.youtube.com/watch?v=3aKVArutiIU&t=36s","video_duration_seconds":596.0},{"before_you_start":"Now that you’ve seen Claude Code operate inside a local repo, you’ll extend that mental model to remote control. The goal is to stay clear on what runs on the host machine, what the phone is controlling, and what limitations still apply.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1773240074/segments/ocQ7ZKhHU5Q_19_353/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Claude Code Remote/Remote Control concept","Handing off an in-progress Claude Code CLI session to the native Claude mobile app","Using the /remote-control command to link a session","Mental model: phone as a controller; computation/tools run on laptop or remote server","Practical constraint: starting new sessions still requires access to the host machine first (as described)"],"duration_seconds":334.32,"learning_outcomes":["Explain what Claude Code Remote/Remote Control does (and does not do)","Use the /remote-control entry point in Claude Code to make a running session accessible on mobile","Describe the correct mental model: Claude Code edits/runs against the host machine environment; the phone is a controller/UI","Anticipate practical workflow constraints (needing to start the session and cd into the project on the host first)"],"micro_concept_id":"claude_code_setup_authentication","prerequisites":["Basic familiarity with what a terminal/CLI session is","Claude Code already installed and working on a host machine (laptop or remote server)","Claude mobile app installed and signed in"],"quality_score":5.575,"segment_id":"ocQ7ZKhHU5Q_19_353","sequence_number":2.0,"title":"Remote-Control Sessions Without Losing Context","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"3aKVArutiIU_36_570","overall_transition_score":7.3,"to_segment_id":"ocQ7ZKhHU5Q_19_353","pedagogical_progression_score":7.0,"vocabulary_consistency_score":8.0,"knowledge_building_score":7.5,"transition_explanation":"Builds on the local-repo Claude Code workflow by extending it to a second interface, while keeping the same core idea: the host session owns the tools and files."},"url":"https://www.youtube.com/watch?v=ocQ7ZKhHU5Q&t=19s","video_duration_seconds":451.0}],"selection_strategy":"Prioritized ZPD=PREREQUISITE needs by selecting the only segment that establishes Claude Code’s local-repo workflow and structured prompting, then optionally extending with the only other available segment to reinforce the “host machine vs interface” mental model. Explicitly avoided vibe-coding philosophy content and kept focus on operational workflow, reviewable diffs, and GitHub/PR security cues where present.","strengths":["Directly targets the learner’s biggest execution misconceptions: local files, diffs, and a repeatable Claude Code workflow.","Emphasizes predictability through repo rules and structured prompting, which supports safer iteration.","Introduces collaboration/security hooks (PR review, scanning cues) without drifting into long framework build-alongs."],"target_difficulty":"beginner","title":"Claude Code and GitHub Workflow","tradeoffs":[],"updated_at":"2026-03-11T14:59:16.527230+00:00","user_id":"google_109686473204119163777"}}