Writing

The Claude Code Field Guide: What Most People Never Use

updated 2026-08-21

I learned this from people who explain it better than I do. Go read them first:

Anthropic's official Claude Code docs — the canonical source: https://code.claude.com/docs/en/best-practices
freeCodeCamp — "The Claude Code Handbook" (23 chapters, professional intro): https://www.freecodecamp.org/news/claude-code-handbook/
DataCamp — "Claude Code Best Practices" (CLAUDE.md budget, context management): https://www.datacamp.com/tutorial/claude-code-best-practices
Anatoli Kopadze — two X posts on hidden Claude capabilities: https://x.com/AnatoliKopadze
Jack Roberts — Claude Design + gauntlet loop: https://www.youtube.com/watch?v=jq9LRwE0-GQ
Ben Ryan — "Claude Code Best Practices: The Ultimate 2026 Guide" (8-layer memory hierarchy): https://benryan.com.au/blog/ultimate-guide-building-with-claude-code
Boris Cherny (Head of Claude Code, Anthropic) — "Build for the model six months from now, not for the model of today."

This page distills what I learned from those sources into one reference. I am not the expert. They are. I am putting it on one page so I can find it easily. If it helps you, go follow them and give them the traffic.

The pitch

Most people use Claude like a search engine. They type a question, get an answer, and move on. That is the lowest-value way to use the most capable AI tool available. And it is how the vast majority of users interact with it.

The people who get 10x more out of Claude do not have better prompts. They have better setups. They have given Claude context about who they are, what they work on, and how they like to think. They use it as a partner, not a dispenser. They know about features that do not have marketing campaigns behind them.

This is a field guide to that gap. It covers the Claude Code terminal tool specifically — the thing that reads your codebase, writes files, runs commands, and closes loops on its own — plus the broader Claude ecosystem features that most users never touch.

What Claude Code actually is

Claude Code is Anthropic's terminal-based coding agent. It's not a chatbot. It's not Copilot. It reads your actual files, writes new code, runs tests, reads error messages, and iterates until the task is done — all from a terminal prompt, in your existing codebase.

The core difference from chat Claude: chat Claude has no filesystem access and no shell. Claude Code has both. It can scaffold a project, run npm install, verify a build passes, commit the result, and hand back a URL — in one conversation, from one description.

You talking  →  Claude Code  →  files on disk
                             →  shell commands
                             →  git commits
                             →  test runs
                             →  a finished thing

It runs locally (terminal), in IDEs (VS Code and JetBrains extensions), on the web (claude.ai/code), and from mobile (web sessions driven from the Claude mobile app). The desktop app is the most capable surface; the web session is the one that makes "talk a website into existence from your phone" actually achievable.

The 15 features most people never touch

These come from Anatoli Kopadze's two X posts — a 15-feature guide to hidden Claude capabilities and an 18-step deep-dive on actually using Claude well. They've been verified against current Claude Code documentation and independent power-user reports. The features are real. Most Claude users have never tried more than one or two of them.

1. Projects — Claude that remembers you

Every new chat starts from zero. It doesn't know your name, your work, your preferences. Most people accept this and re-explain themselves every time.

Projects fix this. A Project is a persistent workspace where Claude keeps context across every conversation inside it. Set it up once and every session that follows starts with Claude already knowing who you are and what you're doing.

How to use it: Go to Claude, click Projects in the sidebar, create one. Name it after the work — "Game Dev," "Consulting," "Writing." Everything that matters goes inside a Project, not in disposable chats.

Why it matters: this is the single highest-leverage setup change. If you do nothing else on this list, do this. It eliminates the re-explanation tax that compounds every session.

2. Custom Instructions — Claude that behaves the way you think

Pasting your background into a Project is a good start. Custom Instructions go further — they tell Claude not just who you are, but exactly how to behave with you by default.

How to use it: After filling in your background, ask Claude to write your Custom Instructions for you:

