Claude AI Guide: Tips, Tutorials & Best Practices

Stuck on "what am I even supposed to ask an AI?" This gives you 30 ready-to-paste prompts that get a fun reply back the moment you paste them. Six genres of five: get to know yourself (hidden strengths, shared values, which animal you are), spark ideas and what-ifs (unexpected uses for an everyday object, if gravity were halved, inventing a holiday), explanations that click (quantum mechanics for a 5-year-old, compound interest in three metaphors, the internet as pizza delivery), wordplay (rewrite in 10 styles, a two-sentence micro-story, epithets, palindromes), role-play and advice (a tough life coach, a sage who invents proverbs, a letter from your future self, a baffled alien), and useful-but-fun (turn an excuse into a maxim, five levels of saying no, fix a bland message, dramatic menu names, a fun detour in your to-do). Works on free ChatGPT, Claude, or Gemini. Includes tips (stack "more," add role and constraints, switch AIs), cautions, and a link to the sister article "15 fun ways to use AI."

Talk about AI and it is always the serious stuff, but AI might shine brightest at play. This article shows 15 fun ways to use AI, each with a copy-paste prompt you can try right now. Wordplay & comedy (① comedy battles ② parody-song/rap machine ③ naming factory), role-play & dialogue (④ talk to a historical figure ⑤ make two AIs debate ⑥ practice arguing with a devil's-advocate bot), games (⑦ text adventure with AI as game master ⑧ original quiz show ⑨ whodunit mystery game), creative (⑩ fictional creature field guide ⑪ a story where you are the hero ⑫ playing with image generation), and everyday & unexpected (⑬ leftovers chef ⑭ travel plans to ancient Rome or the Moon ⑮ entertainment fortune-teller). All work on free ChatGPT, Claude, or Gemini. The three keys to the fun — give it a role, bind it with constraints, stack "more" — double as the foundations of practical prompting. With cautions (fact vs. fiction, personal info, playing with kids) and an FAQ.

Claude Fable 5 and Opus 5 are both top-tier, but the answer is neither "always Fable 5" nor "always Opus 5" — choose by task. And the arrival of Opus 5 on July 24, 2026 moved that answer a long way: the previous generation, Opus 4.8, was "a notch below Fable 5 but half the price", whereas Opus 5 holds the same $5 / $25 price while matching or beating Fable 5 on agentic benchmarks (Frontier-Bench 43.3% vs 33.7% and OSWorld 2.0 70.6% vs 66.1%, both press-sourced; on CursorBench 3.2 Anthropic states it lands within 0.5% of Fable 5 at roughly half the cost). The hardest single-shot reasoning still tilts to Fable 5, though barely — Humanity's Last Exam 56.5% vs 56.3% and DeepSWE v1.1 69.7% vs 68.8% (press-sourced). Specs match on the 1M context window and 128K max output; fast mode (about 2.5x) is Opus 5 only but costs 2x and is Claude API only, and Opus 5 carries the newer knowledge cutoff of May 2026. The decision flow: try Opus 5 first and escalate to Fable 5 only where it plateaus. In practice, "Opus 5 as the base, Fable 5 for the hard parts" is optimal, backed by the app-side auto-switch on safety blocks and the new API fallback "default" mode. Covers availability (June suspension, July redeployment), avoiding single-model dependence, effort tuning for cost, and an FAQ — tying the Fable 5 cluster to the Opus 5 release guide.

On July 1, 2026, Anthropic redeployed its flagship models Claude Fable 5 and Mythos 5 worldwide — just 19 days after they were fully suspended on June 12 under a US export-control order. The direct reason for the return: the US Commerce Department lifted the export controls on June 30. The original trigger was a jailbreak report from Amazon researchers, but Anthropic has consistently argued that "Fable 5 offers no unique offensive capabilities," and the lifting resolves the matter in line with that position. It did not simply come back unchanged: a new classifier trained to detect the reported bypass technique blocks it in over 99% of cases, and when it fires the request is auto-rerouted to Opus 4.8 (the "switch models when a message is flagged" toggle in the app). For now a temporary cap applies — up to 50% of the weekly limit on Pro, Max, Team and select Enterprise plans through July 7, then via usage credits. Fable 5 consumes usage faster than Opus 4.8, and cloud access (AWS, Google Cloud, Microsoft Foundry) returns in stages (no date yet). As a follow-up to the suspension (article 113), this piece covers why it could return, what changed, usage caveats, and the lesson of designing without depending on a single model — grounded in the official announcement and press reporting.

Claude Code's permission rules let you write allow/ask/deny entries in settings.json to specify, fine-grained, which tools, commands, files, and domains run without asking, prompt every time, or are forbidden. This guide covers what permission rules are (modes set the broad confirmation baseline, rules are per-tool specifications, and rules are enforced by Claude Code, not the model), allow/ask/deny and precedence (evaluated deny then ask then allow, first match wins, and specificity does not change the order, so a broad deny beats a specific allow and a deny carries no allowlist exceptions; a bare tool-name deny removes the tool from context while a scoped deny blocks only matching calls), the rule syntax (Tool(specifier): Bash wildcards where a space before * is a word boundary and :* equals a trailing *, compound commands needing every subcommand to match, read-only commands that never prompt and stripped wrappers like timeout; Read/Edit gitignore-style anchors // absolute, ~/ home, / project root, ./ current; WebFetch domain:; MCP mcp__server__tool; Agent(Name)), the settings.json hierarchy and precedence (managed > CLI > .claude/settings.local.json > .claude/settings.json > ~/.claude/settings.json, where a deny at any level always beats an allow at any other, plus defaultMode and additionalDirectories), practical recipes (deny secret files, ask before risky ops, allow routine work, and for URLs deny curl/wget and use WebFetch(domain:) rather than fragile Bash argument patterns), and gotchas (Read/Edit deny can't stop indirect script access so pair with sandboxing; environment runners like devbox run/npx/docker exec need the inner command spelled out; hooks extend but don't override deny/ask). Based on the official docs as of June 2026.

The "Permission Mode" selector next to the prompt box in Claude Code (cycled with Shift+Tab) sets how often Claude pauses to ask permission before editing a file or running a command. This guide covers what permission modes are (the oversight-vs-autonomy tradeoff; protected paths like .git and .claude are never auto-approved except in bypass), the five modes (Ask permissions = default, reads only auto-approved; Accept edits = acceptEdits, auto-approves edits and common filesystem commands inside your working dir; Plan mode = plan, explores and proposes a plan without editing; Auto mode = auto, a separate classifier blocks dangerous actions while running everything else without prompts; Bypass permissions = bypassPermissions, everything with no checks, isolated environments only) plus the settings-only sixth mode dontAsk, how to switch (Shift+Tab cycles default to acceptEdits to plan, auto and bypass join conditionally, the --permission-mode flag, and defaultMode in settings, with auto honored only in user settings), auto mode in depth (the classifier's allow/block defaults, requirements of Opus 4.6+ or Sonnet 4.6, conversational boundaries honored as block signals, and the 3-consecutive / 20-total block fallback), which mode to use when and safety (bypass has no prompt-injection protection so it's isolated-only; auto is the right answer for everyday prompt fatigue; hooks still run in bypass), and how permission mode relates to the effort setting (permission mode = how much it asks, effort = how hard it thinks). Based on official docs and the live UI as of June 2026.

That "Effort" slider next to the model name in Claude Code — the Faster-to-Smarter dial — sets how much work (thinking, tool calls, and response text) the AI puts into each reply. This guide covers what effort is; the slider's 6 items and labels (the API has 5 levels, low to max, and Claude Code adds its own Ultracode mode; the slider reads Low, Medium, High, Extra, Max, Ultracode, where "Extra" = xhigh and the top effort is "Max" — Ultracode is an add-on, not a step); what saves vs. is session-only (low–xhigh persist, Max and Ultracode are session-only); model support and auto-downgrade (xhigh is limited to Fable 5, Opus 4.8, Opus 4.7, etc.; Opus 4.6 and Sonnet 4.6 have no xhigh and downgrade to high; Claude Code's default is high, xhigh on Opus 4.7, while the API default is high everywhere); how to set it (/effort slider and direct values, /effort auto, /model, --effort, the CLAUDE_CODE_EFFORT_LEVEL env var as highest priority, the effortLevel setting, and skill/subagent frontmatter); a quick-reference table; an in-depth look at Ultracode (a two-layer mode that sends xhigh and has Claude auto-launch multi-agent dynamic workflows, limited to xhigh-capable models and session-only, with how to enable it, when to use it, and cost cautions); and related features (ultrathink, /fast). Based on official docs and the live UI as of June 2026.

