Source: wiki synthesis: nate-herk-every-level-of-claude, skills-vs-projects-eliot-prince, cowork-projects-ai-consultant-recipe; September 2026 redesign: raw/AI_News_-The_AI_Slowdown-_What_You_Need_to_Know.md (Matt Wolfe reading Anthropic’s post) and raw/7_Ways_How_We_Use_AI_Is_Changing.md (The AI Daily Brief quoting the Claude account); Cowork projects walkthrough and October merge: raw/How_to_Use_Claude_Cowork_PROJECTS_Correctly_Super_Simple_Walkthrough.md (Eliot Prince, YouTube, https://www.youtube.com/watch?v=1gAE1ebLkTU, 21:41, published 2026-06-15) and raw/Everything_You_Know_About_Claude_Cowork_Is_OUTDATED.md (Eliot Prince, https://www.youtube.com/watch?v=VX2G7De8Oj8, 18:34, published 2026-10-27)

Claude.ai Projects are the per-project context containers in claude.ai — a bundle of custom instructions, uploaded knowledge files, and persistent chat history scoped to a single workspace. They are the spine of serious claude.ai usage at the Beginner-through-Intermediate tier of Nate Herk’s 5-level framework: the cheat code from L1 (Enthusiast, single-turn chat) to L2 is “create your first project.” ^[inferred] The same concept extends into the Claude Cowork desktop app via Import from project, which transfers a Chat Project’s knowledge files and custom instructions into a Cowork Project that can additionally execute files and tasks.

Key Takeaways

  • Projects are nouns. Eliot Prince’s verb/noun mental model: skills are doing words (reusable processes that run anywhere in the Claude ecosystem); projects are things (scoped knowledge containers with overarching instructions and chat history). The linguistic test on any prompt: if you want Claude to know about a specific business / client / workspace, it’s a project.
  • Six features stack on top of Projects at L2. Continuity across conversations + memory & past-chat search + connectors (50+) + file creation + persistent artifacts with API access + inline visuals + Microsoft Office native add-ons. Projects are the surface that makes the rest load-bearing.
  • Token-cost win. Eliot Prince’s operator estimate: Projects can reduce token cost by ~90% in some cases versus re-uploading the same knowledge files in every fresh chat. ^[inferred] Particular leverage for users hitting Claude’s weekly cap on recurring context.
  • Scoped, not portable. Skills run anywhere — claude.ai chat, Cowork, Claude Code. A Project runs inside that one workspace only. This portability difference is the biggest functional consequence of the verb-vs-noun distinction.
  • Memory is free; past-chat search is paid. Per the L2 walkthrough, cross-conversation recall works on every plan including free; past-chat search is Pro-and-up.
  • The 4-knowledge-file architecture is the consultant-tier spec. Business DNA + Client Intelligence Brief (reusable prompt-as-file) + Service Playbook + Consulting Framework. The architectural pattern that makes a Project usable as an “AI consultant,” not just a stocked pantry.
  • September 2026: projects become conversations (beta). Anthropic’s redesign turns a project from a folder of context into one coordinating conversation that routes work to parallel threads, each a Claude Code cloud session on its own branch. It starts in Claude Code for a subset of Pro and Max users; see 2026-09 redesign (beta) below.
  • October 2026: chat and Cowork projects are one kind. Per Eliot Prince’s 2026-10-27 walkthrough, “all of our projects are just projects”: each has a local folder and uploaded context, and scheduled tasks can be attached to it. Before the merge (June 2026), Cowork projects were separate, local-folder copies that did not sync with chat projects. See Cowork projects, June to October 2026 below.
  • Living documents, not chat history. Custom Instructions and knowledge files are framed as documents updated after every engagement. “Fix the instructions, not the chat” — when Claude gets something wrong, update Custom Instructions so it doesn’t happen again.

How Projects work

  • Custom instructions. Overarching house rules — role, behaviour, output standards, knowledge-file routing, guardrails. Discipline rule: instructions here are general guidance only, NOT specific task workflows (those belong in skills).
  • Knowledge files. Documents always referenced in conversations — company info, client lists, ICPs, transcripts, financial breakdowns, templates. Includes the option to store executable prompts as files (e.g., the Client Intelligence Brief), iterated independently of behaviour rules.
  • Persistent chat history. Every conversation in the project files together for retrieval. Forms the long-term memory of decisions and prior work — “what did we decide about the Q2 launch last week?” returns a citation.
  • Sharing model. Project-scoped, not user-scoped — knowledge files, custom instructions, and chat history live inside the project workspace.
  • Cowork bridge. Cowork’s + button → Import from project → search and select a claude.ai Chat Project → choose local folder. Knowledge files and custom instructions transfer; Cowork adds file creation, multi-step execution, dispatch from mobile.

When to use Projects vs Skills vs Cowork Projects

  • Reach for a Project when you want Claude to know about a specific business / client / workspace and accumulate history within it.
  • Reach for a Skill when you want a repeatable process that runs the same way every time, portable across surfaces.
  • Reach for a Cowork Project when the same context needs to also execute files, run multi-step tasks, and be controlled from your phone — the Cowork import is the bridge, not a replacement.
  • The flywheel: run a skill inside a project. The skill brings the general process; the project supplies the specific knowledge. Output flows back as a new knowledge file, compounding the project’s value over time.

Full comparison and decision-test table in skills-vs-projects-eliot-prince.

Cowork projects, June to October 2026

Source: raw/How_to_Use_Claude_Cowork_PROJECTS_Correctly_Super_Simple_Walkthrough.md (Eliot Prince, published 2026-06-15) and raw/Everything_You_Know_About_Claude_Cowork_Is_OUTDATED.md (Eliot Prince, published 2026-10-27). Auto-caption transcripts.

June 2026: separate Cowork projects (historical)

In June, Cowork projects lived in the desktop app’s Cowork tab, ran on folders on your computer, and did not sync with chat projects. That is no longer the layout on merged accounts (next subsection), but the instruction-file and import techniques still apply to folder-backed projects.

  • Three ways to create one (New project, top right):
    • Start from scratch — name it, optionally paste instructions, add knowledge files, and choose a project location. The default is Documents/Claude/Projects; the Documents/Claude folder also holds scheduled tasks and artifacts. Eliot keeps everything in one dedicated Cowork folder so it is easy to find.
    • Import a project — pick a chat project. Its name, custom instructions and knowledge files come across.
    • Use an existing folder — point the project at a folder you already have. It keeps that folder’s own path, outside Documents/Claude/Projects.
  • Instructions are CLAUDE.md files and they layer. Writing folder instructions in the UI saves a CLAUDE.md into that folder. You can also write the file yourself or ask Claude to write it. Project-level instructions apply everywhere in the project; a CLAUDE.md in a subfolder applies only when Claude works in that folder. His example: an ongoing-work/ subfolder whose CLAUDE.md says its files are outputs and must not be used as reference knowledge, while the top-level instructions say where new outputs go.
  • What import misses.
    • Memory doesn’t come across. Copy the chat project’s memory, paste it into a Cowork task and ask “Can you add this information to the memory so we can remember it for later.” Cowork writes a memory.md file.
    • Knowledge files are hidden. An imported project’s folder looked empty in Finder; the files were in a hidden project cache (176 files in his example) and the instructions were in a metadata JSON file. His fix-up prompt: “Can you go and get all of the knowledge base files and custom instructions, Claude.md file, for this project and bring them into the top-level folder so that I can always see all of the knowledge base files instead of having them hidden deep in my computer.”
    • No live sync. Edits in the chat project don’t reach the Cowork copy, and the reverse is also true.
  • Scheduled tasks inside a project. A project can carry recurring tasks that run with its instructions and knowledge and file their output into the project. His example was a weekly communication briefing that reads his Granola meeting transcripts for the past 7 days and writes a one-page report for Monday morning. He set it to act without asking, picked a model, and chose a weekly frequency. In the video he picks Opus 4.8 because “Fable 5 has been discontinued”. That was the June 12 to July 1 suspension recorded in the Fable 5 federal shutdown article; Fable 5 has since returned.
  • Outputs panel. The project view lists recent tasks and the files and dashboards they produced.

October 2026: one projects area

  • All projects are one kind. Chat and Cowork projects were merged into one area and then merged again; Eliot’s October video shows no distinction.
  • Two context sources per project. A Folder on the connected computer (change it with the edit button) and Context uploaded with + → Upload from device, stored on Anthropic’s servers, which works whether the computer is on or off. A project can use both.
  • Chats and tasks file under the project, and scheduled tasks attach to it with the project’s context, skills and memory, on a time or a trigger.
  • What this means for the June techniques. The CLAUDE.md layering still applies wherever a project points at a local folder. Uploading the files a task needs is now the way to make it run when your computer is off.

2026-09 redesign (beta)

Matt Wolfe read Anthropic’s post, “Projects redesigned: from folder to conversation”, on air; he did not have access himself (raw/AI_News_-_The_AI_Slowdown_-_What_You_Need_to_Know.md). Everything below is his reading of that post, not a first-party source.

First-party walkthrough (added 2026-10-30): Anthropic’s narrated video, Getting started with Claude Code Projects (raw/Getting_started_with_Claude_Code_Projects.md), now has its own article: Claude Code Projects. It confirms the points below (one coordinating conversation, a cloud thread per task on its own branch, beta rolling out to Pro and Max) and adds the Threads, Pull requests and Library tabs, threads that open and watch their own PRs, shared thread memory, and the team’s tip to run the coordinator on low effort.

  • Official video. Anthropic posted a 1:23 promo, “Projects are now a conversation with Claude”, on 2026-09-17 (youtube.com/watch?v=5qt_aGyAsKk, raw/Projects_are_now_a_conversation_with_Claude.md). Its transcript is music and cheering with no narration, so it confirms the launch date but adds no mechanics.

  • Setup. Start a project with a goal plus a repo or other context. Claude suggests work it can pick up right away. You configure the project’s cloud environment, connectors, plugins, instructions and model.

  • One conversation directs the threads. You brief the project “the way you’d brief a chief of staff”, and it routes work to new or existing threads. Monitor and steer from the main project chat, or open a single thread to steer it directly.

  • Each thread is a Claude Code cloud session on its own branch and copy of the repo. If two threads touch the same code, the overlap resolves “as a merge conflict just like any other PR.”

  • Who gets it. Beta first for Pro and Max subscribers who use Claude Code cloud sessions and have no existing projects on web or desktop. It expands to more Claude Code users on those plans over the coming weeks, then to all of Claude and to Team and Enterprise. Pro and Max users without access can join a waitlist.

  • Corroboration. The AI Daily Brief quotes the Claude account the same week: “Projects now run from one conversation starting in Claude Code. You describe what needs doing, and Claude directs parallel threads that keep working after you close your laptop.” Boris Cherny: “I stopped managing sessions. I just send thoughts as they come. Claude splits them into threads and the project remembers how I work.” (raw/7_Ways_How_We_Use_AI_Is_Changing.md). NLW notes Cursor shipped the same coordinator-in-one-thread pattern a week earlier.

  • What it changes for this article. The container model above (instructions, knowledge files, chat history) describes claude.ai projects before the redesign. The redesigned version adds an execution layer on top, so the project-vs-Cowork-project split in the previous section may collapse once it reaches claude.ai.^[inferred] The same week’s chat/Cowork merge is covered in Claude Cowork.

Futurepedia field notes (April to August 2026)

Source: raw/Full_Claude_Tutorial_-_Beginner_to_Advanced_in_19_Minutes.md (2026-04-08), raw/The_3_Most_Powerful_Claude_Features_Beginners_Don_t_Know_About.md (2026-05-13), raw/Understand_the_FULL_Claude_Ecosystem_in_One_Video.md (2026-06-24), raw/Use_Claude_Better_Than_99%_of_People_Beginner_to_Pro.md (2026-08-16). Futurepedia, YouTube; series summary in The Claude Ecosystem in Four Layers (Futurepedia).

  • Leave account-level instructions blank. Futurepedia calls the common advice to fill in the “about you” and preference fields “bad advice” for anyone who uses Claude across topics, because no single instruction set fits everything. He writes instructions per project instead.
  • Projects are walled off, and that is useful. A project remembers what happens inside it; other projects and plain chats do not see it. He keeps a project per work stream (business, YouTube, health, family) and asks one-off questions outside projects. “Probably 90% of my chats are in projects.”
  • Good first candidates (April 2026): work with reference material you reuse, consistent requirements for how Claude should answer, or chats you want to find again. Start with two or three. The project description does not change how it works.
  • Review project memory now and then. Project memory updates on its own about once a day. Futurepedia’s memory kept saying he was still working on videos he had already posted, because he never told it they were done; he told Claude to delete that section.
  • Projects store knowledge, skills perform tasks. His April phrasing: “Projects are persistent, reusable knowledge. Skills are persistent, reusable processes.”
  • June 2026 state (historical): chat projects and Cowork projects worked the same way but did not sync, and a chat project could be imported into Cowork. That split has since gone (see Cowork projects, June to October 2026, above).

Nested sessions or projects (Robo Nuggets, 2026-10)

Jay (Robo Nuggets, “Use Claude 2.0 better than 99% of people”, https://www.youtube.com/watch?v=yMnFHFf43Qg, raw/Use_Claude_2.0_better_than_99%_of_people_11_BIG_Updates.md) compares redesigned projects with nested sessions in the desktop Code tab, where a session starts sub-sessions that report back to it. Full walkthrough: The Revamped Claude Desktop App.

  • Where it runs. Projects run in Anthropic’s cloud and keep working when you close the device; nested sessions run on your computer and stop when it sleeps. Anthropic’s walkthrough adds that you can ask Claude to run a single project thread on your computer when a task needs local files or tools (Claude Code Projects).
  • Context. Nested sessions use your local skills, files and tools directly. A project needs them added first; he asks Claude to collect them from the computer while it is awake. Business files uploaded to a project go to Anthropic’s servers.
  • Shared memory and overview. A project’s custom memory applies one rule to every session in it, and its overview page shows what is done, in progress and waiting on you.
  • Access as of his video. Projects are still rolling out: beta on Pro and Max, found under “More” in the sidebar, otherwise via the waitlist. Nested sessions work on any plan. This matches the staged rollout in the section above.
  • His rule of thumb. Work that needs your computer, or that you want kept local: nested sessions. A large, ongoing job that should run while you are away: a project.

Simon Scrapes field notes (2026-09 to 2026-10)

Source: raw/Anthropic_Just_Built_It_s_Own_Agentic_OS.md (Simon Scrapes, https://www.youtube.com/watch?v=afVpjeoQF2I, 8:24, uploaded 2026-09-18; no access yet, reading Anthropic’s video and docs) and raw/The_New_Claude_Is_Quietly_Incredible_17_Best_Features.md (https://www.youtube.com/watch?v=KjuANoI8HDw, 8:40, uploaded 2026-10-28; hands-on). Both promote his paid Agentic Academy.

  • His framing (September). The redesign is Anthropic building what people hand-built as an “agentic OS”: an orchestrator that delegates to threads, each thread loaded with the project’s repos, files, instructions and a memory.md that carries decisions across threads, plus a Library tab for files added and produced.
  • Retrieval behind large projects (as he read it, untested). When project knowledge nears the context limit, Claude gets a project knowledge search tool and pulls only the parts a question needs, with no setup; under the limit it loads everything again. He calls it an MVP version of the retrieval in third-party memory systems.
  • Sharing for Team and Enterprise (as he read it). Project permission levels: view-only or edit, shared by email or organization-wide. He calls this the first step toward a team operating system and the “least finished” part.
  • Hands-on, October. One message (“plan this week’s video, draft the Skool post, write three LinkedIn hooks”) in his copywriting project started three threads, shown as cards under the message, each with its own plan checklist. The main conversation could report where every thread was without opening them and stayed uncluttered because the detail sits in the threads. A correction made in one thread reached later threads through project instructions and memory.
  • What changed between his two videos. In September he listed three gaps: Claude Code only, cloud only, and the main conversation can’t use connectors. By late October the first two were fixed (projects in chat; a thread can run on your computer when it needs local files); the main conversation still hands connector work to a thread.
  • Two cautions. Every thread defaults to Opus on high effort, which uses limits fastest, so check project settings first. Cloud threads don’t load the skills and settings on your computer; turn skills on in your Claude account so threads get them.
  • Session features from the same October tour: side chats (three-dot menu; a pane that can read the main chat up to that point, sends nothing back unless you ask, and can be saved), an in-chat to-do list, environment / context / connectors / outputs cards beside the chat (the context card has a compact button; the environment card has the Remote Control switch), sidebar sections for sorting chats, split view (drag a chat into the current one), a files pane you can edit in, a built-in browser, and Ctrl+O to switch between normal and verbose thinking. Docs, Slides and Design left beta in October on every plan including free; Dashboards are beta on paid plans (Claude Docs and Slides, Dashboards and Motion).
  • Where he still uses his own system. Bigger builds that need long-term decisions and memory he controls stay in his Agentic OS; most focused jobs now run in a project.

Open Questions

  • Does the redesigned project keep knowledge files and custom instructions as they work today, or do repo and connector context replace them? Matt’s reading of the post lists instructions but not knowledge files.
  • Does the October merged project (folder + context) carry over a June-style Cowork project’s hidden cache, or do imported knowledge files still need surfacing by hand?
  • How will existing web and desktop projects migrate? The beta excludes anyone who has them, and no migration path is described.

Try It

  1. Pick one recurring context you keep re-explaining to Claude — a client, a side hustle, a research thesis. Create a Project, load 3-5 knowledge files, write 5-10 lines of Custom Instructions (role + behaviour + output rules).
  2. Run the same prompt twice — once in a fresh chat, once inside the Project. Compare quality and the time spent re-explaining context. The delta is the Project’s leverage.
  3. Bring it into Cowork. Open Claude Desktop → Cowork → Projects → Import from project → pick the one you just built. Now the same brain can also write files and run multi-step tasks on your local folder. On a merged account (October 2026) there is only one projects area: attach a local folder to the project instead, and keep the uploaded context for anything that must work when your computer is off.
  4. Layer one CLAUDE.md. Add a subfolder for outputs with its own CLAUDE.md saying those files are not reference material, and check that new work lands there.