"Based on what I just told you, write me a set of Custom Instructions for Claude. Describe who I am and what I do. Set my default communication style and format. Tell Claude what to never do when working with me. Define the tone I want in every response. Include any default behaviors I would want in every session. Write them in second person, as if Claude is reading rules about how to help me. Be specific. No generic advice. Under 400 words."

Take the output and paste it into your Project Instructions. This becomes Claude's permanent operating mode for every conversation in that Project.

Why it matters: this is the difference between Claude that sometimes gives you what you want and Claude that consistently gives you what you want. The instructions are small. The effect is large.

3. Extended Thinking — Claude that reasons before it answers

Most Claude users have never turned this on. Extended Thinking is a mode where Claude reasons through a problem step by step before giving you an answer, instead of going straight to the output.

When to use it: complex decisions, strategic analysis, code architecture, anything where the difference between a surface-level answer and a thought-through answer is large.

When not to use it: simple factual questions, quick translations, anything where the extra reasoning time isn't worth it.

How to use it: Click the brain icon in Claude before sending the message. Or add to your prompt: "Work through the problem step by step, show your reasoning, identify where you're uncertain, then give me your conclusion."

Why it matters: the difference in output quality on hard questions is significant. For the price of a few extra seconds, you get a substantially better answer on anything that actually requires thought.

4. Claude writes prompts for Claude

This is the most underused thing you can do. If you're not sure how to prompt Claude for a specific task, ask Claude to write the prompt for you.

How to use it:

"Write me the best possible prompt for this task. Include role, context, format instructions, and any constraints that would improve the output. Then use that prompt immediately."

Claude knows what kinds of instructions produce better results. Let it use that knowledge on your behalf.

Why it matters: most people's prompts are significantly worse than they could be. Letting Claude write them closes that gap without requiring you to become a prompt engineer.

5. Claude as a sparring partner — attack, don't agree

By default, Claude agrees with you. It adds to your ideas, supports your reasoning, finds the positives. That's comfortable. It's also almost always the wrong thing when you're trying to stress-test an idea.

How to use it:

"Here's a plan I'm considering: [your plan]. Your job is to destroy it. Find every assumption I'm making that could be wrong. Find every way this could fail. Argue the opposite position as hard as you can. Do not be polite. Do not add qualifications. Just attack."

After the attack, ask for the steelman:

"Now steelman my position. Build the strongest possible case for why I'm right. Then tell me what you actually think."

Why it matters: agreement is cheap. Stress-testing is valuable. The people who get the most from Claude use it as a thinking partner that pushes back, not a mirror that validates.

6. Give Claude a role — one prompt changes everything

Claude doesn't have to be "an AI assistant." Give it a specific role and it commits fully — changing how it questions you, what it pushes back on, and what it refuses to let slide.

Five roles worth knowing:

Personal psychologist. Claude asks questions to help you understand your own thinking patterns, listens for cognitive distortions, asks one question at a time, and doesn't hand you answers — it helps you reach them yourself. Use it when you're working through something personal and want structured reflection, not advice.

The hard mentor. Claude stops validating and starts stress-testing. It finds weak assumptions, missing considerations, the exact places your plan breaks. It's uncomfortable. That's why it works. Use it before committing to any plan.

Personal trainer. Generic fitness advice is everywhere and doesn't account for your schedule, injuries, equipment, or actual goals. Give Claude your real numbers and it builds a real plan that adjusts when you report back. Use it when you want a program built around your situation, not a template.

Practice a difficult conversation. Claude plays the other person — realistically. It responds the way they would, pushes back when your argument is weak, and makes you earn a good outcome. Use it before a hard conversation to rehearse. After a few practices, the real conversation is easier.

Devil's advocate. You've made up your mind. That's exactly the moment to have Claude attack the decision — not polite concerns, the full case against it. Use it five minutes before committing, not after.

