Projects & Artifacts

Claude's Projects and Artifacts features help you organize and act on work more effectively than a single freeform chat.

Projects. A Project groups related conversations under one roof, with shared context that persists across every chat inside it. You can attach reference files, write custom instructions specific to that project, and start as many conversations as you need — each one automatically has access to the project's shared materials. This is especially useful for ongoing work like writing a book, managing a codebase, or running a research effort, where re-explaining context every time you open a new chat would be wasteful.

Artifacts. When Claude generates a substantial, self-contained piece of content — a block of code, a document, an HTML page, a diagram — it can render that content in a separate panel next to the conversation instead of inline in the chat. This "artifact" stays interactive: you can ask Claude to revise it, and the panel updates in place while your conversation history stays clean and readable. Artifacts are especially useful for code you intend to keep iterating on, since you don't have to scroll back through chat history to find the latest version.

Working together. Projects and Artifacts complement each other: a Project gives you a stable home base with shared context, while Artifacts give you a clean workspace for any single deliverable you're actively building within that project. Understanding when to reach for a Project versus a single conversation, and how Artifacts keep long-running work organized, is core to using Claude efficiently for real tasks rather than one-off questions.

Practical use. A common pattern is starting a Project for a recurring area of work — say, a specific codebase or an ongoing writing project — uploading the relevant reference material once, and then returning to that Project repeatedly over days or weeks. Every new conversation inside it starts with full context already available, without you needing to re-upload files or re-explain background each time. Combined with Artifacts for any individual deliverable you're iterating on, this pairing turns Claude from a single-conversation tool into something closer to an ongoing workspace for real, sustained projects.

Setting up a Project well. The value you get from a Project depends heavily on what you put into it. Two inputs matter most: the reference files you attach and the custom instructions you write. Good reference files are the documents you would otherwise find yourself pasting into chats repeatedly — a style guide, a product specification, meeting notes, a summary of decisions already made. Good custom instructions describe how you want Claude to behave in every conversation inside the project: the audience it is writing for, the conventions to follow, the tone to use, and anything it should always or never do. A few minutes spent writing clear project instructions pays off across every conversation that follows.

Curate rather than dump. A tempting mistake is to attach everything even loosely related to the work. In practice, a smaller set of well-chosen, current documents produces better results than a large pile of overlapping or outdated ones, because it is clearer which source should win when documents disagree. When a project's reference material changes — a spec is revised, a decision is reversed — updating the attached files keeps every future conversation grounded in the current truth rather than the old one.

One project per stream of work. Projects work best when each one maps to a single ongoing effort with its own context: one per codebase, one per book, one per client, one per research question. Mixing unrelated work into a single project dilutes the shared context and makes custom instructions harder to write, since instructions that suit one kind of task may be wrong for another. Creating a new project is cheap; untangling a mixed one is not.

Iterating on Artifacts. Because an artifact updates in place, you can treat it as the single live version of whatever you are building. Ask for a revision in plain language — tighten this section, rename that function, make the layout two columns — and the panel reflects the change while the conversation stays a readable record of what you asked for and why. This is a very different rhythm from scrolling back through chat history comparing near-identical pasted versions, and it is the main reason artifacts suit work you expect to refine over multiple rounds rather than accept on the first pass.

When a plain conversation is enough. Not everything needs this machinery. A one-off question, a quick explanation, or a task with no reusable context is perfectly served by a normal chat. The judgment to develop is simple: if you expect to come back to this work, or you are already re-explaining the same background a second time, that is the signal to promote the work into a Project — and if you are about to iterate on a single self-contained deliverable, that is the signal to have Claude build it as an artifact.

The bigger picture. Together, these two features mark the difference between using an AI assistant as a question-answering box and using it as a workspace. The Project holds the durable context; each conversation inside it handles one thread of the work; each artifact holds one evolving deliverable. Learning that division of labor — and forming the habit of setting up a Project the moment work becomes recurring — is one of the most practical skills for getting sustained, real-world value out of Claude.