Agent evals are the process of systematically measuring whether an agent — one that uses tools and takes multiple steps to reach a goal — can actually accomplish its tasks. They are an evolution of LLM evals, expanding the target from "one output" to "a sequence of actions." Because an agent plans, calls tools, and updates state, the final output alone is not enough; Google notes you must understand the "why" behind an agent's actions and splits evaluation into final response and trajectory. The five dimensions are: outcome (task success, judged by the final state — whether a reservation exists in the DB, not the utterance "I booked it"), trajectory (reasonable steps, right tools in the right order), tool-use correctness (right tool and arguments, checking function names and types), efficiency (steps, tokens, cost, latency — often observability signals brought into evaluation), and final-response quality (via LLM-as-judge or a rubric). Graders are code (fast/cheap/reproducible but brittle), LLM-as-judge (flexible but non-deterministic and needs calibration), and human (gold standard but expensive — avoid if possible). Anthropic recommends grading the outcome, not the path: rote trajectory matching is "too rigid and brittle" because agents find valid alternatives, while Google and Microsoft offer trajectory-match metrics for diagnosing failures. The unique pitfalls are non-determinism (pass^k), compounding errors (p^t), reward hacking (DeepMind's robot arm faking a grasp), and stale or contaminated eval sets. The practical play, per Anthropic: turn 20-50 production failures into test cases, run automated grading in CI, separate capability and regression evals, and write them early. Benchmarks like SWE-bench, tau-bench, WebArena, GAIA, OSWorld, and BFCL are useful references (scores move by version, so do not take them at face value). Based on official information, with uncertainties flagged.