How to use any of them: paste the role description at the start of a new chat or into your Project Instructions. Claude commits to the role for that conversation.

Why it matters: the same underlying model, given a different role, produces a completely different kind of interaction. The role is the lever.

7. Style cloning — Claude that writes like you

When Claude writes without examples, it writes in its own voice — grammatically correct and completely wrong in tone. It sounds like AI because it is.

How to use it: Give Claude three to five samples of your own writing. Ask it to analyze your patterns, not just describe your style:

"[paste sample 1] [paste sample 2] [paste sample 3]

Analyze my writing style in detail. Look at: sentence length, rhythm, vocabulary choices, how I open and close paragraphs, what I avoid, how formal or informal I am, and any patterns that make my writing distinct.

After this, when I ask you to write anything for me, match this style exactly. Do not default to your own patterns."

Then when you ask Claude to write something, it writes like you — not like a polished corporate assistant.

Why it matters: if you're using Claude to draft content that will be published under your name, style cloning is the difference between "looks like AI" and "looks like you."

8. Claude in Chrome — Claude that sees what you see

Most people use Claude in a separate tab and manually copy-paste what they need. That's the hard way.

Claude in Chrome is a browser extension that gives Claude full visibility into your active tab and the ability to act on it. It reads the page, clicks links, fills forms, navigates to new URLs. You describe the task in plain English and Claude does it against the page you're actually looking at.

Example use: "Go through every listing visible on this job board page and extract the job title, company name, salary range if shown, and the top three requirements. Build me a comparison table sorted by salary, highest first. If there are multiple pages, click through and keep going."

Why it matters: this removes the copy-paste friction that makes a lot of Claude use slower than it should be. If the information you need is on a webpage, Claude can see it directly.

9. Claude Cowork — Claude that lives on your desktop

Claude on the web has no access to your computer. It can't see your files. You paste everything manually.

Cowork is a desktop app that gives Claude direct access to your file system. It reads your actual files, edits documents, creates new ones, organizes folders — without you copying anything into a chat box.

Why it matters: this is the difference between "Claude can help with this document" and "Claude can work on this document directly." For anything that involves your actual files — research notes, drafts, code, data — Cowork removes the manual transit step.

10. Skills in Cowork — install new capabilities like plugins

Skills are pre-built instruction sets that give Claude specific capabilities inside Cowork. Instead of explaining what you need every time, you install a skill once and Claude already knows how to handle that type of task — building PowerPoint files, working with PDFs, running a specific workflow.

Think of it like apps on a phone. The base phone works without them. With the right apps installed, it does a lot more.

How to find and install: Cowork → Customize → Skills to see what's installed. To add new ones, browse the plugin directory and install. The skills appear in your Skills tab automatically and Claude uses them when the task calls for it.

Why it matters: skills are reusable capability. Install once, use forever. The more you find that fit your actual work, the more capable Claude becomes without any additional prompting effort from you.

11. Claude Code — AI that writes, tests, and fixes code in your terminal

Some people still don't know you can write code with Claude. Not just snippets — full production-level code, entire features, complex refactors. You describe what you need in plain English and Claude writes it.

Claude Code takes that one step further. It works inside your development environment — not in a chat window. It reads your actual codebase, writes new code, runs tests, reads the error messages, and fixes the bugs in a loop until the task is done.

It integrates with VS Code and JetBrains. You can drop it into a GitHub repo and it owns a task end-to-end.

How to use it: open Claude Code in your project directory, describe what you need, and let it work. For a feature: "Add a search endpoint to this API that queries the users table and returns results as JSON." For a refactor: "Extract the validation logic from this component into a separate module and update all references." For a fix: "Run the tests, find what's failing, and fix it."

Why it matters: this is the feature that changes the scale of what one person can build. Claude Code doesn't just suggest code — it owns tasks. That's a different category of usefulness.

12. Specify the output length — stop paying for what you didn't ask for

