Claude Hidden Features: 20 Uses Most People Never Try

Put the context you re-explain in every chat into one workspace: project instructions, files, and a chat history of its own. Upload the documents and code the project needs and Claude uses them as the background for your chats. A new beta version is also rolling out in stages, starting with Claude Code and select Pro, Max and Ultra subscribers: a project becomes one conversation and Claude splits the work into parallel threads running in the cloud.

Click Projects in the left side of claude.ai, or open claude.ai/projects and start a new one; the knowledge base sits on the right side of the project page, and that is where project instructions live too. Every account can create projects, including the Free plan, which is capped at five projects. Retrieval over your project files (RAG) is on paid plans.

Follow the instructions for this project in every chat here:
Product: [what this service does]; stage: [internal trial / live].
Stack: [language and framework with versions], database: [name], deployed on: [target].
Code style: keep the repo's existing naming and layout; prefer small functions and explicit error handling; do not add frameworks.
Answer format: a one-line conclusion, then a paste-ready code block, then the list of changes and the points that need my decision.
If you are unsure, say so rather than inventing a library call or flag; name the document you would check.
Do not: bump dependencies, rewrite tests, add features I did not ask for, or re-explain basics.

Ask for a widget, a chart, slides or a document and Claude builds it as a panel you can operate, keep editing and download into common file types. Anthropic's Artifacts page counts Claude Design, Claude Slides and Claude Docs as included in every plan, including the Free plan.

Ask for one in any conversation, or start from the Artifacts tab. When it is ready, open it, click "Share" and choose who gets access; artifacts made earlier still show "Publish" or "Share & copy link".

Build a small tool developers reach for daily: a regular expression tester that runs as one page.
Inputs: one line for the pattern, checkboxes for flags (g, i, m), and a text area below for the sample.
Highlight every match, list each capture group with its index and value, and if the pattern is invalid show a plain-language reason instead of a blank page.
Add an examples dropdown: email, URL, semantic version, nginx log line.
Tech: a single HTML file, plain JS, no external libraries, no network calls.
End with two sentences on how to turn this into a regex-replace preview.

The same control exists twice. In the web app it is two items in the model menu, usable in any combination: Effort sets how much thinking Claude applies to a reply, and the Thinking toggle sets whether its reasoning is shown in an expandable section. Through the API it is a request field where the model itself decides whether thinking helps and how deep to go. Anthropic states that thinking cannot be turned off in claude.ai with Haiku 5.5, Sonnet 5.5, Opus 5.5, Fable 5.1 or Opus 5.

Web: click the model name next to the send button, mouse over "Effort" and flip the "Thinking" (or "Extended") toggle. API: send thinking as {"type": "adaptive"} and put the level in output_config.effort (low / medium / high / xhigh / max depending on the model; most models default to high, Claude Opus 5.5 and Claude Haiku 5.5 to medium). In Claude Code, /effort sets the level (described on QCode's usage/adaptive-thinking page).

I have a decision in front of me: [what needs deciding]. Context: [constraints, deadline, who is affected].
Do not answer yet. Work through this order first:
1) what the decision really affects, and over what time span;
2) second-order effects of each option: what a win here creates next;
3) worst case: which signal would tell me I chose wrong, and whether the damage is reversible;
4) what information I am missing and the cheapest way to get it;
5) what evidence would make me reverse my own conclusion.
If the context is too thin, stop and ask me two or three questions instead of picking.
Close with one clear recommendation, the assumption it rests on, and the thing most likely to break it.

Claude saves what it learns about you as separate topics while you chat, so the next conversation starts with your role, your project and your preferences already on the table. Searching old chats and generating memory are two different switches.

Both live under Settings > Your Claude (older layout: Settings > Memory). Memory is on by default for the Free plan and for Pro, Max and Ultra plans on web, desktop and mobile; say "remember this" and it saves that item straight away; to keep one chat out of it, open the "+" menu in a new chat and turn memory off before your first message. In Claude Code running on an API key, the equivalent is the CLAUDE.md file in your project.