Claude Code hooks are user-defined shell commands that run automatically at specific points in Claude Code's lifecycle, making "this must always happen" real and deterministic without relying on the LLM's judgment. The classic events are nine—SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Notification, Stop, SubagentStop, SessionEnd, PreCompact—of which PreToolUse and others can block (stopping protected-file edits or dangerous commands). You configure them in settings.json under the "hooks" key as event name -> matcher -> type + command. The I/O contract: a hook receives JSON on stdin (session_id, tool_input, etc.) and returns via exit code 0 (success) / 2 (block, with stderr passed back to Claude) or structured JSON (continue, decision:block, permissionDecision: deny/allow/ask). The key principle is "hooks can tighten but not loosen restrictions" (deny always wins, blocks even under bypassPermissions). Classic use cases: auto-format after edits (PostToolUse + Edit|Write), protect critical files, stop dangerous commands, re-inject context (SessionStart), notifications/audit logging, and test-before-stop (Stop). On security, hooks run arbitrary shell commands with your privileges, so only configure trusted ones and validate/quote inputs; hook config is captured at session startup (a safety feature) so mid-session changes do not apply. Based on the official documentation, anchored on the nine classic events and the I/O contract.

Checkpointing and /rewind are a safety net: Claude Code automatically tracks Claude's file edits as you work, so you can roll back to "before it went wrong" in a few keystrokes. A snapshot is taken before each edit, every prompt you send becomes a restore point, and checkpoints persist across sessions. To use it, type /rewind or press Esc twice when the input is empty to open the menu, then pick a point and choose Restore code and conversation / Restore conversation / Restore code (note: if the input has text, Esc twice clears it instead). The most important caveat: only changes made by Claude's edit tools (Write/Edit/NotebookEdit) are restored — file changes by bash commands (rm/mv/cp), changes outside the session or from other sessions, directory operations, remote files, and database state are NOT undone by rewinding. The docs frame it as "checkpoints = local undo, Git = permanent history," stating it complements but does not replace version control, so committing to Git at milestones is the rule. /rewind is also the recovery for the 400 error tied to tool-use concurrency and thinking blocks (the product itself prompts you to run it), though versions before v2.1.156 may not clear it so claude update comes first. It is on by default in the interactive CLI, opt-in in the Agent SDK, and retained with sessions for 30 days (configurable). Based on the official documentation, with uncertainties flagged.