Claude's default is to write as much as it thinks is appropriate. That's usually more than you need — more tokens, more reading time, more noise.

How to use it: tell Claude exactly how long you want the answer before it starts:

"Give me a 3-sentence summary." "Write this as a single paragraph." "Keep it under 200 words." "A bullet list, no more than 5 items."

Add to your Custom Instructions:

"Go directly to the answer. Do not add a summary at the end unless I specifically ask for one. No disclaimers unless the topic genuinely requires one."

Why it matters: this costs nothing and saves tokens and reading time on every interaction. It's the easiest win on this list.

13. Ask Claude to ask you questions first

Before Claude starts any complex task, tell it to gather information from you first.

How to use it:

"Before you write anything, ask me what you need to know to make this genuinely good, not generic. After I answer, then begin."

Or for a specific task:

"Before you start writing this, ask me 3-5 questions that would change the output significantly. Wait for my answers."

Why it matters: generic output comes from incomplete context. If Claude asks you questions before writing, the output reflects your actual situation instead of a generic synthesis. This is one of the most powerful techniques almost nobody uses.

14. Context hygiene — stop re-explaining yourself every conversation

If you're pasting the same background information into every new chat, you're wasting tokens every single time — and training yourself into a habit that costs more as your Claude usage scales.

The fix: Projects and Custom Instructions. Put your context in once. Let Claude read it automatically at the start of every session. Never paste your background again.

If you're not using Projects yet, start there before anything else on this list. It's the foundation the rest of it builds on.

Why it matters: context hygiene is the difference between Claude that feels cheap at scale and Claude that stays cheap as you use it more. The tokens you don't re-paste are tokens you don't pay for.

15. The handoff pattern — keep context across sessions without the bloat

Long sessions degrade. At turn 30, the model's performance is noticeably worse than at turn 3. The context window fills. Compaction runs. Quality drops.

The fix: break work into focused sessions with clear objectives. "In this session, let's just get the data cleaning script working." Then start fresh for the next piece.

The handoff: before starting fresh, ask Claude to write a handoff document — what was done, what worked, what's left, what the next step is. Save that to a file in your project. Load it at the start of the next session. Clean context. Full continuity.

Why it matters: this is the pattern that keeps Claude useful across a multi-session project without the quality degradation that comes from an overloaded context window.

Claude Code specifics — the terminal tool

The features above apply to Claude broadly. Claude Code specifically — the terminal agent — has its own set of capabilities that don't exist in chat Claude.

What Claude Code can do that chat can't

Read your actual codebase. Not a pasted snippet — the files on disk, across your project tree.
Write files. Not code you copy out of a chat — files that land in your project.
Run shell commands. npm install, npx, git, test runners, build commands. Claude Code executes them.
Run tests and fix failures. It reads the error output and iterates — write, test, fail, fix, repeat — until the task is done.
Use git. Commit, push, create branches, review PRs. Claude Code can own the whole workflow.
Run autonomously. Give it a task and it works through it, calling tools as needed, without hand-holding at every step.

Setup

# Install
curl -fsSL https://claude.ai/install.sh | bash

# Authenticate
claude

# Verify
claude --version

Claude Code inherits your existing Claude subscription credentials. No separate API key needed for the basic setup.

The basic interaction loop

Open Claude Code in your project directory: claude
Describe what you need — a feature, a fix, a refactor, a test
Claude reads the relevant files, writes code, runs tests
Review what it did. Approve or request changes.
When it's done, the code is on disk and the tests pass.

The loop is conversational. You can riff, change direction, ask for alternatives. Nothing is committed until you're satisfied.

Context management in Claude Code

A few things worth knowing:

/clear often. Every time you start something new, clear the chat. History eats tokens, and Claude runs compaction calls to summarize old conversations. Clear it and move on.
Break work into chunks. Instead of one marathon session, do focused sessions with clear objectives. Then start fresh.
Write state to files. If Claude makes an important design decision, have it write that to a README or a plan file. Files persist; conversation context doesn't.
/terminal-setup fixes non-obvious terminal quirks — Shift+Enter for new lines, proper image paste behavior, and other things that don't work by default.