Remember my background and use it in later chats so I do not repeat myself:
Role: [job title / years]; day to day I mostly do: [recurring work].
Technical ground: [languages and platforms you know]; thin spots: [areas I should not be assumed to know].
Answer style: conclusion first, then the reasoning; code I can paste; one line explaining a term the first time it appears; say so when unsure.
Working style: I write the code myself, so do not redesign things for me; when offering options, state the tradeoff.
When one of these stops being true I will say "update my background".
Now list what you saved as a few short lines for me to confirm, and do not recite it back to me again.

Hand it the plan you already wrote. It hunts the quiet assumptions that fail, the blind spots you clearly did not consider and the parts you described far too lightly, then keeps one thing worth fixing first.

Start a fresh chat, paste this as the first message and put your plan underneath. If you want the same bluntness every session, keep it as project instructions in Projects (a paid-plan feature) or inside CLAUDE.md.

You are a senior engineer who has watched a lot of plans fail and does not soften the news.
The plan I am handing you: [paste the design, RFC or schedule].
Find: the hidden assumption that breaks first, the blind spot I clearly never considered, the part I described lightly that is actually hard, and anything that looks clever but is really wishful thinking.
Order the list from most likely to fail to least, one sentence each on why it fails.
Do not praise me, do not hand me a complete checklist, do not rewrite the plan.
If something is missing, ask exactly one question, then continue.
End with the single change you would make if only one is possible, and why that one.

About a decision you already made, it writes only the strongest case against it and the most realistic failure paths, so you see the risk before you commit money and time.

Start a fresh chat and paste the decision plus the reasoning next to it. To get this kind of opposition at every design review, keep the text as project instructions in Projects (a paid-plan feature).

I have already decided: [what was decided]. Why: [the reasoning at the time].
Your only job is the strongest case against it, as if you had to persuade a review meeting to reverse the call.
Write three things only: the three sharpest arguments against; the three most realistic failure modes, each with when the first symptom shows up and what it looks like; and what the most expensive lesson on this path could look like.
You may say my judgement is off, my information is incomplete, or my motivation is wrong. No reassurance, no "but there are also upsides".
Close with a verdict: on what I gave you, is the opposition strong or am I only facing weak objections? If strong, name the step to pause at and what to verify first.

It plays your manager, the client or the partner, argues back turn by turn, steps out of character with one note after each round, and finishes with a full debrief.

Use it in a fresh chat after filling in the role and the situation. If you drill often, keep the text as project instructions in Projects (a paid-plan feature) so each new chat picks up the same setup.

Let's rehearse a hard conversation: you play [manager / client / partner], I play myself.
The situation: [what needs discussing, e.g. scope will not shrink and the schedule is already short]; what this person cares about: [pressures, commitments, quota].
Hold your own position and your own pressures; do not cooperate with me out of character. I say one line, you answer with one line, and never write my part for me.
After each round, step out and give one short note: what my line actually did, and a steadier version of it. Two or three lines, then back into role.
When I am stuck I can ask "what are my options", and you give three moves with the price of each.
At the end, debrief me: their core concern, where I was visibly weak, and how I should open next time.

Findings grouped by severity: correctness, security, concurrency and timing, edge and error handling, maintainability. Each one gets a location and a fix, no compliments and no filler.

Start a fresh chat with the PR, branch name or the code pasted in. To make this the default way reviews run, fold the text into your project rules in CLAUDE.md.

You are a strict code reviewer. Review target: [PR / branch / file path, or paste the diff].
Judge only these dimensions: correctness, security, concurrency and timing, edge cases and error handling, maintainability.
Group findings by severity (blocking / should fix / can defer). For each: file and location, why it is a problem, the smallest fix, and how I would verify it.
Do not praise anything that needs no change, do not pad the list, and if nothing is serious, say so plainly.
If you lack context (tests, callers, requirements), list what you need instead of guessing.
End with one line: can this ship as is, and how many findings block it.

It asks by role and level, one question at a time, pushes back on your answer, then scores you across several dimensions and names the three things to shore up in the next two weeks.

