CHAPTERS
- 0:00 – 0:20
Claude Code Projects in action: parallelizing a big goal
The video opens with a demonstration of how Claude can take a large objective and break it into smaller tasks automatically. Instead of the user managing multiple sessions or worktrees, Claude coordinates parallel work through a single project conversation.
- •Claude decomposes a large goal into smaller tasks automatically
- •Work is coordinated without the user managing sub-agents or multiple sessions
- •Claude assigns tasks to parallel execution as part of a project workflow
- 0:20 – 0:30
What a Project is: one coordinator conversation + multiple task threads
This chapter defines a project as one ongoing “main conversation” where Claude coordinates work. Each task becomes a separate thread, enabling structured parallel progress toward a shared goal.
- •A project is a single, ongoing coordinating conversation
- •Claude creates a thread for each task you provide
- •Threads let multiple workstreams progress in parallel under one umbrella
- 0:30 – 0:44
How threads work: independent sessions, branches, and cloud continuity
Threads are described as independent Claude Code sessions running on their own cloud branches. This allows work to continue even when you’re away, while still giving you the option to run tasks locally when needed.
- •Each thread is its own session on its own branch in the cloud
- •Work continues even if you close your laptop; you can check in from anywhere
- •Threads can be moved to run on your computer when local files/tools are required
- 0:44 – 1:00
When to use Projects: large goals across sessions and repos
The video outlines the best fit for projects: big, multi-step initiatives that would normally span many sessions, possibly across multiple repositories. Examples include migrations and coordinated API changes across platforms.
- •Use projects for goals that span many sessions
- •Projects can coordinate work across multiple repos
- •Example use cases: dependency migrations; updating an endpoint across API/web/mobile
- 1:00 – 1:22
Setting up a new project: name, goal, and repo/folder context
Here the walkthrough shows how to create a new project from the Code tab and provide Claude with the essential context. You specify a project name, the goal to work toward, and the relevant repositories or folders.
- •Create a new project from the Code tab (desktop/web)
- •Provide a project name and a clear goal
- •Attach relevant repos or folders so Claude has the right context
- 1:22 – 1:31
The main conversation: giving tasks, using suggestions, reviewing findings
After creation, you land in the main conversation where you can choose suggested next steps or provide your own task list. Claude can explore the codebase and report back, helping you align on what to do before spinning up threads.
- •Main conversation is the control center for the project
- •You can use Claude’s suggestions, ask questions, or provide a task list
- •Claude can explore repos and return findings to guide next actions
- 1:31 – 2:01
Working with threads: monitoring progress, steering, and pausing work
Once you agree on tasks, Claude creates a thread per task and you can mostly let them run independently. You can also open a thread card to watch progress, give direction inside the thread, or stop a task.
- •Claude creates one thread per agreed-upon task
- •Threads can run with minimal supervision, but remain inspectable
- •You can steer via thread chat, follow progress, or stop a thread
- •Threads tab shows which threads are waiting on you
- 2:01 – 2:31
Pull requests lifecycle: auto-PRs, CI fixes, and review comment handling
When a thread produces concrete code changes, it can open a pull request automatically or on request, then continue to monitor it. Claude can respond to CI failures and reviewer feedback, surfacing next steps back in the main conversation.
- •Threads can open PRs automatically or when you ask
- •Claude monitors PRs and iterates when CI fails
- •Claude addresses review comments and keeps the PR moving
- •Pull Requests tab shows all PRs and statuses; you can ask Claude to merge
- 2:31 – 3:02
Artifacts and the Library: shared project outputs and reusable context
Projects support artifacts like reports that summarize changes and results (e.g., performance before/after metrics). These artifacts live in the Library, which acts as a shared folder accessible to every thread and can include user-added files like specs or mockups.
- •Artifacts capture outputs like summaries and metric reports
- •Library tab stores artifacts and any files you add (e.g., design specs)
- •Library is shared across all threads for continuity
- •Artifacts can be updated in future work using the stored context
- 3:02 – 3:32
Connecting external services: monitoring-driven routines and auto-investigation
The video shows integrating Claude with an external monitoring service so it can read real user metrics directly. You can then schedule a daily routine that checks for regressions and automatically opens an investigation thread when issues appear.
- •Connect Claude to monitoring services to access real user metrics
- •Set up a daily routine to check for performance regressions
- •If a regression is found, Claude opens a new investigation thread
- •Issues will be waiting in the project next time you check in
- 3:32 – 4:02
Tips: manage usage with models and effort levels
Because projects can run multiple threads concurrently, they can consume plan limits faster than a single session. The recommended approach is to keep the coordinator low effort and use smaller models by default for well-scoped thread tasks, upgrading only when needed.
- •Projects may use plan limits faster due to parallel threads
- •Adjust model and effort level in project settings to manage usage
- •Keep the coordinator on low effort since it mostly routes work
- •Use smaller models for scoped tasks; switch up for complex thread work
- 4:02
Tips: instruct coordination style and leverage shared memory across threads
You can specify how Claude should coordinate work, such as concurrency, update frequency, and requiring a plan before execution. Threads also share memory, letting you store preferences for future threads and edit that memory in project settings.
- •Tell Claude coordination preferences (thread count, update cadence)
- •Ask Claude to show a plan before starting work
- •Threads share memory for consistent preferences across tasks
- •Edit shared memory and preferences in project settings
Wrap-up: when to try projects + beta availability
The video closes by encouraging viewers to use projects for ambitious goals that don’t fit in a single session. It notes that Claude Code Projects are in beta, rolling out to Pro and Max plans, with documentation available for deeper learning.
- •Use projects when the goal is bigger than one session
- •Provide the goal, let Claude split into threads, and check in as needed
- •Projects are in beta and rolling out gradually to Pro/Max
- •Docs are available via the link for more details