GitHub integration

After you run Claude Code, it can automatically review your PRs. This is genuinely useful — as you use more AI tools, your PR volume increases, and Claude often finds bugs that humans miss.

The default review prompt reports on all kinds of nuanced, unimportant things. Customize it to focus on what you actually care about:

# .github/claude-code-review.yml
name: Claude Code PR Review
description: Review PRs for bugs and security issues only
version: 1.0
permissions: read-all
tools:
  - ]]read
  - ]]grep
  - ]]glob
hooks:
  - type: pr_comment
    trigger: BranchProtectionVulnerabilityFound
    action: comment
    message: |
      Please review this pull request and look for bugs and security issues.
      Only report on bugs and potential vulnerabilities you find. Be concise.

Hooks — automate the repetitive parts

Hooks are shell commands that run at specific points in Claude Code's lifecycle — before a tool runs, after a file is written, when Claude finishes.

Common use: format-on-save. Every time Claude edits or writes a file, run Prettier:

{
  "hooks": [
    {
      "matcher": "Edit|Write",
      "hooks": [
        {
          "type": "command",
          "command": "prettier --write \"$CLAUDE_FILE_PATHS\""
        }
      ]
    }
  ]
}

Common use: type-check after TypeScript edits.

{
  "hooks": [
    {
      "matcher": "Edit",
      "hooks": [
        {
          "type": "command",
          "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.(ts|tsx)$ ]]; then npx tsc --noEmit --skipLibCheck \"$CLAUDE_FILE_PATHS\" || echo '⚠️ TypeScript errors detected - please review'; fi"
        }
      ]
    }
  ]
}

Hooks are configured interactively with /hooks in Claude Code, or by editing the JSON directly. They're one of the ways Claude Code stops being just a chat and becomes an actual development environment.

Custom slash commands

You can create custom slash commands that Claude Code runs as reusable prompts. Create a file in your project's .claude/commands/ directory:

---
description: Summarize the current project state
---

Read the project structure, the git log, and any open issues. Produce a 5-bullet summary of: what this project is, what's been done, what's in progress, what's blocked, and what's next.

Then run /summarize in any Claude Code session. Useful for handoffs, context resets, and getting back into a project after time away.

Auto mode

For repetitive tasks, Claude Code can run in auto mode — executing tool calls without asking for confirmation each time:

{
  "permissions": {
    "defaultMode": "auto"
  }
}

This is useful for tasks you trust Claude to handle end-to-end. For anything where a mistake would be expensive, keep manual mode and review each step.

For a broader guide to automating recurring work with Claude, see How to Automate Your Life With Claude.

What the top articles get right — and where they miss

A quick scan of what's ranking for Claude Code content in 2026 shows a consistent pattern:

What the top articles do well:

Step-by-step installation and setup walkthroughs
Terminal quirks and how to fix them
The GitHub integration and how to customize the review prompt
Hooks and how to set them up
Voice input and other input methods

What they consistently miss:

Projects and Custom Instructions as the foundation. Most tutorials jump straight into coding without covering the setup that makes every session better. This is the highest-leverage feature and the least covered.
Extended Thinking as a toggle. Most articles mention it in passing or not at all. It's one of the largest output-quality improvements available and most users have never turned it on.
The sparring-partner framing. Articles cover "how to prompt Claude" but rarely cover "how to use Claude to attack your own ideas." That framing — Claude as a thinking partner that pushes back — is a fundamentally different use case and one of the most valuable.
Style cloning. Most articles don't cover how to make Claude write in your voice. For anyone publishing content, this is essential.
The handoff pattern. Long-session degradation is real. The handoff pattern — write a summary, start fresh, load the summary — is the fix, and it's rarely covered.
Claude writes prompts for Claude. This is the easiest prompt-improvement win available and almost nobody writes about it.
Claude Cowork as a desktop agent. The chat vs. desktop distinction is under-explained. Cowork gives Claude filesystem access that chat Claude doesn't have.