Fill in the role, level and company type, then run it in a fresh chat. Between sessions, open a new chat each time and send this block as the first message.

You are a technical interviewer at a [company type / team], interviewing for [role] at the [junior / mid / senior] level.
Ask one question at a time and wait for my answer, then follow up: why that choice, what happens at the edge case, what breaks when the load is ten times bigger.
Keep questions close to real work: one design question, one debugging question, one code judgement question. No trick puzzles and no questions you pass by memorising.
You may interrupt me and ask for something more concrete, or for the interface and the data structure written out.
When the session ends, score me on correctness, depth, communication and engineering judgement, with one sentence of reasoning each.
Then list the three things to shore up over the next two weeks and one small exercise for each.

The extension lets Claude work on the page in front of you: read it, click, type, navigate, run a flow end to end, and summarize or compare what is open across your tabs.

Find Claude in Chrome in the Chrome Web Store and click "Add to Chrome"; paid plans only (Pro, Max, Ultra, Team, Enterprise). In Claude Code the command is claude --chrome, which needs extension version 1.0.36 or later and a plan bought directly from Anthropic. In QCode's comparison table it is marked ❌, with the note that this is inferred: tied to an Anthropic plan.

Turn the information on this page into a table, and do not add anything the page itself does not state.
Columns: [which columns you want, e.g. name / version / which plan it applies to / notes], one row per item.
Leave cells empty where the page says nothing, and after the table list which cells had no source.
Then summarise the page in three sentences and name the section headings you relied on.
Do not touch logins, payments or personal data, do not press submit-style buttons, and do not send anything outward.

Cowork has been folded into Claude: the official page says that in the new experience everything Cowork does is available from any conversation, and you cannot go back to separate Chat and Cowork entries. The desktop app can also link a folder on your computer so Claude reads it, tidies it and creates files there. Tasks that touch files or apps on your machine need the desktop app open.

In Claude Desktop you grant one conversation access to a folder on your computer. To let Claude work the screen itself, turn on Enable computer use under Settings > Capabilities; if that section is missing, open Settings > System and look under This computer. The official page calls it a beta on Pro, Max and Ultra plans, and the unified experience for Enterprise turns on by default on November 16, 2026. Filling in a gateway inside the desktop app has its own guide.

Take this month's meeting notes in [your folder path] on my computer and file them by date.
Keep only the decisions and the action items from each note, then give me one table of meeting, date and owner.
List how you plan to sort them and wait for my go-ahead before you touch any file.

The same request comes in three shapes. In the cloud: Scheduled tasks in Cowork run remotely according to the official page, so they fire even when your computer is asleep or Claude Desktop is closed, and Claude Code's /schedule is cloud too, needing a claude.ai subscription login, with the earlier name routines still showing. Desktop scheduled tasks run on your machine, which must be on. /loop only re-runs a prompt on an interval inside the current session.

Web and desktop: describe the cadence in a conversation and click Schedule, or open Scheduled in the left sidebar to land on the Scheduled tasks page. In Claude Code type /schedule for a cloud task; for quick polling while a session is open use /loop 5m plus your prompt, which the official page says Claude converts into a cron expression. If the work should live in your own timer, put a one-shot claude -p prompt in a script or a cron line; the headless mode page in QCode docs shows that usage.

Every weekday at 08:30, brief me on [your open-source project]:
1. issues opened in the last 24 hours, grouped by label, up to five per group, title plus one line;
2. new releases with version numbers and the key points of the notes;
3. anything waiting on my decision, listed last with its number.
One table plus at most three bullets, no preamble. Repo: [your repository URL]

Anthropic lists it as one of the templates you can start an artifact from: you can use it in any chat, in Claude Code and from the Artifacts tab, with on-canvas editing and your own design system. It suits landing pages, campaign pages and component previews, where seeing the thing beats reading about it. Officially it is available on every plan from the Free plan up to Enterprise and on by default; on Enterprise it turns on by default on October 15, 2026, and the standalone version at claude.ai/design closes on December 14, 2026.