Claude Managed Agents launched as a public beta on April 8, 2026 as a suite of composable APIs for building and deploying cloud-hosted agents at scale. Instead of building your own agent loop, tool execution, and runtime, you get a fully managed environment where Claude can read files, run commands, browse the web, and execute code securely, with prompt caching, context compaction, sandboxing, and state persistence built in. It is organized around four concepts (Agent, Environment, Session, Events), and the Environment can be an Anthropic-managed cloud sandbox or a self-hosted one. The difference from the self-hosted Agent SDK (where you run the loop, tools, and infrastructure) is "you run it vs Anthropic runs it" — not competitors but a choice about how much of the operations you hold. A signature feature is workspace-scoped persistent memory (a memory store) mounted in the sandbox at /mnt/memory, which the agent reads and writes with normal file operations and which persists across sessions (immutable versions, 30-day retention, limits like 100 kB per memory). Dreaming is an async job that reads the existing memory and past transcripts to produce a reorganized memory store — merging duplicates, updating stale values, and surfacing new insights (a research preview requiring access; some call it "scheduled" but the docs describe an on-demand async job). It also has outcomes-based grading (a separate grader evaluates against your rubric; reported up to a 10-point improvement) and multi-agent orchestration. Pricing is tokens + $0.08 per session-hour (metered to the millisecond, only while running; about $0.705 for a 1-hour Opus 4.8 session). Enabled by default for all API accounts, but stateful so not eligible for ZDR or a HIPAA BAA. Based on official information, with uncertainties flagged.

As you use Claude Code more, your own slash commands, subagents, MCP servers, and hooks accumulate. A plugin bundles them into one unit you can version, share, and reuse across teams and projects (plugins arrived in public beta in October 2025; an official directory and /plugin search and list were added in 2026), and a marketplace is where they are distributed. This article covers what a plugin is (a self-contained directory bundling skills, commands, subagents, hooks, and MCP servers), its structure (only plugin.json inside .claude-plugin/, with commands/agents/skills/hooks at the root; the plugin.json name/description/version/author manifest), how to use it (the /plugin tabbed manager, /plugin marketplace add owner/repo then /plugin install name@market, /plugin enable|disable|uninstall, /plugin list --enabled, the search bar, /reload-plugins), what a marketplace is (a .claude-plugin/marketplace.json catalog; the official claude-plugins-official available from first launch and browsable at claude.com/plugins, plus the community claude-plugins-community), how to build and publish your own (place plugin.json and SKILL.md and test with claude --plugin-dir, then put marketplace.json at the git root; versioning resolves plugin.json then marketplace then commit SHA; claude plugin validate), distribution scope (user/project/local/managed, with team distribution via .claude/settings.json extraKnownMarketplaces and enabledPlugins), and safety (plugins can run arbitrary code with your privileges, Anthropic does not verify third-party plugins, and strictKnownMarketplaces restricts sources) — all based on the official documentation.