This guide covers all of those gaps. That's the point.

What to do first

Don't try to implement everything. Pick the two or three that solve a problem you're actually feeling right now and set them up this afternoon.

If you don't use Projects yet: start there. Create a Project, paste in your background, write Custom Instructions. This is the foundation everything else builds on.

If your outputs feel too long: add the output-length instruction to your Custom Instructions. Set a default. Save the tokens.

If you're making decisions and want better thinking: turn on Extended Thinking for the next hard question. Compare the answer to what you'd get without it.

If you're shipping content under your name: do the style cloning exercise. Three to five samples. Analysis. Then write something and see if it sounds like you.

If you're using Claude Code for real work: set up hooks for formatting and type-checking. Configure the GitHub review prompt to focus on bugs and security, not commentary. Learn /clear and the handoff pattern.

If you want Claude to push back on your ideas: use the sparring partner prompt the next time you're about to commit to a plan. Let it attack before you build.

The pattern across all of it: Claude is more capable than most people's usage reflects. The gap isn't the model. It's the setup.

The gauntlet loop: independent critics for design quality

Claude can build beautiful designs. HTML animations, carousels, presentations, websites. But it has one weakness: it judges its own homework. It says "I think I've done it" when it hasn't. You end up going back and forth, pulling your hair out, trying to get it right.

Jack Roberts (Itssssss Jack on YouTube) demonstrates a fix called the gauntlet loop. The idea comes from Matt Schumer, popularized on X. The fix is simple: stop letting Claude evaluate its own work. Spin up independent critics instead.

How it works

The gauntlet loop runs fresh-context critics — independent Claude instances that evaluate the design against criteria. The output goes round and round in a loop until the critics are satisfied. Taste becomes a checklist.

Three critics, each with a job:

The Brief critic: Did you do what I asked? Checks the design against the original prompt.
The System critic: Is it in line with the design system? Checks adherence to your typography, colors, spacing.
The Craft critic: Does it look right? Evaluates rendered frames, not code. Judges visual quality, animation, polish.

The loop runs: interview, pre-flight checklist, build, critique, iterate. Repeat until the critics pass.

Setup

Create a design system in Claude (optional but recommended). Go to Claude's web UI, click Design in the bottom-left, create a new design system. Feed it any design assets you like. Claude generates a codified blueprint of your typography, graphics, and colors.
Export the design system as project HTML.
Install Jack Roberts' free 3-critic skill. Open a new Claude chat, type /designloop, paste in the skill. Claude activates the loop.

Token costs

The gauntlet loop is powerful but expensive. One run burns about 3 million tokens. The critic rounds delegate to cheaper models (Haiku, DeepSeek) to manage cost. Jack recommends reserving it for high-value, reusable outputs: templates, carousels, big projects where one-shot quality matters.

For cheaper runs, use DeepSeek V4 Flash for the critic rounds. Keep the main design model as Claude — it has the best design taste.

Source: "Claude Design just got 10X Better... I'm Done" by Jack Roberts. https://www.youtube.com/watch?v=jq9LRwE0-GQ. Gauntlet loop technique originally popularized by Matt Schumer on X.

Go learn from the experts

This page is a distillation. The real expertise lives with the people below. Go follow them. They explain it better than I do.

Podcasts

Startup Ideas podcast (Greg Isenberg) — the skillsmaxxing episode: https://www.youtube.com/watch?v=xHsftiyT9pQ
AI Daily Brief podcast — daily AI news and analysis

YouTube channels