The three entries are listed side by side: ask for a design in any chat, pick a Design template in the Artifacts tab, or use it in Claude Code. You iterate on the canvas itself. Publishing and sharing stay on the claude.ai account side: the official artifacts page says the session must be backed by a claude.ai account, and sessions using an API key, a gateway token or a cloud-provider credential cannot publish.

Build a landing page prototype for [your product] aimed at [your audience].
Sections in order: headline with one promise, three feature blocks, one customer scenario, three price tiers, footer questions.
Style: [your style, for example light and minimal with a single accent colour]; no carousels.
Give me a wireframe first, then refine the sections I point at, and keep the copy as placeholders.

A skill is one directory with a single SKILL.md inside: the description in the frontmatter tells Claude when to reach for it, and the body is the steps it follows. Claude loads it when something matches, or you call it yourself with /skill-name. It is where the routines you otherwise re-explain every week belong: a release checklist, the shape of a weekly report, a review rubric.

In Claude Code the skill directory goes under .claude/skills/ in the project or ~/.claude/skills/ for yourself, and it travels with the local CLI. On the web the official entry is Customize > Skills, and Anthropic notes that Customize is becoming Plugins, with the Skills, Connectors and Plugins tabs folded into one page; skills need code execution turned on. Officially skills are available on plans from the Free plan through Enterprise.

Turn the whole procedure I just walked you through into a skill: first the situations that should trigger it and the inputs it needs, then the steps and the checkpoints.
Save it as SKILL.md under [your folder in .claude/skills or ~/.claude/skills].
Write the description to say when the skill should be used, not only what it is.
Show me the directory and the full SKILL.md before you invoke it.

Claude Code loads CLAUDE.md and CLAUDE.local.md from your current working directory and every directory above it at launch, ordered from the filesystem root down, so instructions closer to where you launched are read last. Files in subdirectories load once Claude works in that directory. What goes in is whatever you are tired of repeating: what the project is, how tests run, the code style, the things not to touch.

Personal scope lives in ~/.claude/CLAUDE.md and applies to every project; project scope sits at the repository root and is shared through git; CLAUDE.local.md is for private per-project preferences that should stay out of version control, and the official page says to add it to .gitignore. Inside a session /memory lists these files and opens them for editing, while /context shows which ones actually loaded at launch.

Project: [name] - one line on the problem it solves.
Layout: front end in web/, back end in server/, shared types in packages/types/.
Commands: pnpm install; pnpm dev locally; pnpm test for the files you touched; pnpm lint and pnpm typecheck before committing.
Style: TypeScript strict mode, never any; lowercase-hyphen names for directories and files.
Convention: each new endpoint gets its own file under server/routes; never edit the historic route files.
Data: migration scripts are append-only; leave the files in migrations/ alone.
Off limits: do not read or edit files starting with .env; do not git push on your own; never commit a secret.
Dependencies: ask before adding a package, one at a time, with the reason.
Answers: state the plan before editing, change one file per step, ask instead of guessing.
Testing: after a change run pnpm test and paste back any failure.
Docs: every new public endpoint needs a matching entry in docs/api.md.

The same Claude Code asks for different things depending on where it runs. Anthropic's table puts the CLI and everything that runs locally in one list, with the VS Code and JetBrains extensions in the same list, while Claude Code on the web and on mobile, Claude Code in Slack and Remote Control sit in the list that requires a claude.ai sign-in and is not reachable with an Anthropic Console API key or from a third-party provider.

For GitHub Actions the official page offers two credentials: ANTHROPIC_API_KEY for an API key, or CLAUDE_CODE_OAUTH_TOKEN generated by claude setup-token for a subscription. How to point the local CLI somewhere else appears with setup steps in the Claude Code tutorial in QCode docs.

Two things only: read the repository root and tell me how to install dependencies and run the tests here.
Then list three points where you need my call. Do not change any file and do not run anything that writes.

