By task · Free prompt pack

Claude Prompts for Work: 46 Prompts for Projects, Artifacts, Files and Claude Code

46 free Claude prompts for long documents, Projects, artifacts, file creation, thinking settings and Claude Code. Copy, fill the variables, paste.

Prompts
46
Works with
Claude
Updated
Price
Free to copy

This pack is organised around what you are trying to do with Claude. Four of its sections lean on things that exist in Claude itself: Projects with instructions and knowledge, artifacts, file creation for spreadsheets, documents and chart images, and Claude Code with its CLAUDE.md files, plan mode and subagents. The first section follows Anthropic's long-context guidance, with documents first inside tags and the question last. The short last section is about the effort and thinking settings.

There are 46 prompts in six sections. You will find a quote-first way to question a long report, a read check that catches a partly loaded upload, a Project hand-off note, a calculator and a deck built as artifacts, a cleaned workbook that proves its row counts, a prompt for planning a code change before any edit, and a triage that tells you which tasks deserve more effort.

Everyday jobs such as emails, reports and plans are covered in our role packs, and our coding pack holds general code prompts that work in any model. Where a prompt needs a plan, a setting or a menu, the instructions say so and point to Anthropic's help page, because plans and menus change. We have not named a model version. Fill the variables, keep the tags as they are, and check anything that matters before you rely on it.

Long Documents, Uploads & Images

Claude takes long documents, attached PDFs, image files and batches of uploads. The first four prompts use the long-context layout from Anthropic's prompting guide: documents first inside tags, the question last, and quotes pulled out before the answer. They cover a single document, a comparison of two, contradictions across three, and a cited summary. The rest handle attached material: charts in a PDF, charts and photos, an index of a batch of uploads, and a read check that catches a file Claude only partly saw.

Quote-First Answer From a Long Document

Best for: Grounded answers from long reports, contracts and papers

<document>
<source>{{DOCUMENT_NAME}}</source>
<document_content>
{{DOCUMENT_TEXT}}
</document_content>
</document>

My question about the document above: {{QUESTION}}

Work in two steps.
Step 1: find the passages that bear on the question and copy them word for word into <quotes> tags. After each quote, give the section heading or page number if the text shows one. If nothing is relevant, write "No relevant passage" inside the tags and stop.
Step 2: answer in <answer> tags in no more than {{MAX_WORDS}} words, using only what is inside your <quotes>. Start each sentence with a label: Stated (the quote says it directly), Inferred (it follows from a quote; show how in a few words), or Not covered (the document is silent). Use no knowledge from outside the document, and if the question cannot be answered from it, say what is missing instead of guessing.

Fill in: DOCUMENT_NAME DOCUMENT_TEXT QUESTION MAX_WORDS

Documents go first and the question last, with quotes before the answer: the layout in Anthropic's long-context guidance. Or attach the file and delete the document block. Spot-check each quote.

Run in ChatGPT Run in Claude Run in Gemini Prompt page
Example output · Claude (example written by The Prompt Index)
Inputs used: DOCUMENT_NAME = Maple Court tenancy agreement (extract). DOCUMENT_TEXT = "Clause 4 Rent. Rent is 1,050 pounds per calendar month, payable in advance on the 1st. Clause 7 Deposit. A deposit of 1,200 pounds is held in a government-approved scheme. Clause 9 Notice. The tenant may end the tenancy after the fixed term by giving one month's written notice." QUESTION = What notice must I give to leave after the fixed term, and is there any penalty? MAX_WORDS = 60.

<quotes>
"The tenant may end the tenancy after the fixed term by giving one month's written notice." (Clause 9, Notice)
</quotes>

<answer>
Stated: After the fixed term, the tenant must give one month's written notice to end the tenancy (Clause 9). Not covered: whether any penalty applies, because the quoted clause says nothing about one; check the full agreement.
</answer>

Compare Two Documents Against One Decision

Best for: Side-by-side comparison of two long documents

<documents>
<document index="1">
<source>{{DOCUMENT_A_NAME}}</source>
<document_content>
{{DOCUMENT_A_TEXT}}
</document_content>
</document>
<document index="2">
<source>{{DOCUMENT_B_NAME}}</source>
<document_content>
{{DOCUMENT_B_TEXT}}
</document_content>
</document>
</documents>

I must make this decision: {{DECISION}}. Compare the two documents above for it.

First, inside <quotes> tags, copy the passages from each document that bear on the decision, labelled by document index. Then build a table with the columns Topic, Document 1 says, Document 2 says, and Exact words (the quote that supports the row). Include only topics that appear in at least one document. Write "silent" where a document says nothing; never assume it agrees or disagrees.

Finish with the three differences that matter most for the decision, ranked, and one question I should put to the author of each document. Use nothing from outside the two documents, and do not recommend a winner unless the documents alone justify it.

Fill in: DOCUMENT_A_NAME DOCUMENT_A_TEXT DOCUMENT_B_NAME DOCUMENT_B_TEXT DECISION

Works for two quotes, offers, policy versions or proposals. Keep both documents in the same message, above the decision.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Find Contradictions Across Three Documents

Best for: Reconciling several documents that should agree

<documents>
<document index="1">
<source>{{DOCUMENT_A_NAME}}</source>
<document_content>
{{DOCUMENT_A_TEXT}}
</document_content>
</document>
<document index="2">
<source>{{DOCUMENT_B_NAME}}</source>
<document_content>
{{DOCUMENT_B_TEXT}}
</document_content>
</document>
<document index="3">
<source>{{DOCUMENT_C_NAME}}</source>
<document_content>
{{DOCUMENT_C_TEXT}}
</document_content>
</document>
</documents>

Read all three documents and list every place where they disagree about a fact, figure, date, name, responsibility or commitment.

For each disagreement give: a short label; the exact quote from each document involved, tagged by document index; whether it is a true conflict or could be explained by a different date, scope or definition; and which source I should check first and why.

Put the list in <conflicts> tags, most serious first. After it, add <not_conflicts> tags listing near-misses that look like disagreements but are not, with one line of reasoning each. If you find no conflicts, say so; do not stretch to produce one.

Fill in: DOCUMENT_A_NAME DOCUMENT_A_TEXT DOCUMENT_B_NAME DOCUMENT_B_TEXT DOCUMENT_C_NAME DOCUMENT_C_TEXT

Good for a contract plus its amendments or three drafts of a report. Check that none was cut off when you pasted.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Cited Summary Using Document Numbers

Best for: Summaries where every sentence can be traced

<documents>
<document index="1">
<source>{{DOCUMENT_1_NAME}}</source>
<document_content>
{{DOCUMENT_1_TEXT}}
</document_content>
</document>
<document index="2">
<source>{{DOCUMENT_2_NAME}}</source>
<document_content>
{{DOCUMENT_2_TEXT}}
</document_content>
</document>
</documents>

Summarise the two documents above for {{AUDIENCE}} in no more than {{WORD_LIMIT}} words.

Rules for the summary:
- Every factual sentence ends with a citation in the form [doc 1] or [doc 2], plus a short quoted fragment of up to eight words, for example [doc 2: "revised the launch plan"].
- If both documents support a sentence, cite both.
- Leave out any claim you cannot attach to a quote.
- Open with a one-sentence bottom line, then three to five short paragraphs.

After the summary, list in <left_out> tags the most important things in the documents that did not fit the word limit, so I can decide whether to ask for them.