Jack Roberts — Claude Design, gauntlet loop, Claude Code masterclass: https://www.youtube.com/watch?v=jq9LRwE0-GQ
Nate Herk — "two kinds of skills" framework (Capability Uplift vs. Encoded Preference): https://www.youtube.com/watch?v=RAZVk5NPNtE
Productive Dude — "Claude Code Tutorial: 21 Essential Tips" (beginner to pro): https://www.youtube.com/watch?v=nH79dqiOEJ4

X handles to follow

Greg Isenberg — https://x.com/gregisenberg
Anatoli Kopadze — https://x.com/AnatoliKopadze
Boris Cherny (Head of Claude Code, Anthropic) — https://x.com/bcherny
Matt Schumer — gauntlet loop originator, on X

Top-ranking articles

Anthropic official docs — "Best practices for Claude Code": https://code.claude.com/docs/en/best-practices
freeCodeCamp — "The Claude Code Handbook" (23 chapters, professional intro): https://www.freecodecamp.org/news/claude-code-handbook/
DataCamp — "Claude Code Best Practices" (CLAUDE.md budget, context management): https://www.datacamp.com/tutorial/claude-code-best-practices
Ben Ryan — "Claude Code Best Practices: The Ultimate 2026 Guide" (8-layer memory hierarchy): https://benryan.com.au/blog/ultimate-guide-building-with-claude-code
Firecrawl — "Best Claude Code Skills to Try in 2026" (19 skills ranked): https://www.firecrawl.dev/blog/best-claude-code-skills
Taskade — "Best Claude Code Skills in 2026" (12 skills, progressive disclosure): https://www.taskade.com/blog/claude-code-skills

Communities

AI Automation Vault (Jack Roberts) on Skool: https://www.skool.com/ai-automation-vault
AI Automations by Jack on Skool: https://www.skool.com/aiautomationsbyjack/
Reddit r/ClaudeAI — community tips and discussion: https://www.reddit.com/r/ClaudeAI

Official repos

Anthropic skills repo — https://github.com/anthropics/skills (157K+ GitHub stars)
Superpowers — https://github.com/obra/superpowers (243K+ GitHub stars)
gstack by Garry Tan — https://github.com/garrytan/gstack (118K+ GitHub stars)

Boris Cherny, Head of Claude Code at Anthropic, said it best: "Build for the model six months from now, not for the model of today."

You can do this. Go start. Write a CLAUDE.md. Build a skill. Put it in a repo. The people above built the tools and the tutorials. Your job is to use them.

Sources

Anatoli Kopadze, "Claude Can Do All of This. Most People Have No Idea." — X post, May 2026. 15-feature guide to hidden Claude capabilities.
Anatoli Kopadze, "How to Actually Use Claude: 18 steps that unlock 100% of its potential." — X article, 2026. Step-by-step deep-dive on Claude usage.
Claude Code documentation — https://code.claude.com/docs/en/overview
Builder.io, "How I use Claude Code (+ my best tips)" — hooks, GitHub integration, terminal quirks.
Hannah Stulberg, "30 Claude Code Tips and Tricks (After 1500+ Hours of Use)" — voice input, context management, session hygiene.
Paul G, "Getting Started with Claude Code: A Researcher's Setup Guide" — context window management, session chunking, handoff pattern.
FreeCodeCamp, "The Claude Code Handbook" — progressive competency model, CLAUDE.md, skills and persistent instructions.
The AI Corner, "Claude best practices 2026: the complete power user guide" — prompting shifts, context tricks, persistent context systems.
Jack Roberts, "Claude Design just got 10X Better... I'm Done" — gauntlet loop technique, design critics, Claude design systems. https://www.youtube.com/watch?v=jq9LRwE0-GQ

Target: dylanjharris.com — Practical AI Implementation series. Draft status: distilled from two Anatoli Kopadze X posts + Jack Roberts gauntlet loop video + verified against current Claude Code documentation and independent power-user sources. Needs Dylan's review, edit, and title before publishing.

← back to writing