Writing prompts by hand works, but there's a faster way: you can build them with Claude. This guide shows you how to set up a prompt-builder project to make it repeatable.

By the end of this guide, you'll:

  • Create a Claude project dedicated to building prompts.
  • Use a builder instruction that turns your goal into a ready-to-use prompt.
  • Build a personal prompt library you can reuse across conversations.

Note: This builds on How to Write Effective Prompts for Claude (Part 1). You don't strictly need it, since the builder handles the structure. But reading it first helps you understand the two kinds of prompt it produces: framework prompts and wizard prompts.

Why use Claude to create prompts?

Writing a structured prompt from scratch takes time, especially while you're still learning the patterns. Claude can speed this up: you describe what you want, and it asks clarifying questions, works out the structure, and drafts the prompt.

This isn't about outsourcing your thinking. You still decide what the prompt should accomplish. What you skip is the blank text field and the guesswork over which framework fits.

Before you start

  • Plan: a Pro subscription is recommended.
  • Cowork, not Chat: Claude's Cowork mode picks up your project context automatically, including the files in a connected folder. Keep your library as a local .md file and let Claude read and edit it directly.
  • Model: use the latest Opus model and set effort to High.

Set up your prompt-builder project

1. Create a project folder with your library

Your library lives in one local folder. Create a "Prompt Library" folder and put one file inside:

  • The prompt library. Download the starter prompt library (framework and wizard prompts plus reading-level components), or start with an empty .md file.

The builder instruction goes in the project itself (next step), so the folder only needs the library.

2. Create a project connected to the folder

Claude's Projects feature groups conversations around a topic and, in one dialog, connects to a folder on your computer and holds your instructions. Go to Projects and click New project.

Name the project Prompt Builder. Paste the instruction below into Instructions. It tells Claude how to build each new prompt:

<role_and_objective>
You are a world-class prompt engineer. You help me build strong, reusable prompts. Work efficiently – explain only what's needed to understand the next step or the choice of prompt.
</role_and_objective>

<context>
Use the prompt library file in this folder:
- Draw on it for inspiration, and reuse a prompt where it fits.
- If you reuse one, adapt it to my goal and briefly say what you changed.
</context>

<instructions>
- Work with me toward a single, usable prompt.
- Treat the frameworks and the wizard anatomy as tools, not rigid templates.
- Don't make assumptions when information is missing – say what's still needed.
- If missing context can be inferred from the library or my earlier answers, use that before asking new questions.
- If my intent is already clear and the next step is reversible, continue without unnecessary clarifying questions.
</instructions>

<process>
<step_1 goal="Clarify the goal and pick the prompt type">
Ask what I want to achieve, for whom, and in what context. Then decide which kind of prompt fits, and tell me which and why:
- A framework prompt for a one-off task (draft an email, summarize a report, analyze a process).
- A wizard prompt for co-creating a document with me step by step (a problem statement, a plan, a proposal).
</step_1>

<if_framework_prompt>
1. Pick a framework as a starting point (R-T-F, R-A-C-E, R-I-S-E, or D-R-E-A-M) and say why.
2. Ask follow-up questions to fill any gaps. Let my answers shape the prompt; deviate from the framework where that makes it clearer.
3. Draft the prompt with XML tags, one tag per component.
4. Expand where useful: extra context or sources, steps, criteria, output rules (placement, length, structure, reading level).
</if_framework_prompt>

<if_wizard_prompt>
1. Build it from the wizard anatomy:
   - Role – the expertise you take on.
   - Task – the one document we're building.
   - Principles – non-negotiable rules (don't invent facts, label assumptions, ask instead of guess).
   - How to work – step by step, wait for my response after each step, a few questions at a time.
   - Steps – for each: explain the concept briefly, ask, summarize, wait for my confirmation.
   - Output – the shape of the finished document.
   - Stop condition – when to stop.
2. Ask follow-up questions to fill any gaps.
3. Draft the prompt with XML tags.
</if_wizard_prompt>

<both>
Check the prompt for clarity, completeness, and reusability. State explicitly if information is missing – don't make assumptions. Then work my feedback in until we have a single final prompt.
</both>
</process>

<output>
- Deliver the final prompt with XML tags.
- Make sure it works on its own.
- When I approve the final prompt, append it to the prompt library file in this folder. Match the library's format: a short `###` heading, then the prompt in a fenced code block. Don't change or remove the prompts already there.
</output>

Under Local folder, choose the "Prompt Library" folder you just made. Set Visibility to Local so the project stays on your computer and Claude reads the folder as context. Leave Add files empty. The library already lives in the folder.

Note: Connecting the folder can make Claude rename the project to match it. Change the name back to Prompt Builder before you create it.

Then click Create project.

3. Build a prompt

For each new prompt, open a new chat in the project and keep it in Cowork mode. Type:

I want to create a new prompt.

Claude reads the builder instruction and your library, then asks about your goal: what you want, who it's for, and the context. A rough description is enough. In this example, I asked for a brand story built step by step, for the team, drawing on three existing files.

From your answer, Claude picks the prompt type and explains why. Here, it's a wizard prompt, because the brand story is co-created over several turns. It asks a few follow-ups (the story's backbone, what else the document should hold, length, language), then drafts the prompt in XML. Review it, give feedback, and iterate until it matches what you need.

Answer those, and Claude drafts the prompt in XML. Review it, give feedback, and iterate until it matches what you need.

Then test the finished prompt in a fresh chat outside the project, away from the builder instruction and your library. That confirms it works on its own. If it misbehaves, bring your findings back to the project chat and refine.

4. Save the prompt to your library

Once the prompt is final, tell Claude to save it:

Add this to my prompt library, keeping the existing prompts as they are.

Claude appends the prompt to the library file in the folder and confirms where it landed, leaving your existing prompts byte-for-byte unchanged. No copying, pasting, or re-uploading.

Finally, rename the chat so the project stays scannable. A Role / Goal name works well. Here, that's Brand strategist / Brand story. Each chat then reads as the prompt it produced.

Over time your library fills with tested, structured prompts, ready for whatever task comes next.

Tip: Keep the folder in a synced location like iCloud Drive or Dropbox, and your library is backed up automatically.

Share your experience

  • Did using Claude to build prompts change how you think about structuring your instructions?
  • Did the builder pick the right prompt type (framework or wizard) for what you were making?
  • Have you started building a prompt library? What types of prompts are you collecting?

Coming up next?

You now have both kinds of prompt and a builder to create them on demand. Next, you'll start giving Claude lasting context to work from. The first piece is an AI writing system. You'll begin by building personas: the audiences Claude writes for, so every prompt inherits who it's talking to.