Long material you send over and over does not have to be paid at full input price each time: in the official API you mark the stable start (system prompt, long background, a map of the codebase) with cache_control and it goes into the cache. The official price table gives 1.25 times base input for a 5-minute write, 2 times for a 1-hour write and 0.1 times for a cache read, with reads on Opus 5.5 and Sonnet 5.5 at 0.05 times (a footnote in the official table). The cache matches by prefix, so one early change invalidates everything after it.

In the request body set the cache_control type to ephemeral; without a ttl that is the default 5-minute lifetime, and Anthropic also offers a 1-hour duration at additional cost, written by giving ttl the value 1h. The official page says shorter content is not cached even when marked, with no error returned, and that the minimum length differs by model (see the official table). The cost optimization page in QCode docs says caching happens automatically and shows how placing unchanging content first raises your hit rate.

{
  "model": "claude-opus-5-5",
  "max_tokens": 1024,
  "system": [
    {
      "type": "text",
      "text": "[your unchanging long reference: API contract, house style, a map of the codebase]",
      "cache_control": { "type": "ephemeral" }
    }
  ],
  "messages": [
    { "role": "user", "content": "[the actual question for this round]" }
  ]
}

Claude has no video editing feature, and the official docs carry no example of cutting video. What you can do is let Claude Code run commands on your machine: install ffmpeg yourself, and it builds the arguments, runs them and reads the output. Repetitive jobs suit it — trimming a section, turning a horizontal clip vertical, squeezing a file under a target size, converting a batch. Judging whether the picture looks good remains your call, and none of this replaces an editing suite.

State three things: where the input file is, what you want out of it, and where the result goes. Have it print each command first and run it only after you say so, and ask it to explain why it chose each argument. When the run is done, make it list the output files with their sizes, then judge the result yourself. This uses the Bash tool of the local CLI.

I have ffmpeg installed. Please work on [your input file]:
1. cut out the section from [start time] to [end time] and convert it to vertical 9:16; ask me first whether to crop to the centre or add bars;
2. save a second version squeezed under [your target size];
3. export a GIF preview of the first three seconds.
Print each command first for me to confirm, run them after, and finish with the output files and their sizes.

Two roads here, and they are not the same one. The ready-made connectors in claude.ai (Gmail, Google Calendar, Google Drive and the rest) are loaded by the account side, and the official page says they take effect only while your claude.ai subscription is the active authentication method. In Claude Code you add MCP servers yourself.

On the web you browse and add them under Customize → Connectors, and the official note is that this section is being folded into the new Plugins page. In Claude Code you add one from the terminal; the official example is claude mcp add --transport http claude-code-docs https://code.claude.com/docs/mcp, then you check it with /mcp inside a session. Per the official pages, web connectors such as Gmail, Google Calendar and Google Drive are open to all users; custom connectors are limited to one on the Free plan.

Using my connected Gmail and Google Calendar, do only this on Monday morning:
1. list every meeting on the calendar for [today] with its start time and how many attendees;
2. group unread mail containing [your keyword or project name] by sender, three groups, one line each on what it is about;
3. point out which look like they are waiting on me.
Do not send any mail for me and do not reply to anyone. Finish with one table: meetings, clashes, replies waiting.

Reading pictures is a property of the model. The formats the official page supports are JPEG, PNG, GIF and WebP, and an animation contributes only its first frame. Expense receipts, error screenshots, whiteboard photos and mockups can go straight into the conversation, and having them transcribed into the columns you ask for is much faster than typing them out. Good for a pile of them; check the numbers yourself.

In Claude Code the official ways are three: drag and drop an image into the window, copy an image and paste it with Ctrl+V (Alt+V on Windows and WSL), or give Claude the image path in your prompt. On the web you attach files or paste an image from the clipboard. The model you picked has to be one that reads images.

These pictures are my expense receipts. Give me one row per receipt: date, merchant, amount, tax, currency.
Add a totals line at the end, and list separately any number you are not sure you read, naming which receipt and which field.
Output CSV I can paste straight into a spreadsheet, with a header row and no extra prose.