Fill in: DOCUMENT_1_NAME DOCUMENT_1_TEXT DOCUMENT_2_NAME DOCUMENT_2_TEXT AUDIENCE WORD_LIMIT

The citations let you check any sentence in seconds. Keep the documents above the instructions.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Read the Charts and Tables in an Attached PDF

Best for: Reading figures and tables from a PDF with visuals

I have attached a PDF titled {{DOCUMENT_TITLE}}. My focus is: {{FOCUS_QUESTION}}.

Before you analyse anything, tell me what you can actually see. In <inventory> tags, list the charts, tables and figures on {{PAGE_RANGE}} with their page numbers, titles or captions, and types. If you can read only the text and not the visuals, say so now and stop.

Then, for each item that bears on my focus:
- Copy its numbers into a table with the page number. Where you are reading a value off a chart rather than from printed figures, mark it "approx" and give the range you are reading.
- State what the item shows in one sentence, using only what is on the page.

Finally, in <answer> tags, answer my focus question. Separate what the document states from what you infer from the visuals, and list any figure you could not read clearly so I can check it against the original.

Fill in: DOCUMENT_TITLE FOCUS_QUESTION PAGE_RANGE

Attach the PDF instead of pasting. Claude analyses text and visuals only for PDFs of 100 pages or fewer and reads text only in longer ones (Anthropic's upload page, checked 28 Oct 2026). Split a long PDF if you need its charts read.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Read a Chart or Photo and Answer a Question From It

Best for: Answering a question from a chart or photo

I have attached an image of a chart, graph or photographed page: {{IMAGE_DESCRIPTION}}. The question I need answered from it is: {{PURPOSE}}.

Work in this order.
1. In <what_i_see> tags, describe the image in plain terms: what kind of image it is, the title or labels, the axes or column headings, and the units. Say if any part is blurred, cropped or too small to read.
2. In <transcription> tags, copy out the data you can read as a table. Use exactly what is printed. Where a number is hard to read, write it with a question mark, for example "4?7", rather than choosing a digit. Where you are estimating a value from the height of a bar or position of a line, mark it "approx".
3. In <answer> tags, use the transcription to do the job I described. Do not rely on anything not visible in the image.
4. In <check_me> tags, list the cells or values I should verify against the original, most uncertain first.

If the image is too poor to read reliably, tell me what a better capture would need, instead of guessing.

Fill in: IMAGE_DESCRIPTION PURPOSE

Crop to the relevant area before uploading, and check every transcribed number. Supported image types are listed on Anthropic's upload page.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Index Everything I Have Uploaded to This Chat

Best for: Taking stock of a batch of uploaded files

I have attached several files to this chat for one purpose: {{OVERALL_GOAL}}.

Before doing any analysis, build an index. In <file_index> tags, give a table with one row per attached file and these columns: File name, Type, What it is (one sentence), Date or version if the file shows one, Length (pages, rows or approximate words), and Read status (read fully, read in part, or could not read, with the reason).

Then, in <overlaps_and_gaps> tags, tell me: which files overlap or duplicate each other; which files conflict with each other, with a pointer to where; and what is missing from the set that the goal would need.

Finally, in <reading_order> tags, propose the order in which you would work through the files for my goal, and say which one file you would start with. Do not start the analysis yet. Wait for my go-ahead. If a file could not be read or looks cut off, say so plainly in the index.

Fill in: OVERALL_GOAL

Use it right after uploading a batch; it shows at once if a file did not load properly. Check Anthropic's upload help page for current limits.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Prove You Read the Whole Document First

Best for: Catching truncated or partly read uploads early

I have attached or pasted a long document: {{DOCUMENT_NAME}}. Before I ask you anything about it, confirm that you have the whole thing.

In <read_check> tags, give me:
1. The first heading or first sentence, and the last heading or last sentence, exactly as they appear.
2. The number of top-level sections you can see, listed by title.
3. Two short quotes, word for word, from the middle of the document, with the section each is in.
4. Whether you can see the document's charts, tables and images, or only its text.
5. Any place where the text seems to be missing, truncated, repeated or garbled.

Then ask me for {{FOCUS_AREA}} and tell me in one sentence how you would approach it. Do not start analysing until I reply. If anything in the read check does not match what I know is in the document, say so plainly and ask me to re-upload it or paste the missing part.

Fill in: DOCUMENT_NAME FOCUS_AREA

Run this before relying on any analysis of a large upload. Item 4 matters because visuals are read only in PDFs of 100 pages or fewer.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Projects, Instructions & Knowledge

A Claude Project has its own instructions, knowledge files and chats, and Anthropic's help page says context is not shared between chats unless it is saved in the knowledge. These prompts decide what belongs in instructions and what in knowledge, turn raw notes into clean knowledge files, brief you on what Claude can see at the start of a chat, test and refresh the knowledge, write hand-off notes, resume work through chat search, and onboard a colleague to a shared project.

Decide What Goes in Instructions vs Knowledge

Best for: Planning a Project's structure before uploading

I am building a Claude Project for: {{PROJECT_PURPOSE}}.

Here is everything I could add to it:

<material>
{{MATERIAL_LIST}}
</material>

Sort each item into one of three places:
1. Project instructions: short, standing rules that should shape every reply in the project.
2. Project knowledge: reference files Claude should consult when relevant.
3. Leave out: things that are noisy, outdated, duplicated or too sensitive to upload.

Present the result as a table with the columns Item, Where it goes, and Reason. Add a fourth column, Prep needed, where an item needs trimming, renaming or splitting before upload.

Afterwards, in <risks> tags, point out any item that contains personal data, credentials or confidential client details, and say what to remove first. Then draft the project instructions from the items you placed there, in under 250 words, as positive instructions with a short reason for each.

Fill in: PROJECT_PURPOSE MATERIAL_LIST

Instructions go in the project's instructions box (Set project instructions); reference files go in project knowledge. Paid plans switch to retrieval mode as knowledge nears the context limit, so check your plan.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Prepare Notes as Clean Project Knowledge Files

Best for: Turning messy notes into searchable knowledge files

Below are my raw notes on {{TOPIC}}. I will upload them to a Claude Project as knowledge files.

<raw_notes>
{{RAW_NOTES}}
</raw_notes>

Reorganise them into {{FILE_COUNT}} separate, self-contained files that Claude can search and quote reliably. For each file give:
- A clear file name with no spaces.
- A first line stating what the file covers and the date or version if the notes give one.
- Content under descriptive headings, so each section makes sense without the rest of the file.
- Duplicates merged. Where two notes conflict, keep both and mark the conflict with [CONFLICT] rather than choosing silently.

Do not add facts that are not in my notes. Put each file in its own <file name="..."> tags. After the files, list in <gaps> tags anything the notes mention but never explain.

Fill in: TOPIC RAW_NOTES FILE_COUNT

Self-contained sections with clear headings suit retrieval over large knowledge sets. Review the files before uploading.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Kick-Off Chat: Brief Me on the Project Knowledge

Best for: Starting a project chat with a check on what Claude can see

Before we start any work in this project, read everything in the project knowledge and instructions and report back. Do not begin the task yet.

In <report> tags, give me:
1. A list of the files you can see, with one line on what each contains.
2. Any conflicts or overlaps between files, with the file names.
3. The three things in the knowledge that matter most for this first task: {{FIRST_TASK}}.
4. What you would need that is not in the knowledge.
5. How you will treat the project instructions if they clash with something I say in chat.

If you cannot see any files or any instructions, say so clearly instead of guessing what they might contain. Then wait for my go-ahead.

Fill in: FIRST_TASK

Send this as the first message of a new chat in a Project. It shows exactly what Claude can see, since chats in a project do not share context unless it is saved in the knowledge.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Test My Project Knowledge With Five Questions

Best for: Auditing what a Project knows and does not know

I want to check how well this project's knowledge supports the work I plan to do: {{PLANNED_WORK}}.

Step 1: write five questions that someone doing that work would realistically ask, ranging from an easy lookup to one that needs two files combined.
Step 2: answer each using only the project knowledge. For each answer give the file name and the quote you relied on. If an answer needs more than one file, name them all and say whether you saw each one in full or only in extracts.
Step 3: for any question you could not answer fully, write "Not in project knowledge" and say which document or fact would fix it.

Put the results in a table with the columns Question, Answer, Source file and quote, and Confidence (high, medium or low, with a reason for anything below high). After the table, list in <priority_additions> tags the three additions that would improve the project most, and any file that looks outdated.

Fill in: PLANNED_WORK

Use it after you first upload files and again after you update them. The gaps it finds are your next to-do list for the knowledge base.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Write a Hand-Off Note to Save Into the Project

Best for: Carrying decisions from one project chat to the next

We have made progress in this chat on {{WORKSTREAM}}. Chats in a project do not share context with each other unless it is saved in the project knowledge, so write a hand-off note I can save there.

Write it for a future chat that has not seen this conversation. Use these tags:
<decisions> what we decided and the reason, one line each </decisions>
<current_state> what is done and what is in progress </current_state>
<open_questions> what is unresolved and who could answer it </open_questions>
<constraints> rules, preferences or limits I stated that must carry forward </constraints>
<next_step> the single most useful first message for the next chat </next_step>

Use only what was said or produced in this chat. Start the note with a title line and the heading "Date: " followed by the word UNKNOWN, which I will replace. Keep it under 300 words, and mark anything you are unsure about with [CHECK].

Fill in: WORKSTREAM

Save the note as a text file in project knowledge. Context is not shared between chats in a project unless it is saved there (Anthropic's Projects help page).

Run in ChatGPT Run in Claude Run in Gemini Prompt page
Example output · Claude (example written by The Prompt Index)
Inputs used: WORKSTREAM = the autumn newsletter for Hillside Bakery. What was said in the chat: we agreed to send monthly on the first Tuesday; the tone is friendly and uses British spelling; each issue stays under 300 words; issue 1 is drafted; issue 2 has an outline only; we have not decided whether to include recipes, and Sam needs to confirm.

Hillside Bakery newsletter: hand-off note
Date: UNKNOWN

<decisions>
- Send monthly, on the first Tuesday of the month.
- Friendly tone, British spelling.
- Keep each issue under 300 words.
</decisions>

<current_state>
- Issue 1: drafted.
- Issue 2: outline only.
</current_state>

<open_questions>
- Whether to include recipes. Sam needs to confirm.
</open_questions>

<constraints>
- Under 300 words per issue.
- Friendly tone and British spelling.
</constraints>

<next_step>
"Here is the outline for issue 2. Draft it in the agreed tone, under 300 words, and leave a placeholder where a recipe would go until Sam confirms."
</next_step>

Pick Up Where We Left Off Using Chat Search

Best for: Resuming earlier work without re-explaining it

Search our past chats for the conversation about {{TOPIC}} and help me continue.

Report back in <found> tags with each relevant chat you find: its title and date only if the search result shows them, otherwise write "not shown", and a two-sentence summary of what was decided or produced. Then, in <state_of_play> tags, give the decisions made, the open items, and any files or drafts mentioned.

If you cannot find a relevant conversation, say so plainly. Do not reconstruct one from general knowledge. If several chats look relevant, tell me which one you think is most recent and what makes you think so, without inventing a date.

Finally, suggest the single most useful next step and ask me whether to take it.

Fill in: TOPIC

Past-chat search is listed for paid plans, can be switched off in Settings, and never searches incognito chats (Anthropic's chat search article). Claude cites the chats it used, so open them to confirm.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Spot Stale Files in Project Knowledge

Best for: Keeping a Project's knowledge current

I keep these files in a Claude Project for {{PROJECT_PURPOSE}}.

<knowledge_files>
{{FILE_LIST_WITH_DATES}}
</knowledge_files>

Here is what has changed recently in my situation: {{WHAT_CHANGED}}.

Look at the knowledge files you can see in this project, together with the list above. In <audit> tags, give a table with the columns File, Likely status (current, possibly outdated, outdated, or cannot tell), Evidence (a short quote from the file or from my change description), and Suggested action (keep, update, replace, split or remove).

Then, in <contradictions> tags, list pairs of files that disagree, with a quote from each. In <replacement_notes> tags, list for each outdated file the exact facts that need updating, so I can edit it quickly. If you cannot see a file in the list, say so rather than judging it from its name.

Fill in: PROJECT_PURPOSE FILE_LIST_WITH_DATES WHAT_CHANGED

Run it after a change in your business or process. Re-upload edited files rather than leaving old versions beside new ones, since both would be searched.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Onboard a Colleague to a Shared Project

Best for: Handing a Project to a teammate

I am sharing a Claude Project with a colleague. The project is for: {{PROJECT_PURPOSE}}. Their role: {{COLLEAGUE_ROLE}}.

Look at the project instructions and knowledge you can see, then write a one-page guide for the colleague, in <guide> tags, that covers:
- What this project is for and what it is not for.
- A list of the knowledge files, with one line on when each is useful.
- Five example first messages that work well in this project, written in a form they can copy.
- What the project cannot do or does not know, based on gaps you can see.
- How to add or change knowledge, and a reminder that whether they can edit depends on the sharing permission they were given.

Write in plain, friendly language for a person who has never used Claude Projects. Do not describe files or instructions you cannot see. Mark any statement that you inferred rather than saw with [inferred].

Fill in: PROJECT_PURPOSE COLLEAGUE_ROLE

Sharing is listed for Team and Enterprise plans with Can view or Can edit permissions; check the help page for current wording.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Artifacts: Build & Iterate

Artifacts open beside the conversation and can be edited and revisited. These prompts ask for a calculator, a dashboard from pasted data, a document that is revised by section, a flowchart, a one-page site, a deck from the Slides template, a flashcard app, an interactive explainer, a working prototype from a screenshot, and two directions of one design that you compare by editing an earlier message. Several tell Claude to use only what you supply and to leave visible placeholders in place of invented facts.

Build a Single-Page Calculator as an Artifact

Best for: Small interactive tools without writing code

Create an interactive artifact: a single-page calculator for {{CALCULATOR_PURPOSE}}.

Inputs the user enters: {{INPUT_FIELDS}}.
The calculation, in plain words: {{CALCULATION_RULE}}.

First state, in two or three lines, any assumption you are making about the calculation. Do not wait for my reply; build the artifact straight after, so I can correct the assumptions on the next turn.

Requirements for the artifact:
- Show the result and the working underneath it, so a user can see how the number was reached.
- Validate the inputs: reject empty, negative or non-numeric entries with a plain message beside the field.
- Include a reset button and sensible default values.
- It must work on a phone screen and use no external services or network calls.
- Add a note at the bottom stating what the calculator does not take into account.

After the artifact, give three test cases with the answers you expect, worked out step by step, so I can check the arithmetic by hand.

Fill in: CALCULATOR_PURPOSE INPUT_FIELDS CALCULATION_RULE

Check the formula yourself with the three test cases before relying on the numbers. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page
Example output · Claude (example written by The Prompt Index)
Inputs used: CALCULATOR_PURPOSE = working out the monthly cost of leasing a delivery van. INPUT_FIELDS = monthly lease fee, insurance per month, miles per month, cost per mile. CALCULATION_RULE = total monthly cost = lease fee + insurance + (miles per month x cost per mile). (This example shows the chat text only; the artifact itself opens beside the conversation.)

Assumptions: all amounts are in one currency and exclude tax; the cost per mile covers fuel and wear only; insurance is a flat monthly amount. Building the calculator now, so you can correct these on the next turn.

[Artifact: a single-page calculator with four labelled number fields and default values, an inline message beside any empty, negative or non-numeric entry, a result line, the working shown underneath as "lease fee + insurance + (miles x cost per mile)" with the numbers filled in, a Reset button, a layout that fits a phone, and a note at the bottom: "Does not include tax, tolls, parking or maintenance outside the cost per mile."]

Three test cases, worked by hand:
1. Lease fee 450, insurance 120, miles 1,000, cost per mile 0.15: 1,000 x 0.15 = 150, then 450 + 120 + 150 = 720.
2. Lease fee 450, insurance 120, miles 0, cost per mile 0.15: 0 x 0.15 = 0, then 450 + 120 + 0 = 570.
3. Lease fee 600, insurance 95, miles 2,500, cost per mile 0.12: 2,500 x 0.12 = 300, then 600 + 95 + 300 = 995.

Turn Pasted Data Into a Dashboard Artifact

Best for: Visualising a dataset for a specific audience

I will paste a dataset. Build a dashboard from it as an artifact.

<data>
{{DATA}}
</data>

The questions the dashboard must answer: {{QUESTIONS}}.
The audience: {{AUDIENCE}}.

Requirements:
- Use only the data above. Do not invent rows, benchmarks or targets.
- A row of summary tiles, then one chart per question, then the data table with sorting.
- Chart titles state the finding in words, such as the direction of change, and the axes are labelled.
- State the period and the number of rows the dashboard covers, at the top.
- If the data has gaps, duplicates or odd values, list them in a small "Data notes" panel rather than quietly fixing them.

Before building, summarise in three lines what the data contains and which questions it can and cannot answer.

Fill in: DATA QUESTIONS AUDIENCE

Dashboards is a beta template on some plans; without it this works as an ordinary artifact request. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Draft a Document Artifact Ready for Section Edits

Best for: Long documents revised piece by piece

Draft a {{DOCUMENT_TYPE}} as a document artifact titled "{{DOCUMENT_TITLE}}".

Audience: {{AUDIENCE}}.
What it must achieve: {{GOAL}}.
Material to use (use nothing else):
<source_material>
{{SOURCE_MATERIAL}}
</source_material>

Structure it with clear headings and keep each section short enough to review on its own. Where the source material does not support a statement a section needs, write [NEEDS INPUT: what is missing] in place of the statement.

After the draft, do not rewrite anything. In the chat, list the three sections you are least sure about and why. I will then select text in the artifact and ask for changes one section at a time, so leave the rest of the document exactly as written when I do.

Fill in: DOCUMENT_TYPE DOCUMENT_TITLE AUDIENCE GOAL SOURCE_MATERIAL

In a document or Markdown artifact, highlight text, click Edit with Claude and describe the change, which keeps edits local. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Draw a Process as a Flowchart Artifact

Best for: Documenting a workflow as a visual

Turn the process below into a flowchart or diagram artifact.

<process_description>
{{PROCESS_DESCRIPTION}}
</process_description>

Step 1, in the chat: list the steps you have identified, numbered, with the decision points marked and each decision's possible outcomes. Point out any step where the description is unclear, or where two paths never rejoin or end. Do not draw yet.

Step 2: if there are no blocking problems, draw it straight away. Otherwise draw it with the unclear steps highlighted and labelled "to confirm".

Diagram rules: one start and a clear end for each path; decisions as diamonds with labelled exits; no more than {{MAX_BOXES}} boxes; short labels; the owner of each step noted where the description names one. Under the diagram, add a plain-text version as a numbered list for anyone who cannot view it.

Fill in: PROCESS_DESCRIPTION MAX_BOXES

Ask for changes by describing them in chat. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Build a One-Page Website Artifact for a Real Offer

Best for: Prototype landing pages from a short brief

Create a single-page website as an artifact for {{BUSINESS_NAME}}.

What they offer: {{OFFER}}
Who it is for: {{TARGET_CUSTOMER}}
Tone: {{TONE}}
The one action a visitor should take: {{CALL_TO_ACTION}}

Page order: a headline that states what the visitor gets, a short supporting paragraph, three benefits each tied to a specific feature of the offer, how it works in three steps, a frequently asked questions section with four items, and a closing call to action.

Rules:
- Use only the facts I have given. Do not invent testimonials, statistics, awards, prices, client names or guarantees. Where a section needs a fact I did not supply, show a visible placeholder in square brackets.
- Simple, readable design with good contrast that works on a phone.
- No external scripts or tracking.

Afterwards, list the placeholders you left, in order of importance.

Fill in: BUSINESS_NAME OFFER TARGET_CUSTOMER TONE CALL_TO_ACTION

Treat the result as a draft: supply and check every fact before publishing anywhere. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Create a Study Flashcard App From My Notes

Best for: Revision tools built from your own notes

Build an interactive flashcard and quiz artifact from my notes.

<notes>
{{STUDY_NOTES}}
</notes>

The subject and level: {{SUBJECT_AND_LEVEL}}.

Features:
- Cards with a question on the front and the answer on the back, flipped by a click or tap.
- A shuffle mode, and a quiz mode that asks me to type an answer, then shows the card's answer for me to mark myself right or wrong.
- A running score and a list of the cards I missed, so I can review only those.

Rules: create the cards only from the notes above, and do not add facts from elsewhere. If a topic in the notes is too thin to make a good card, list it in the chat after the artifact rather than padding. Aim for {{CARD_COUNT}} cards, fewer if the notes do not support that many.

Fill in: STUDY_NOTES SUBJECT_AND_LEVEL CARD_COUNT

Check each card against your notes, since the cards are only as accurate as what you pasted. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Build a Slide Deck From My Outline With the Slides Template

Best for: First-draft decks from a written outline

Make a slide deck from my outline using the Slides template.

Topic and purpose: {{DECK_PURPOSE}}
Audience: {{AUDIENCE}}
Number of slides: {{SLIDE_COUNT}}

<outline>
{{OUTLINE}}
</outline>

Rules:
- One main message per slide, stated as a full-sentence title. Use short supporting points, not paragraphs.
- Use only facts and figures in my outline. If a slide needs a number or example I did not give, write [ADD: what is needed] on the slide.
- Put speaker notes under each slide with what to say in about 30 seconds.
- Finish with a closing slide that states the single action you want from the audience.

After the deck, list in the chat the three slides most likely to need changes and what would improve them.

Fill in: DECK_PURPOSE AUDIENCE SLIDE_COUNT OUTLINE

Docs, Slides and Design are artifact templates (artifacts help page); edit by typing, moving elements or asking Claude. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Create an Interactive Explainer for a Concept

Best for: Teaching a concept through a small interactive tool

Create a small interactive artifact that helps {{AUDIENCE}} understand {{CONCEPT}}.

The one idea they should leave with: {{KEY_TAKEAWAY}}.

Design it so the learner changes something and sees the effect, for example with sliders, buttons or choices, rather than reading a block of text. Include:
- A one-sentence description of the idea at the top, in plain words.
- At least one control that changes a visible result, with a label saying what it does.
- A short "what to notice" line that updates as they interact.
- A "check yourself" question at the end with feedback on the answer.

Keep the logic simple and correct. If the concept cannot be shown accurately in a simple interaction, tell me before building and suggest the closest honest alternative. Use no external services, and make it usable on a phone.

Fill in: AUDIENCE CONCEPT KEY_TAKEAWAY

Read through the finished explainer before sharing it; interactive models are simplifications. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Build Direction A and Write the Branch Message for B

Best for: Exploring two directions without losing either

I need an artifact for {{ARTIFACT_PURPOSE}} for {{AUDIENCE}}.

Build it now in this direction: {{DIRECTION_A}}.

Put a short design-notes block above the artifact with: the key choices you made, the one thing you traded away, and three criteria I can use to judge it against a different direction.

Then, in <branch_message> tags, write a plain request that I can use to ask for a quite different direction: {{DIRECTION_B}}. The branch message must state the purpose and audience, describe the new direction in enough detail to build from, and say what must stay the same. It must not contain design-notes instructions or ask for any further branch message. Do not build direction B yourself.

Fill in: ARTIFACT_PURPOSE AUDIENCE DIRECTION_A DIRECTION_B

Edit your first message in the chat and paste in the branch message: editing an earlier message creates a different version of the chat with its own artifacts, so you can compare directions (artifacts help page).

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Recreate a Screenshot as a Working Artifact

Best for: Turning a screenshot into a clickable prototype

I have attached a screenshot of {{WHAT_THE_SCREENSHOT_SHOWS}}. Recreate it as a working single-page artifact so I can try out how it behaves.

Before building, describe in <observations> tags what you can see: layout, sections, labels, colours, any text you can read, and any control that looks interactive. Mark what you are guessing, such as hidden states or what a button would do.

Then build the artifact. Match the layout and visual hierarchy closely, use placeholder text in place of anything unreadable, and make these elements interactive: {{INTERACTIVE_ELEMENTS}}. Do not copy a company's logo or brand assets; use a plain placeholder box instead. No external services, and it must work on a phone.

After the artifact, list in the chat the five biggest differences between your version and the screenshot, so I know what to ask you to fix.

Fill in: WHAT_THE_SCREENSHOT_SHOWS INTERACTIVE_ELEMENTS

Attach the screenshot to the chat first. Use it for prototypes and mockups, not for copying another company's product.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Files, Spreadsheets & Data

With file creation switched on, Claude can create Excel, Word, PowerPoint and PDF files and chart images for you to download. These prompts make the file the point: a cleaned workbook with a flag column, a change log and a row-count check, a chart image whose title states the finding, a screenshot of a table turned into a spreadsheet, notes turned into a Word or PDF document, a PDF brief built from project knowledge, and a second pass that reopens a generated file and checks it against your spec.

Make a Chart Image From Uploaded Data With the Finding in the Title

Best for: Presentation-ready charts from a data file

I have attached a data file called {{FILE_NAME}}. Make a chart from it that answers: {{QUESTION}}. The chart is for {{AUDIENCE}} and will go in {{DESTINATION}}.

Steps:
1. Tell me which columns you will use, any rows you will exclude and why, and which chart type you chose and why it suits the question. Mention one alternative you rejected.
2. Create the chart as an image file (PNG). The title should state the finding in a sentence, the axes must be labelled with units, and the colours must stay distinguishable in greyscale. Remove clutter such as gridlines that do not help.
3. Below the image, in the chat, give the three numbers that support the title, taken straight from the data, so I can verify them.
4. Tell me one thing the chart could mislead the audience about, and how I could caption it to avoid that.

Do not smooth, extrapolate or invent data. If the data cannot support a clear answer to my question, say so instead of drawing a chart that implies one.

Fill in: FILE_NAME QUESTION AUDIENCE DESTINATION

Check the three supporting numbers against your file; use files you trust (see the FAQ on hidden instructions). See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Turn a Screenshot of a Table Into a Spreadsheet

Best for: Rescuing data that exists only as an image

I have attached a screenshot of a table: {{TABLE_DESCRIPTION}}.

Turn it into an Excel file.

Rules:
- Copy the values exactly as shown. Keep the original column headings and order.
- Where a character is unclear, enter the best reading and highlight the cell in yellow. List each highlighted cell with the alternatives you considered.
- Put numbers in as numbers and dates as dates where the format is clear. If a value only looks like a number, tell me what you did with it.
- Do not add rows, columns or totals that are not visible. If you think a total row is wrong, say so in the chat but leave the printed value as it is.
- Add a final sheet called Source_Notes saying what the image showed, the date if visible, and anything cut off at the edges.

After building the file, give me the row count and column count you transcribed and the number of highlighted cells, so I can compare with the image.

Fill in: TABLE_DESCRIPTION

Compare the file with the original image: misread digits are the main risk. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Turn My Notes Into a Formatted Word Document or PDF

Best for: Getting a ready-to-edit document file

Turn the notes below into a {{FILE_TYPE}} file (Word or PDF). The audience is {{AUDIENCE}} and the purpose is {{PURPOSE}}.

<notes>
{{NOTES}}
</notes>

Rules:
- Use only what is in the notes. Where a section needs something I did not give you, put a clearly marked placeholder in the file.
- Use real heading styles, a short opening summary, plain language and short paragraphs. Add a table of contents only if the document runs to more than three pages.
- Put any list of figures or comparisons into a table with a header row.
- Add page numbers, and a header with the document title.
- Do not add images, logos or statistics you cannot source from the notes.

Create the file for download. In the chat, list the placeholders you left, the three weakest parts of the draft, the page count, and any claim in the notes that you were unsure how to phrase.

Fill in: FILE_TYPE AUDIENCE PURPOSE NOTES

Open the file and check the formatting in your own software before sending it. See the setup note in How to use.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Cleaned Workbook With Flags, Change Log and Row-Count Proof

Best for: A cleaned file you can audit

I have attached a spreadsheet called {{FILE_NAME}}. Known problems: {{KNOWN_PROBLEMS}}.

Create a new Excel file and leave my original untouched. The new file must have exactly these sheets:
1. Clean_Data: every original row, in the original order, with the fixes applied. Add a column called Review_Flag that is blank for untouched rows and holds a short reason for any row you changed or doubted.
2. Change_Log: one row per type of change, with the column, the rule applied and the number of cells affected.
3. Questions: values you could not fix without guessing.

Do not delete any row. After creating the file, open it again and verify it. Report the sheet names, the row count in Clean_Data compared with the original, the number of rows with a Review_Flag, and whether the Change_Log counts add up to the changes you made. If any figure does not match, say so before giving me the file, and fix the file first.

Fill in: FILE_NAME KNOWN_PROBLEMS

The point is the downloadable file and the verification step. Compare a sample of rows with your original before using it. File creation must be on (see How to use).

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Check the File You Just Created Against My Spec

Best for: Catching errors in generated files

You created a file for me earlier in this chat. Open it again and check it against my original request, which was: {{ORIGINAL_REQUEST}}.

Work through these checks and report the result of each as pass, fail or cannot check, with evidence:
1. The file name, type and sheet or slide or section names match what I asked for.
2. The counts I specified match the file: {{COUNTS_TO_CHECK}}.
3. Formulas are real formulas rather than pasted values, wherever I asked for calculations. List three examples with their cell references.
4. No placeholder text, example rows or invented figures remain, other than those I asked you to leave.
5. Anything I asked for that is missing.

Show the evidence, such as cell references and the numbers you read back, not just a verdict. Fix every failure, create a corrected file, and list what you changed. Tell me what you cannot verify from inside the file, such as how it will look in my own software.

Fill in: ORIGINAL_REQUEST COUNTS_TO_CHECK

Use it as a second pass on any generated .xlsx, .docx or .pptx. Claude checking its own work can miss errors, so still open the file yourself. File creation must be on (see How to use).

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Turn Project Knowledge Into a Downloadable PDF Brief

Best for: Turning a knowledge base into a shareable document

Using only the knowledge files in this project, create a PDF brief on {{BRIEF_TOPIC}} for {{AUDIENCE}}.

Structure: a title and date line; a half-page summary; three to five sections with clear headings; a short "What we do not know" section; and a source list naming the project files you used.

Rules:
- Use only what the project knowledge says. Do not add outside facts. Where the knowledge conflicts, show both versions and name the files.
- Under each section, name the file it came from in small text.
- Keep it to about {{PAGE_COUNT}} pages, in plain language, with no decorative images.

Create the PDF for download. Then, in the chat, list the files you used and the files you did not use, and flag any section where the knowledge was thin.

Fill in: BRIEF_TOPIC AUDIENCE PAGE_COUNT

Works in a Project with knowledge files, with file creation on (see How to use). Check the PDF against your sources before sending it on.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Claude Code: CLAUDE.md, Plans & Reviews

These prompts are for Claude Code, Anthropic's coding tool, not for the chat window. They cut a CLAUDE.md down to what Claude cannot work out from the code, interview you into a SPEC.md, ask for a plan in plan mode before any edits, fix a bug from a failing test, review a diff against the spec, keep noisy output in a subagent, work from screenshots, add tests that match your style, write a /goal condition, plan parallel worktree sessions and write the prompt for an unattended scheduled task. Our coding pack covers general code prompts for any model.

Interview Me Until You Can Write the Spec

Best for: Turning a vague idea into a buildable spec

I want to {{FEATURE_GOAL}} in this project, but I have not thought it through yet.

Interview me until you could write the spec, then write it to SPEC.md.

How to interview: first read the parts of the codebase that this touches, so you do not ask me things the code already answers. Then ask in small batches, using multiple-choice questions where there are real options, on the parts I have not pinned down: who or what the behaviour applies to, what happens in the failure and edge cases, what is out of scope, and how we will know it works.

When my answers are enough, write SPEC.md with these headings: Goal, Behaviour, Out of scope, Edge cases, Acceptance checks (each one something that can be run or observed, with the command where there is one), and Open questions. Do not write any code in this session. Tell me when the spec is ready and suggest starting a fresh session to build from it.

Fill in: FEATURE_GOAL

Run this inside Claude Code, not in the chat window. The interview-then-SPEC.md method is the Claude Code best-practices page's own; start a fresh session to build from the spec. It differs from a ticket-to-spec prompt in that Claude reads the code and interviews you.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Plan Mode: Propose Changes Before Any Edits

Best for: Reviewing a change before it touches the code

I want to make this change: {{CHANGE_REQUEST}}.

Constraints: {{CONSTRAINTS}}.

Do not edit any files. Read the code that this touches and propose a plan. In the plan give me:
1. The files you would change and what you would change in each, in order.
2. The files you would need to read but not change.
3. The existing pattern in the repo that you would follow, with the file where it appears.
4. How you would check the work: the exact commands for the tests, typecheck or lint, and any new test you would add first.
5. The risks: what could break, what you could not verify from the code, and anything where you would want my decision.

If something in the request is ambiguous, list your questions at the end instead of choosing for me. I will approve, edit or reject the plan before you make any change.

Fill in: CHANGE_REQUEST CONSTRAINTS

Run this inside Claude Code, not in the chat window. Start in plan mode: run claude --permission-mode plan, or press Shift+Tab until the status bar shows plan mode on. Anthropic's docs say Claude then reads files and proposes a plan with no edits until you approve.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Fix a Bug Starting From a Failing Test

Best for: Bug fixes that are proven rather than claimed

Users report: {{SYMPTOM}}.

The likely area is {{CODE_AREA}}. "Fixed" means: {{DEFINITION_OF_FIXED}}.

Work in this order and do not skip a step.
1. Read the relevant code and say what you think is happening, in three sentences or fewer.
2. Write a failing test that reproduces the problem, run it, and show me that it fails for the reason you expect.
3. Make the smallest change that fixes it. Do not refactor unrelated code or change formatting elsewhere.
4. Run the new test and then the wider test command {{TEST_COMMAND}}, and keep going until they pass or you hit something you cannot resolve.
5. Show me the evidence: the commands you ran and their output, not just a statement that the tests pass.

If you cannot reproduce the problem with a test, stop at step 2 and tell me what you tried, instead of changing code on a guess.

Fill in: SYMPTOM CODE_AREA DEFINITION_OF_FIXED TEST_COMMAND

Run this inside Claude Code, not in the chat window. It names the symptom, defines fixed, gives Claude a check to run and asks for evidence.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Review the Diff Against SPEC.md With a Subagent

Best for: Checking a change against what was agreed

Use a subagent to review my current changes against {{SPEC_FILE}}.

The subagent should check three things only:
1. That every requirement in the spec is implemented, listing each requirement with the file and line where it is handled, or "not implemented".
2. That every edge case listed in the spec has a test, and that the tests would fail if the behaviour broke.
3. Anything that affects correctness: logic errors, unhandled failure paths, and changes to behaviour the spec does not ask for.

Skip style, naming and formatting. Do not suggest extra abstraction layers or tests for cases that cannot happen. Report gaps only, ranked by how much they affect correctness, with the file and line for each. If you find nothing in a category, say "none found" rather than inventing a finding.

Give me the report, then wait. Do not change any code until I say which gaps to fix.

Fill in: SPEC_FILE

Run this inside Claude Code, not in the chat window. Keep the skip-style line so the reviewer reports gaps instead of padding. The /code-review command is another option.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Fix a Layout From a Screenshot and a Mockup

Best for: Matching a design with screenshots

I have two images: {{CURRENT_IMAGE}} showing how the page looks now, and {{TARGET_IMAGE}} showing what it should look like. The page is built in {{FRAMEWORK}}.

First, in a short list, describe the differences you can see between the two images: spacing, alignment, sizes, colours, missing or extra elements. Say which differences you are sure about and which are guesses.

Then find the component and styles that produce this part of the page and tell me which files you will change before you change them.

Make the changes. Keep to the existing styling approach in the repo and add no new libraries. If you can, run the app and check the result against the target image, and tell me what you compared. If you cannot run it, say so and list what I should check by eye. Finish with a short summary of every file changed.

Fill in: CURRENT_IMAGE TARGET_IMAGE FRAMEWORK

Run this inside Claude Code, not in the chat window. Paste or drag the two images into the session; check the result in a real browser.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Add Tests That Match the Project's Existing Style

Best for: Closing test gaps without disturbing conventions

Add tests for {{CODE_TO_TEST}}.

Before writing any test, look at the existing test files near it and tell me, in a short list, the framework, the file naming and location, how tests are set up and torn down, the assertion style, and how the project handles mocks. Follow those conventions exactly and add no new test libraries.

Then identify the behaviours of {{CODE_TO_TEST}} that are not yet covered. List them, ordered by how likely they are to break: normal paths, error conditions, boundary values and unexpected inputs. Show me the list and the tests you propose to write, one line each, then write them.

Run the new tests and then the full test command {{TEST_COMMAND}}. If any new test fails, decide whether it has found a bug or the test is wrong, say which, and show the evidence. Do not change the code under test to make a test pass without asking me. Finish with the commands you ran and their output.

Fill in: CODE_TO_TEST TEST_COMMAND

Run this inside Claude Code, not in the chat window. Read every new test before you commit it.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Cut My CLAUDE.md Down to What Claude Cannot Work Out

Best for: Making a bloated CLAUDE.md effective

Review my CLAUDE.md file against the repository and propose a shorter version.

Read these first: the current CLAUDE.md at {{CLAUDE_MD_PATH}}, the project manifest and build files, and the test configuration. Do not edit anything yet.

For each line or section, decide:
- Keep: it tells you something you could not work out from the code, such as the exact test, typecheck and lint commands, a place where the code is misleading, a decision that is not in the repo, or something I had to correct twice.
- Cut: you can see it from the code, it describes architecture or file layout, it is vague (for example "format code properly"), or it is out of date.
- Sharpen: keep it but rewrite it as a concrete instruction you could verify.
Also report any two lines that contradict each other, and any line written for an older model that current models no longer need.

Show a table of line, verdict and reason, then the proposed file, targeting under 200 lines under short headings. Ask for approval before writing it.

Fill in: CLAUDE_MD_PATH

Run this inside Claude Code, not in the chat window. Run /doctor first: per the Claude Code docs it suggests cuts for lines Claude can work out from the code, and /doctor prompt-audit flags contradictions and outdated lines. This prompt is the manual version and lets you decide each line.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Keep Noisy Output Out of My Main Session With a Subagent

Best for: Parking noisy investigations in a separate context

I need to find out {{QUESTION_ABOUT_CODE}}, but the investigation will probably produce a lot of output, such as long logs, big search results or many file reads that I do not want in this conversation.

Use a subagent for it and bring back only a summary. The summary must contain:
- A direct answer to the question, in no more than five sentences.
- The files, functions or log lines that matter, with one line each on why.
- What you could not determine, and what I would have to run or ask a person to find out.

Mark each statement as seen or inferred. Do not change any file. Before you start, tell me in one line whether you think a subagent is worth it here or whether it would be quicker to look directly, since a subagent has to gather context again and uses extra tokens. If it is not worth it, just do the investigation in this session.

Fill in: QUESTION_ABOUT_CODE

Run this inside Claude Code, not in the chat window. Claude Code's best-practices page says Claude delegates to subagents on its own and that subagents cost extra tokens, and can be slower. This prompt is for when you specifically want noisy output kept out of the main thread; most investigations need no such request.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Write the Prompt for a Cloud Scheduled Task

Best for: Unattended tasks that fail safely

I want Claude Code to run this on a schedule while my computer is off: {{TASK_PURPOSE}}.

The repository or resource it works on: {{TARGET}}.
Where the result should go: {{RESULT_DESTINATION}}.

Because the task runs without me, it cannot ask questions. Write the task prompt so it states exactly what to look at, what a successful run looks like, what to do with the results and where to put them, what to do when something is missing or fails so it does not stall, and what it must never do, such as merging, deleting or editing files outside a named folder.

Give the prompt in <task_prompt> tags. Then, in <dry_run> tags, list five situations in which it could go wrong (empty data, missing file, huge result, unexpected format, permission error) and the behaviour the prompt specifies for each. Last, tell me whether this belongs in a cloud scheduled task or a session /loop, using the rule that a loop only runs while a session is open.

Fill in: TASK_PURPOSE TARGET RESULT_DESTINATION

Run this inside Claude Code, not in the chat window. The Claude Code docs say /schedule creates a cloud scheduled task that runs on a timer (it needs a claude.ai login), while /loop repeats a prompt on an interval inside an open session. Test the prompt by hand once before scheduling it.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Write a /goal Condition That Can Be Checked

Best for: Giving a long run a clear stopping condition

I am about to give Claude Code a long task: {{LONG_TASK}}.

Help me write a /goal condition for it. A goal is a condition that is checked after every turn, and Claude keeps going until it is met, so it must be something that can be verified from evidence and not from Claude's own opinion.

Give me:
1. Three candidate goal conditions, from loosest to strictest, each as a single line I can paste after /goal.
2. For each, the command or observable result that would prove it, and one way it could be satisfied falsely.
3. Your recommendation, and the check you would add to the repository first if none exists, for example {{CHECK_COMMAND}}.
4. What to watch for during the run, since a goal check and background work both use tokens.

Do not start the task. Reply with the options and wait.

Fill in: LONG_TASK CHECK_COMMAND

Run this inside Claude Code, not in the chat window. The Claude Code best-practices page describes /goal as a condition checked against the conversation after every turn, mostly useful for long background runs. Check the docs for your version.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Split Work Across Parallel Worktree Sessions

Best for: Running several Claude Code sessions without collisions

I want to do these pieces of work at the same time in this repository: {{WORK_ITEMS}}.

Plan how to split them across separate Claude Code sessions, each in its own git worktree, so the edits cannot collide. Read the code first, then give me:
1. A table of work item, files it will touch, and the branch name to use.
2. Any pair of items that touch the same files or depend on each other, and what order or merge approach you recommend instead of running them in parallel.
3. The gitignored files a fresh worktree will be missing (such as .env) and which of them I should list for copying.
4. The exact start command for each session and the first prompt to give it.
5. The merge order and the checks to run after each merge.

Do not start any of the work. If parallel sessions are not worth it for these items, say so and explain.

Fill in: WORK_ITEMS

Run this inside Claude Code, not in the chat window. The Claude Code docs describe claude -w <name> for a session in a new git worktree, and note that a fresh worktree lacks gitignored files unless they are listed in .worktreeinclude. Confirm the current options in the docs.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Thinking & Effort Settings

Claude lets you choose an effort level and switch thinking on from the model menu, and in Claude Code the effort level is the main control for how hard it thinks. These three prompts are about those controls: a triage of your task list into default and higher-effort jobs, a side-by-side comparison of one question answered at two settings, and a one-turn ultrathink for a hard design decision in Claude Code. Where a setting has to change, the instructions say which. Higher effort uses more of your usage limit.

Which of My Tasks Need More Effort or Thinking?

Best for: Choosing how much effort a task deserves

Here is the list of tasks I will bring to Claude this week:

<tasks>
{{TASK_LIST}}
</tasks>

My priorities: {{PRIORITIES}}.

For each task, recommend how I should set up the chat before I start. Give a table with the columns Task, Complexity (everyday, moderate or demanding) with a one-line reason, Recommended settings (default, higher effort, thinking on, or both), and Prepare first (what I should attach or paste).

Use this rule of thumb: everyday questions and general writing usually need only the defaults, while math, multi-step technical problems, planning and document analysis benefit from more effort or thinking. Say where you are unsure and I should just try the default first.

Then give me a suggested order for the week, putting the demanding tasks where I will have the most time and attention. Remind me at the end that higher effort and thinking use more of my plan's usage limit than ordinary replies.

Fill in: TASK_LIST PRIORITIES

Menu names vary by plan and model, so check Anthropic's help article on changing the model, effort and thinking settings. It says lower effort stretches your usage further and that thinking cannot be turned off on some current models.

Run in ChatGPT Run in Claude Run in Gemini Prompt page
Example output · Claude (example written by The Prompt Index)
Inputs used: TASK_LIST = 1. Reply to a supplier email in two lines. 2. Check a 12-month cash-flow spreadsheet for formula errors. 3. Summarise a 40-page supplier contract and flag unusual clauses. 4. Suggest ten names for a newsletter. PRIORITIES = finish the contract review by Thursday.

| Task | Complexity | Recommended settings | Prepare first |
|---|---|---|---|
| 1. Supplier email reply | Everyday: a short, routine piece of writing | Default | Paste the email and say what you want to say |
| 2. Cash-flow spreadsheet check | Moderate: multi-step checking across many cells | Default first; thinking on and higher effort if the spreadsheet turns out to be large | Attach the spreadsheet; say which cells hold the totals |
| 3. Contract summary and unusual clauses | Demanding: document analysis where small wording matters | Thinking on and higher effort | Attach the contract; list what counts as unusual for you |
| 4. Newsletter names | Everyday: brainstorming | Default; try higher effort only if the first list is weak | Describe the audience and tone |

Task 2 is the one I am least sure about, because I have not seen the spreadsheet: start on the default and raise the setting if the check looks shallow.

Suggested order: do task 3 first, early in the week, since it carries your Thursday deadline and needs the most attention. Do task 2 next, while you still have full attention. Fit tasks 1 and 4 into short gaps, on default settings.

Reminder: higher effort and thinking use more of your plan's usage limit than ordinary replies.

Was the Higher Effort Setting Worth It? Compare Two Answers

Best for: Learning when extra effort pays off

I asked Claude the same question twice: once with the default settings, and once with a higher effort level or thinking turned on.

The question: {{QUESTION}}

<answer_default>
{{ANSWER_DEFAULT}}
</answer_default>

<answer_higher_effort>
{{ANSWER_HIGHER}}
</answer_higher_effort>

What matters for this task: {{WHAT_MATTERS}}.

Compare the answers. In <comparison> tags, give a table of differences in correctness, completeness, errors in reasoning, and anything one answer includes that the other lacks, quoting the passages. Then, in <verdict> tags, say whether the extra effort made a difference that matters for my stated need, or only made the answer longer. If you cannot tell which answer is right, say what I should check myself rather than picking one.

Finally, give me a rule of thumb for which similar tasks should get the higher setting in future, based only on this comparison, and note that one comparison is a small sample.

Fill in: QUESTION ANSWER_DEFAULT ANSWER_HIGHER WHAT_MATTERS

Run the same prompt in two chats. For the second, click the model name next to the send button, raise the effort level or switch Thinking (or Extended) on. Anthropic's help article says to do that for complex tasks and that defaults usually suffice for everyday ones. Higher effort uses more of your usage limit.

Run in ChatGPT Run in Claude Run in Gemini Prompt page

Ultrathink One Hard Design Decision in Claude Code

Best for: A single deep-reasoning turn in Claude Code

ultrathink

I have to make a design decision in this repository: {{DECISION}}.

The options I am considering: {{OPTIONS}}.
What matters most: {{PRIORITIES}}.

Read the relevant code first. Then set out the case for each option based on what you find in the code, the risks of each, and the cost of changing course later. Recommend one option and say what evidence would change your mind. Also list the three assumptions your recommendation depends on most and how I could test each cheaply before committing. Keep the answer to one page, with the recommendation in the first paragraph. If the code shows that the options are not really different, or that a fourth option I have not listed is better, say so plainly. Where you are relying on something you could not find in the code, mark it as an assumption. Do not make any edits.

Fill in: DECISION OPTIONS PRIORITIES

Run this inside Claude Code, not in the chat window. The Claude Code best-practices page says phrases like think hard are ordinary prompt text, but that ultrathink asks for deeper reasoning on that single turn without changing your effort setting. It needs Claude Code v2.1.311 or later (model-config docs) and is typed as a plain keyword, not inside quotes. For a lasting change, adjust the effort level instead (see the docs for how in your version).

Run in ChatGPT Run in Claude Run in Gemini Prompt page

How to get the best results

  1. Find the job. Pick the section that matches what you are trying to do: question a long document, set up a Project, build an artifact, create a file, or plan a code change.
  2. Fill the {{VARIABLE}} placeholders with real material. Paste the actual text, not a description of it. Where a prompt shows XML tags such as <document>, keep them as they are, since they tell Claude which part is which.
  3. Setup note for artifacts and file creation. Anthropic's artifacts page names the setting Cloud code execution and file creation under Settings > Capabilities (Create and edit files in the updated layout; the file-creation page calls it Code execution and file creation). When we checked on 28 October 2026 that page listed it as on by default for Free, Pro, Max and Team plans and for new Enterprise organizations, so check that it is on, and that your organization has not switched it off.
  4. Claude Code prompts are for Claude Code, not the chat window. The thinking prompts name the setting to change in their instructions.
  5. Verify what matters. Quotes, calculations and transcribed numbers are easy to check, so check them. Do not upload passwords, client secrets or personal data you are not allowed to share.

To tidy a prompt before you use it, try our Prompt Optimizer or the Prompt Generator.

Take the whole pack with you

Download all 46 prompts as a tidy PDF, or as Markdown you can paste straight into Notion. It needs a free account: no card, and the prompts above stay free to copy either way.

Sign up free to download

Frequently asked questions

Do I need a paid Claude plan to use these prompts?

Many work in an ordinary chat on any plan. A few depend on features with their own plan rules. When we checked Anthropic's help pages on 28 October 2026, basic Projects and file creation were listed for free accounts, chat search was listed for paid plans, and dashboards in artifacts were listed as a beta on some plans. Claude Code is a separate tool. These details change, so check Anthropic's help pages for your plan.

How do I check that artifacts and file creation are on?

Open Settings > Capabilities and look for Cloud code execution and file creation, which the updated layout calls Create and edit files. Anthropic's file-creation page listed it as on by default for Free, Pro, Max and Team plans and new Enterprise organizations, with Team and Enterprise owners controlling it in organization settings. Anthropic also warns that hidden instructions in untrusted files could trick Claude, so use files you trust and watch the run.

How much can I upload to one chat?

Limits change, so check Anthropic's upload help page. When we checked on 28 October 2026 it listed a maximum number of files per chat, PDFs up to 1000 pages, and visuals analysed only for PDFs of 100 pages or fewer. The Index Everything I Have Uploaded and Prove You Read the Whole Document First prompts help you spot a file that did not load fully.

Will turning on thinking or raising effort improve answers?

Not for easy questions. Anthropic's help article says to raise the effort level, turn on thinking, or both for complex tasks, and that the defaults are usually enough for everyday ones. It also says thinking cannot be switched off for some current models, and that higher effort uses more of your usage limit. A prompt cannot change the setting, so the prompts in that section tell you which menu to use.

Can I use these prompts with ChatGPT or Gemini?

The tagged long-document prompts will usually run in other chatbots, because tags are plain text. The Projects, artifacts, file-creation, effort-setting and Claude Code prompts refer to Claude's own features and will not work the same elsewhere. For prompts that work in any model, see our role packs.

← All prompt packs