Slash commands are how you steer a session — not as prompts, but as direct control signals. Where natural language tells Claude what to build, slash commands control the tool itself: compressing context, switching models, locking down permissions, triggering predefined workflows.

Most people discover them by accident. This guide is the deliberate version.

Type / in any session and you’ll see a filterable list of everything available. Commands are only recognized at the start of a message, and whatever follows the command name gets passed to it as arguments. Since Claude Code ships updates constantly, /help is always the authoritative source for what’s actually installed in your version — don’t trust any list that claims to be complete, including this one.

There are four kinds of commands worth knowing about. Built-in commands like /help, /clear, and /model are hardcoded into the CLI and execute fixed logic. Bundled skills like /debug, /simplify, /batch, and /loop ship with Claude Code but are prompt-based — they hand Claude a detailed playbook and let it orchestrate the work. User skills are ones you define yourself in .claude/skills/ or ~/.claude/skills/. And MCP and plugin commands are exposed by external servers, namespaced like /mcp__github__list_prs.

One terminology note before moving on: custom slash commands have been merged into skills. Files in .claude/commands/ still work, but .claude/skills/<name>/SKILL.md is the recommended approach now. When a skill and a legacy command share the same name, the skill wins.

Session and context management is where most of your command usage will land.

/compact compresses conversation history into a summary, freeing up context window space while preserving the thread. You can pass an instruction: /compact Preserve decisions, final approach, and any TODOs. The right habit is to compact proactively at logical milestones — not when the context is already full, because by then the summaries get messy.

/clear is the hard reset. It wipes conversation history entirely, though file edits from the session stay on disk. The distinction matters: /compact keeps Claude oriented on what happened; /clear starts fresh with no memory of the session at all. Use clear when switching to something completely unrelated.

/context shows where your context window is being spent so you can decide which one to reach for. Pair it with /cost (API users) or /stats (Pro and Max subscribers) for a picture of what the session has consumed.

/rewind rolls code and conversation back to an earlier checkpoint. Esc Esc opens the same menu and lets you choose between rewinding code only, conversation only, or both. Rather than arguing a session back to the right answer, rewind and re-prompt — it’s almost always faster.

/resume (also /continue) picks up an earlier session. Without arguments it opens a session picker; with a name it jumps straight there. From the terminal, claude -c resumes the most recent session and claude -r <id> resumes by ID.

/branch — renamed from /fork in v2.1.77 — forks the current conversation into a new session when you want to try a different approach without losing where you are.

/btw lets you ask a side question while Claude is working without polluting the main conversation context. Use it freely for “wait, how does X work” tangents.

Setup and configuration commands are mostly one-time-per-project, but they compound.

/init scans the repository and generates a starter CLAUDE.md — a markdown file Claude reads at the start of every session in that repo. Run it once, refine the output, and commit it to version control. Your team gets the context automatically.

/memory opens the relevant CLAUDE.md for editing. Two layers worth knowing: the project file at your repo root, and ~/.claude/CLAUDE.md for instructions that apply across every project. The # prefix at the start of any message also persists a quick note to memory without opening the file.

/model switches the active model mid-session. Sonnet for routine work and exploration; Opus for genuinely hard problems. Alt+P does the same thing while preserving whatever you’ve typed. Some teams just pick a model at launch with claude --model opus and leave it — switching mid-session can occasionally create context inconsistencies.

/effort adjusts the reasoning budget per turn: low, medium, high, or max (Opus 4.6 only). Lower effort is faster and cheaper; higher effort thinks longer before answering.

/plan switches into plan mode, where Claude proposes each action and waits for approval before executing. Worth using before any large refactor or anything touching code paths you can’t easily roll back.

/permissions shows what Claude can read, write, and execute, and lets you tune the approval rules. Pre-approve routine operations; keep manual approval for anything that could cause real damage.

/config opens the settings TUI. /doctor diagnoses install and runtime issues — run it first when something seems broken.

Review and quality commands are your checkpoint layer.

/diff opens an interactive diff viewer showing everything that changed during the session. Toggle between a full git diff and per-turn diffs; navigate files with arrow keys. The per-turn view is particularly useful for tracing when a specific change happened. Run it after a series of edits, always before committing.

/review runs a deeper read-only pass — bugs, style issues, performance problems, missing tests. You can scope it: /review Focus on security issues only or /review Check the database query performance.

/security-review is a focused pass for SQL injection, XSS, exposed credentials, insecure configurations. Use it before touching anything user-facing.

/simplify is a bundled skill that cleans up recent files — lighter than /review, more about efficiency than auditing.

/debug helps trace a failing flow when the cause isn’t obvious. Especially useful paired with /diff afterward to see what changed.

Skills, agents, and integrations extend what Claude Code can do beyond the built-in toolkit.

/agents manages subagents — specialized configurations Claude can delegate to. Built-in agents include Explore for read-only codebase work, Plan for planning without execution, and general-purpose. Subagents run with their own context, so delegating verbose work (test runs, log analysis, broad searches) keeps your main session clean.

/mcp manages Model Context Protocol server connections. Connecting a GitHub MCP server gives you /mcp__github__list_prs, /mcp__github__create_pr, and so on. From the terminal, claude mcp add connects servers and claude mcp serve exposes Claude Code itself as an MCP server.

/install-github-app sets up the Claude GitHub App for pull request workflows via GitHub Actions. Separate from the MCP server — the app handles PR-side automation, MCP handles in-session operations.

Custom skills are where the real leverage lives, and most teams are underusing them.

A skill is a SKILL.md file with optional YAML frontmatter and markdown instructions. The filename or name field becomes the slash command; the markdown becomes the prompt Claude sees when you invoke it. Skills live in .claude/skills/<name>/SKILL.md for project-specific use (commit these), ~/.claude/skills/<name>/SKILL.md for personal use across all projects, or managed locations for org-wide distribution.

Here’s a minimal deploy skill:

---
name: deploy
description: Deploy the application to production
disable-model-invocation: true
allowed-tools: Bash(npm run deploy:*) Bash(git status *)
---

Deploy $ARGUMENTS to production:

1. Run the test suite
2. Build the application
3. Push to the deployment target
4. Verify the deployment succeeded

A few things to understand about that frontmatter. The description field is what Claude uses to decide whether to load this skill automatically — front-load the key use case, since it gets truncated at 250 characters. disable-model-invocation: true means only you can trigger it; Claude won’t decide on its own that now is a good time to deploy. allowed-tools grants those bash patterns without per-use approval while the skill is active.

$ARGUMENTS captures whatever follows the command name. /deploy staging substitutes “staging” wherever $ARGUMENTS appears. You can also access positional arguments with $0, $1, $2 — useful for skills like /migrate-component SearchBar React Vue that take multiple distinct inputs.

A couple of more advanced patterns: the !`command` syntax runs a shell command before the skill reaches Claude and substitutes the output inline, which is useful for injecting live data (like a gh pr diff) into a PR summary skill. And context: fork runs the skill in an isolated subagent, keeping your main conversation clean for long-running research.

Treat skills as code. Review them in pull requests, version them, and refine descriptions over time. The value compounds as you tighten them.

A few workflow sequences worth having in your muscle memory:

Starting a new repo — run claude in the project root, then /init, review and refine the generated CLAUDE.md, set up MCP servers, define subagents, tune permissions, and /doctor to verify. Ten minutes of setup that pays back constantly.

Before a large change — switch to /plan, let Claude propose the approach, discuss it, then execute. Use /diff periodically to catch mistakes before they compound.

Mid-session — when you finish one logical chunk of work, /context to see where you stand, then /compact before the next phase. /clear only if you’re switching to something completely unrelated.

Before committing — /diff to inspect everything, /review for quality, /security-review if anything is sensitive. Then commit.

Cost control — check /cost or /stats periodically. If spending climbs, /model sonnet, /effort low, or /compact to shrink context. Delegating verbose work to subagents helps too.

The common mistakes are predictable.

Chaining commands in one prompt — /review then /compact then /continue — looks efficient but produces worse output than running them one at a time. Each command needs room to complete cleanly.

Switching models mid-task. Better to start a session with the model you want, or use /model only at clean boundaries between subtasks.

Waiting until the context window is full before compacting. By then Claude is already degraded, and the summary reflects that. Compact early.

Treating skills as one-shot prompts rather than things you iterate on. The real value is in the refinement: tighter descriptions, narrower allowed-tools, large reference material moved to supporting files so SKILL.md stays focused. Keep it under 500 lines.

/help is always the authoritative source. Commands ship and rename frequently — /fork became /branch recently, there will be more. The official docs at docs.claude.com cover the full command reference, skills, subagents, hooks, and plugins. Once the daily commands feel automatic, skills are the next thing worth putting time into.

More from AI For Developers

This newsletter is part of AI For Developers — a growing directory of AI developer tools, APIs, frameworks, and resources. If you’re evaluating tools for your stack or just want to stay on top of what’s out there, check it out:

🔗 AI For Developers — Browse the directory

📬 AI For Developers newsletter — Subscribe to the newsletter

Every issue covers one topic in depth — no fluff, no hype, just the stuff you need to build with AI. Subscribe if you haven’t already, and I’ll see you in the next one.

DeepSeek V4 dropped on April 24, 2026. Same day OpenAI released GPT-5.5. The timing is almost certainly deliberate, but that’s not what makes this interesting.

What makes this interesting is the price tag.

Two Models, One Mission

V4 comes in two variants.

DeepSeek-V4-Pro is the flagship — 1.6 trillion total parameters with 49 billion active per token. The one you reach for on hard tasks.

DeepSeek-V4-Flash is the fast workhorse — 284 billion total parameters, 13 billion active. Surprisingly close to Pro on most benchmarks, at a fraction of the cost.

Both use a Mixture of Experts (MoE) architecture, which is why those numbers aren’t as scary as they sound. Only a small fraction of parameters actually fire for each token — so inference costs stay low even at massive parameter counts. Both support a 1 million token context window. Both are MIT-licensed and available as open weights on Hugging Face.

The headline technical upgrade is the Hybrid Attention Architecture — a new mechanism combining Compressed Sparse Attention and Heavily Compressed Attention. The practical outcome: at 1M tokens, V4-Pro requires only 27% of the inference compute and 10% of the KV cache that V3.2 needed. That’s the difference between a 1M context window being theoretically available and actually being affordable to use in production.

The Pricing. This Is the Part You Need to See.

Let’s skip straight to what matters for anyone shipping products.

DeepSeek V4-Flash costs 0.28 per million output tokens. That makes it the cheapest model at its capability tier — less than every Flash, Mini, and Nano offering from every major Western provider.

DeepSeek V4-Pro costs 3.48 per million output tokens. Less than GPT-5.4’s input price alone. About one-ninth of Claude Opus 4.7’s output cost.

For context, here’s where the major models land on output pricing per million tokens: DeepSeek V4-Flash at 0.50, Gemini 3 Flash at 3.48, GPT-5.4 at 12.00, GPT-5.5 at 75.00.

To make it concrete, imagine a pipeline generating 100 million output tokens per month:

Running on GPT-5.5: $3,000/month. Running on Claude Opus 4.7: $7,500/month. Running on DeepSeek V4-Pro: $348/month.

That’s a 9 to 22x cost difference. Not a rounding error. A different category of economics.

How Does It Actually Perform?

DeepSeek published something unusual alongside the release: a candid self-assessment. They state directly that V4-Pro “trails state-of-the-art frontier models by approximately 3 to 6 months.” You don’t often see AI labs publish their own gap estimates — it’s either genuine intellectual honesty or very smart expectation management. Either way, it’s worth noting.

Here’s where V4 stands on the benchmarks developers actually care about.

Coding. V4-Pro reaches a 3,206 Codeforces rating, ranking 23rd among human competitors worldwide. On SWE-bench and agentic coding tasks, DeepSeek’s internal evaluation places V4-Pro above Claude Sonnet 4.5 and approaching Claude Opus 4.5. V4-Flash alone leads all open-source models in coding benchmarks. Independent verification is still coming, but DeepSeek’s R1 numbers held up almost perfectly under external testing — which gives these claims more weight than the average model-launch hype.

Reasoning and Math. V4-Flash-Max scores 81.0 on Putnam-200 Pass@8, against 35.5 for Seed-2.0-Pro and 26.5 for Gemini 3-Pro. On Putnam-2025 formal math, V4 achieves a proof-perfect 120/120. These aren’t close races.

World Knowledge. V4-Pro leads every open-source model, trailing only Gemini 3.1 Pro among all models — open or closed.

Long Context. The 1M token window is real and usable, not a marketing number. The new attention architecture maintains quality as context grows — a problem that seriously degraded previous long-context models. You can load an entire codebase or a book-length document in a single prompt and it holds together.

The honest summary: V4-Pro isn’t the best model alive. But at its price point, it doesn’t need to be.

The Developer Experience

Migration is one line of code. If you’re already on the DeepSeek API, you change the model string and nothing else. The base URL stays identical. The API supports both OpenAI ChatCompletions and Anthropic API formats — so your existing client code works without modification.

# Before
response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[...]
)

# After — literally just this
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[...]
)

Three reasoning modes. Both models support Non-Thinking (fast, direct responses), Thinking (standard chain-of-thought), and Think Max (maximum reasoning budget — set your context window to at least 384K tokens for best results). Flash-Max is surprisingly competitive with Pro-Max on reasoning benchmarks when given enough thinking budget, making Flash a great cost-efficient default for complex pipelines that don’t need Pro’s deeper world knowledge.

⚠️ Deprecation deadline. The old deepseek-chat and deepseek-reasoner endpoints are being retired on July 24, 2026 at 15:59 UTC. They currently route to V4-Flash equivalents, but after that date they stop responding. Put this on your calendar now.

Running it locally. V4-Flash weighs 160GB on Hugging Face — potentially runnable on a 128GB M5 MacBook Pro with light quantization. V4-Pro is 865GB, so you’ll need a multi-GPU setup or cloud infrastructure. Unsloth is already working on quantized versions. For local inference, vLLM 0.9+ with --tensor-parallel-size 2 gives you an OpenAI-compatible endpoint at localhost:8000/v1 — and any existing OpenAI client points straight at it with a one-line URL change.

The Geopolitics. You Can’t Skip This Part.

DeepSeek V4 runs on Huawei Ascend 950 chips — not Nvidia GPUs. Huawei announced that its Ascend supernode fully supports V4 out of the box, making the model deployable at scale on Chinese domestic hardware, entirely outside US export controls. This is the first frontier-class open model that doesn’t need American chips to run at scale.

For developers, this has a very practical consequence: data residency and regulatory risk. Multiple US states, Australia, South Korea, and several EU countries introduced restrictions on DeepSeek R1 citing national security and data privacy concerns. V4 is subject to the same landscape.

If you’re building for regulated industries — government, healthcare, defense, fintech — check your compliance requirements before routing production traffic through DeepSeek’s hosted API. If you’re self-hosting V4, the model weights are MIT-licensed and those concerns largely evaporate. The weights are just weights.

So — Should You Switch?

Reach for V4-Flash when you’re running high-volume pipelines where cost dominates, you need fast responses on tasks that don’t require deep world knowledge, or you want a cheap first-pass model in a tiered routing setup. At 0.28 per million tokens, it’s the new default for anything that doesn’t need frontier performance.

Reach for V4-Pro when you need frontier-level coding and agentic reasoning but the 9–22x price difference over GPT-5.5 or Claude Opus 4.7 is eating your margins, or when you’re working with large codebases where the efficient 1M context window actually matters.

Stay on closed models when you’re in a regulated environment where Chinese-hosted infrastructure is a compliance issue, you need the absolute ceiling of performance (GPT-5.5 leads on terminal agents, Claude Opus 4.7 leads on reasoning and writing quality), or you need deep ecosystem integration — Grok 4 for real-time X data, Gemini for Google Workspace.

The Bottom Line

DeepSeek V4 is the clearest proof yet that frontier AI performance and frontier AI pricing are being permanently decoupled.

A year ago, R1 proved you didn’t need $100M in compute to build a world-class reasoning model. V4 extends that thesis: you don’t need to pay OpenAI or Anthropic prices to get within 3–6 months of the frontier.

Independent benchmarks will close the story over the next week or two. But given DeepSeek’s track record — every self-reported R1 number held up under external scrutiny — V4’s claims deserve to be taken seriously.

If you’re not running V4 in a test environment by end of this month, you’re leaving a significant cost optimization on the table. At these prices, the experiment costs you almost nothing.

Links

• DeepSeek V4 on Hugging Face — open weights, MIT license

• DeepSeek API Docs — migration guide, thinking mode reference, deprecation timeline

• Full Technical Report (PDF) — DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence

More from AI For Developers

This newsletter is part of AI For Developers — a growing directory of AI developer tools, APIs, frameworks, and resources. If you’re evaluating tools for your stack or just want to stay on top of what’s out there, check it out:

🔗 AI For Developers — Browse the directory

📬 AI For Developers newsletter — Subscribe to the newsletter

Every issue covers one topic in depth — no fluff, no hype, just the stuff you need to build with AI. Subscribe if you haven’t already, and I’ll see you in the next one.

This guide walks you through everything you need to actually use it: what it is, how to set it up, how to prompt it well, how to iterate, how to hand off to engineering, and what to avoid. By the end you’ll be able to take a project from idea to shipped prototype without leaving the tool.

Claude Design in one minute

Before you start

Who can use it. Claude Design is in research preview and available on Pro, Max, Team, and Enterprise plans. On Enterprise it’s default off, so if you don’t see it, ask your admin to provision you.

What it’s for. Reach for Claude Design when you need to produce interactive prototypes (working HTML/CSS with real states you can click through), marketing pages like landing pages and pricing sections, internal tools like admin dashboards or review queues, presentations and one-pagers, and app flows like onboarding or multi-step forms.

What it isn’t for. Don’t reach for it when you need pixel-perfect finishing work on an existing Figma file, or when you’re doing brand-identity work like logos, illustrations, or photography. For polish and finishing, export to Canva and continue there.

Set expectations for the output. The first generation is a starting point, never a finished artifact. The real value shows up in the second, third, and fourth rounds of iteration. Plan for that — don’t judge the tool by its first response.

Getting set up

Open a project. Go to claude.ai/design and create a new project. The interface splits into two panes: chat on the left, canvas on the right. Everything else builds on that structure.

Feed it context before you prompt. This is the step most people skip, and it’s the one that determines whether your output looks generic or looks like your product. Before you write your first prompt, attach whatever context is relevant.

Upload screenshots of existing designs, competitor products, or visual inspiration — useful for “make it look like this” requests. Attach an existing slide deck or document whose style you want Claude to match. Link a code repository directly, and Claude will read your components, tokens, and styling patterns, which makes the output dramatically closer to production-ready.

If your team has already set up a design system in Claude Design, it gets inherited automatically — your brand colors, fonts, and components are already in place with no configuration. Check with your design lead or admin if you’re not sure.

Link a subdirectory, not your whole monorepo. If you’re working in a large codebase, don’t link the root. Link the specific subdirectory relevant to the UI you’re building, like apps/marketing or packages/design-system. Large repos cause lag and occasional browser issues.

Writing a first prompt that works

A weak prompt gets a generic result. A good prompt hits four things: the goal (what you’re building), the layout (how it should be arranged), the content (what information goes on it), and the audience (who uses it).

Here’s a weak prompt:

“Make me a landing page for our new API.”

And here’s a strong one:

“Build a landing page for our new Payments API aimed at backend developers. Include a hero with a one-line tagline and a curl code snippet, three feature cards with icons, an interactive API playground mock, pricing tiers, and a footer. Match the style of our existing marketing site.”

You’ll feel the difference immediately. Claude will also ask clarifying questions if it needs more information, so you don’t have to front-load everything — but the more specific you are upfront, the fewer iterations you’ll burn later.

A few templates that tend to work as starting points:

• “Create a dashboard showing [metric] with filters for [dimension] and [dimension].”

• “Design a mobile app onboarding flow with [N] screens that walks users through [features].”

• “Build a landing page for [product] with a hero section, [sections], and pricing.”

• “Create a form for [purpose] with conditional questions based on [category].”

• “Design an internal tool for [team] to [action].”

Iterating: chat vs. inline comments

Claude Design gives you two ways to request changes. Knowing which to use when is the biggest productivity gain you’ll get after prompting well.

Use chat for broad changes. Anything structural, aesthetic, or conceptual goes in the chat — things like “make the color scheme darker and more minimal,” “rearrange the dashboard so metrics are in the top row and the chart is below,” “add a settings panel on the right side,” or “show me two or three alternative layouts for this page.”

Chat is also where you ask Claude to explain its design decisions, suggest improvements, or review the design for accessibility. Treat it as a design collaborator, not just a generator.

Use inline comments for targeted changes. Click directly on an element on the canvas and pin a comment to it. This is much faster than describing the location in chat. Good inline comments look like “make this button padding larger,” “change this to a dropdown instead of radio buttons,” “use the primary brand color here,” or “make this section collapsible.”

The rule of thumb. Comments for component-level changes. Chat for structural or aesthetic changes. If you’re describing which element you mean in chat, you should be using a comment instead. If you’re restructuring the layout, you should be using chat.

If comments go missing. There’s a known bug where inline comments occasionally disappear before Claude reads them. If a comment isn’t being picked up, paste the exact text into the chat instead.

Using adjustment knobs

Beyond chat and comments, there are live controls for spacing, color, and layout that you can tweak without prompting. Use these when you want to try several values quickly — sliding padding from 8px to 16px to 24px to see which feels right — and then ask Claude to apply your final choice across the full design. This saves you from burning prompts on “try 12px... now try 16px... now 20px.”

Exploring variations without losing your work

If you’re unsure about a direction, don’t commit — ask for alternatives:

“Show me 2–3 alternative layouts for the hero section.”

If you want to try a completely different direction without abandoning your current one, tell Claude:

“Save what we have and try a completely different approach.”

Claude will save the current project and confirm where it’s saved, so you can reference earlier iterations later in the conversation. This is the closest thing to version control the tool has today, so use it intentionally.

Getting better output: field-tested tips

A few habits that separate a frustrating session from a productive one.

Start simple, then layer in complexity. Core layout and content first. Then interactions. Then edge cases. Then polish. Incremental requests produce better results than a single giant prompt.

Be specific in feedback. “This doesn’t look right” is hard to act on. “Tighten the spacing between form fields to 8px” gives Claude exactly what it needs.

Reference your design system by name. “Use the Primary Button component” or “Apply the Card layout pattern” will get you a much closer match than “make this look on-brand.”

Mention responsiveness upfront. Say whether the design needs to work on mobile, tablet, and desktop — or just one of those. Retrofitting responsiveness later is painful.

Ask Claude to review its own work. Claude can audit for accessibility, contrast ratios, information hierarchy, and general usability. It’s an underused feature.

Exporting and sharing

When the design is ready, click Export in the upper right. You have several options.

PDF works for stakeholder review. PPTX is good for slide decks. Standalone HTML is the format to use when you want to host the interactive prototype somewhere yourself. .zip gives you the raw assets. Send to Canva opens the design as a fully editable Canva file, via an official integration with Canva — this is the right move when you want to hand off to a designer for polish. An internal URL is shareable within your organization with view, comment, or edit permissions. And Handoff to Claude Code sends the design to your local coding agent or to Claude Code Web.

A quick way to choose the format: if you need stakeholder feedback, use an internal URL with comment access. If you’re presenting in a meeting, export to PPTX or PDF. If you want a live interactive prototype someone can click through, use standalone HTML. If you want a designer to polish it, send to Canva. If you want to ship it as a real feature, hand off to Claude Code.

Handing off to Claude Code

This is the feature that makes Claude Design genuinely different from every other AI design tool. When you’re ready to build, Claude packages the design into a handoff bundle — design intent, component structure, and styling context all included — and sends it to Claude Code with a single instruction.

You have two options: send it to the local coding agent, which picks up Claude Code on your machine against your actual repository, or send it to Claude Code Web, which runs in the cloud.

The coding agent isn’t reverse-engineering a screenshot. It’s implementing a design it has structured metadata about. The practical effect: you can go from “I should probably build this” to a working feature branch in an afternoon, without a traditional design-to-dev handoff ever happening.

Collaboration

Projects have three permission levels for sharing within your organization. View is read-only. Comment lets viewers leave comments but not modify the design. Edit lets colleagues modify the design and chat with Claude together in a group conversation.

The group conversation piece is the interesting one — multiple humans prompting Claude simultaneously on the same canvas. Collaboration is still basic, not yet fully real-time multiplayer, but the foundation is there.

Pricing and limits

Claude Design is priced and metered independently from the rest of Claude. It has its own weekly allowances that reset every seven days, sitting alongside (not inside) your existing chat or Claude Code limits. Allowances are per-user, not pooled across your organization.

On individual plans, Pro is aimed at quick explorations and one-off use. Max 5x is for semi-regular use — PMs and engineers producing regular mockups. Max 20x is for power users: designers and creatives living in the tool.

On Team plans, each provisioned user gets a weekly allowance; Standard seats are sized for quick explorations, Premium seats for power users. Admins can purchase extra usage for anyone who needs more capacity.

On Enterprise, there are two billing models. Legacy seat-based works like Team — Standard and Premium seats, each with recurring weekly allowances. Usage-based Enterprise bills at standard API rates under your existing agreement, with a one-time credit covering roughly 20 prompts per user that expires on July 17.

One thing to flag for ops and compliance: Claude Design is a Labs release and does not yet support audit logs or detailed usage tracking. If that’s a blocker for your org, plan accordingly.

Known issues and workarounds

The rough edges Anthropic acknowledges today, with fixes.

If inline comments occasionally disappear before Claude reads them, paste the comment text into the chat. If you hit save errors in compact layout view, switch to full view and retry. If linking a large monorepo causes lag or browser issues, link a specific subdirectory instead of the repo root. If you hit a “chat upstream error,” start a new chat tab inside the same project. And if the design-system import produces messy output, it’s probably because the source codebase is messy — clean it up or set up the design system manually.

A complete workflow, end to end

Putting it all together, here’s what a realistic session looks like when you go from idea to shipped code.

Open Claude Design and create a new project. Attach context — a reference screenshot, and link your frontend repo, subdirectory and not the root. Write a specific first prompt using the goal, layout, content, and audience structure. Let Claude ask clarifying questions and answer them.

Review the first generation without judging it too hard — it’s a starting point. Iterate broadly in chat for things like palette, layout, and alternate directions. Iterate surgically with inline comments for spacing, component swaps, and color tweaks. Ask Claude to review the design for accessibility and contrast. If you want to explore a different direction, tell Claude to save the current version before pivoting.

Export to standalone HTML for a quick shareable preview. Gather feedback via an internal URL with comment access. When it’s approved, hand off to Claude Code to implement it against your actual codebase. Ship.

That loop — prompt to prototype to production, entirely inside one ecosystem — is what Claude Design is actually selling. Everything else in this guide is technique for making each step of the loop go faster.

More from AI For Developers

This newsletter is part of AI For Developers — a growing directory of AI developer tools, APIs, frameworks, and resources. If you’re evaluating tools for your stack or just want to stay on top of what’s out there, check it out:

🔗 AI For Developers — Browse the directory

📬 AI For Developers newsletter — Subscribe to the newsletter

Every issue covers one topic in depth — no fluff, no hype, just the stuff you need to build with AI. Subscribe if you haven’t already, and I’ll see you in the next one.

Subscribe now

Claude Cowork is Anthropic’s answer to a question developers have been asking since Claude Code took off: what if non-technical teammates could use this too?

Launched in January 2026 as a research preview and promoted to general availability in April 2026, Cowork takes the same agentic architecture behind Claude Code — file access, multi-step execution, tool integration — and wraps it in the Claude Desktop app with a UI anyone can use. No terminal required.

If you’ve been watching the agentic AI space heat up with Microsoft’s Copilot Cowork, Google’s Gemini Agent Mode, and OpenAI’s Operator, Cowork is Anthropic’s entry: a desktop-native agent that reads, edits, and creates files on your machine while you step away.

This guide covers everything: what Cowork is, how to set it up, what it can actually do, and the advanced features that make it worth paying attention to.

What Is Cowork, Really?

In regular Claude chat, you type a message and get a response. Claude can’t touch your files. It can’t produce a finished deliverable. You copy-paste back and forth.

Cowork changes that relationship. You point Claude at a folder on your computer, describe what you want done, and Claude works through it — reading files, writing documents, creating spreadsheets, organizing folders — while you watch or walk away.

Under the hood, Cowork runs inside a sandboxed virtual machine on your desktop (using Apple’s Virtualization Framework on macOS). Your files are mounted into this container, which means Claude gets real filesystem access while staying isolated from the rest of your system.

Think of it this way:

• Chat = you ask, Claude answers

• Cowork = you assign, Claude delivers

Who Is It For?

Cowork was built for knowledge workers who aren’t developers but have the same kinds of repetitive, file-heavy tasks that Claude Code handles so well for engineers.

Anthropic reports that the majority of Cowork usage comes from outside engineering — operations, marketing, finance, legal, and research teams. The pattern they’re seeing: people aren’t handing Claude their core judgment work, but rather the assembly work that surrounds it. Project updates, collaboration decks, research sprints, data organization.

That said, developers benefit too. If you’re already a Claude Code user, Cowork gives you a friendlier interface for non-coding tasks: organizing documentation, compiling reports from scattered notes, processing data files.

Requirements and Setup

What You Need

• Claude Desktop app (macOS or Windows) — download at claude.com/download

• A paid Claude plan: Pro ($20/month), Max ($100 or $200/month), Team, or Enterprise

• Active internet connection throughout your session

• Desktop must stay awake and app must stay open while Claude works

Windows Users

If you’re on Windows, you can download a readiness checker from the Claude help center to verify your system supports Cowork before installing.

Getting Started

1. Download and install (or update) the Claude Desktop app

2. Open the app and find the mode selector

3. Click the Cowork tab to switch from Chat mode

4. You’ll land in the Tasks view — click + New task to begin

Your First Cowork Task

Starting a task is straightforward:

1. Click + New task

2. Optionally attach a folder by clicking the folder icon — this gives Claude access to read and write files in that directory

3. Type your prompt describing what you want done

4. Click Let’s go

Claude will analyze your request, propose a plan, and start executing. You’ll see progress indicators showing what it’s doing at each step.

A Good First Task

A classic starter is file organization:

Look at my Downloads folder. Scan the contents and propose a plan:
- Categories/folders to create
- How files should be sorted
- Any naming conventions to apply
- Files to flag for review or deletion

Show me the plan before making changes.

Notice the last line — asking Claude to show the plan before acting. This is important. Cowork gives Claude real write access to your files, so building in checkpoints is good practice.

How Execution Works

When Claude receives your task, it:

1. Analyzes the request and creates a plan

2. Breaks complex work into subtasks when needed

3. Runs code and shell commands in the isolated VM

4. Coordinates multiple workstreams in parallel if appropriate

5. Loops you in before anything significant

You can steer at any point — redirect, refine, or change approach mid-task.

What Cowork Can Do: Core Capabilities

File Operations

Cowork’s foundation is filesystem access. Claude can read, create, rename, move, and delete files in folders you grant access to. This covers:

• Sorting and renaming chaotic folders

• Deduplicating files

• Extracting text from PDFs and images

• Converting between file formats

Document Creation

Cowork has built-in skills for producing office files: Word documents (.docx), PowerPoint presentations (.pptx), spreadsheets (.xlsx), and PDFs. These aren’t chat-style outputs — they’re real, editable files saved to your filesystem.

Example prompt:

This folder contains our Q3 operating expenses spreadsheet.
Analyze the data and create a Word document report covering:
- Total annual spending
- Breakdown by category with percentages
- The three largest expense categories
- Month-over-month trends

Format it professionally with clear sections, tables,
and an executive summary.

Research and Synthesis

Claude can combine local files with web research to produce comprehensive outputs. Point it at a folder of notes, articles, or data files and ask it to synthesize a report, identify themes, or build a briefing document.

Data Processing

Feed Claude receipt screenshots, expense reports, or raw data files, and it can extract, categorize, and structure the information into clean spreadsheets.

The Customization Stack: Skills, Connectors, and Plugins

This is where Cowork gets powerful. The customization system has three layers that build on each other.

Skills

Skills are instruction files that tell Claude how to do specific kinds of work. They govern output format, tone, methodology, and quality standards.

Cowork ships with built-in skills for common file types (pdf, docx, pptx, xlsx). But custom skills are where things get interesting.

You can create a skill for anything: your brand voice, your report format, your review framework. Once installed, the skill applies automatically whenever Claude does relevant work.

To create a custom skill:

Use the built-in Skill Creator — it interviews you about what you want, then generates a properly structured skill file you can install and toggle on or off.

To browse and install skills:

1. Go to Customize in the left sidebar

2. Click the Skills tab, then the + button

3. Select Browse skills to see available options

For more on browsing all customization options, see Browse skills, connectors, and plugins.

Connectors

Connectors link Claude to external services and data sources. In regular Claude chat, connectors pull information. In Cowork, they gain filesystem access — meaning a connector that fetches data from an external service can now save that data locally, or use local files as input.

The connector catalog includes hundreds of options: Gmail, Google Calendar, Slack, Notion, Asana, Linear, Jira, AWS, Salesforce, and many more. Both web connectors and desktop extensions are available.

To browse connectors:

Go to Settings > Connectors > Browse connectors. You’ll see two tabs: Web and Desktop extensions.

Plugins

Plugins are the highest-level building block. A plugin bundles skills, connectors, slash commands, and sub-agents into a single installable package tailored to a specific job function.

Anthropic open-sourced 11 starter plugins on GitHub covering roles like sales, finance, legal, marketing, HR, engineering, design, and operations. Each comes pre-configured with relevant skills and connectors. There are also specialized financial services plugins for investment banking, equity research, private equity, and wealth management.

To install a plugin:

1. Switch to the Cowork tab

2. Click Customize in the left sidebar

3. Click Browse plugins

4. Click Install on your chosen plugin

After installing, Claude walks you through customizing the plugin — adjusting skills and connectors to match your specific workflow and tools. For more details, see Use plugins in Cowork.

Building your own plugin:

You can build a plugin from scratch using Plugin Create, a built-in tool. Describe what you want — even a sentence is enough — and Claude assembles the skills, connectors, and commands into a plugin package.

Alternatively, start from any Anthropic template and modify it. Plugins are just markdown files and JSON, so no code or infrastructure is needed.

Projects: Persistent Workspaces

Introduced in March 2026, Projects solved Cowork’s biggest early limitation: every session started from zero. You had to re-explain context and re-upload files each time.

A Cowork Project is a dedicated workspace with:

• Instructions — tone, formatting, rules that apply to every task in the project

• Context — a local folder, linked chat project, or URLs for Claude to reference

• Memory — Claude remembers context from previous tasks within the project

• Scheduled tasks — recurring automation scoped to the project

• Conversation history — a persistent thread that doesn’t bleed into other work

Think of Projects as separate desks for separate jobs, instead of one cluttered desk for everything.

Creating a Project

1. Open Cowork

2. Go to Projects in the left sidebar

3. Click + and choose your method:

   • Create from scratch

   • Import from an existing Claude chat project

   • Use an existing folder

4. Name it, set instructions, attach files, and click Create

Memory Within Projects

Memory is scoped per project. What Claude learns in your marketing project doesn’t leak into your finance project. Over time, Claude picks up patterns — it might notice recurring themes in weekly reports or remember your preferences for how data should be formatted.

Scheduled Tasks: Automation on Autopilot

This is the feature that changes Cowork from a tool you use to a tool that works for you.

You write a prompt once, pick a cadence (daily, weekly, monthly), and Claude runs it automatically. No code, no APIs, no cron jobs. For full details, see Schedule recurring tasks in Cowork.

Setting Up a Scheduled Task

1. Open Cowork and start a new task (or open an existing one)

2. Type /schedule in the chat input

3. Claude walks you through defining the task and cadence

4. Once confirmed, the task runs on schedule

Scheduled tasks have access to everything regular tasks do: connectors, plugins, skills, sub-agents.

Practical Examples

Here are some high-value scheduled tasks:

Morning briefing:

Check my email and calendar for today.
Summarize any messages that need a response
and list my meetings with relevant context.
Save the briefing as a markdown file in my
/daily-briefs folder.

Weekly report compilation:

Every Friday, compile data from the /project-updates
folder into a formatted status report.
Include progress against milestones,
blockers flagged this week, and key metrics.

Recurring file cleanup:

Every Sunday, organize my Downloads folder by type
and delete anything older than 30 days.

Important Limitations

• Tasks only run while your computer is awake and the Claude Desktop app is open

• If your machine is off during a scheduled run, the task gets skipped (but shows up in task history and auto-runs when you reopen the app)

• Scheduled tasks consume more usage than regular chat

Dispatch: Remote Control from Your Phone

Dispatch lets you assign tasks to your desktop Cowork agent from your phone. Your desktop stays active and does the work; your phone is just the remote.

Setup

1. Open Cowork on your desktop

2. Click Dispatch in the left side panel

3. Follow the setup flow to connect your mobile app

4. Enable file access and keep-awake settings

What You Can Do

From your phone, you can:

• Ask Claude to pull data from a local spreadsheet and compile a summary

• Have Claude search your Slack and email, then draft a briefing document

• Request a formatted presentation built from files in your Drive

• Tell Claude to organize files in a specific folder

Your desktop must be active for this to work. Claude uses the same connectors, plugins, and file access you’ve already configured.

Safety Note

Dispatch creates a chain where mobile instructions trigger real actions on your desktop — including reading, moving, or deleting files. A manipulated instruction or unexpected command could cascade. Only use this if you’re comfortable with what your agent could do, not just what you intend it to do. For more, see Use Cowork safely.

Sub-Agents: Parallel Execution

When Claude gets a complex task, it can spin up sub-agents — parallel workers that each handle a piece simultaneously.

Instead of reading 20 files one at a time, Claude might create five sub-agents that each process four files at once. One agent researches a company while another pulls CRM data and a third scans Slack for context.

Sub-agents run in parallel or in sequence, each with its own focus and fresh context window. You don’t configure this directly — Claude decides when parallel execution makes sense based on the task complexity.

Enterprise Features (GA Launch, April 2026)

The April 2026 general availability launch added features specifically for enterprise deployment:

• Role-based access controls — admins manage who can access Cowork and what they can do

• Group spend limits — control costs across teams

• Private plugin marketplaces — admins create curated plugin collections for their org

• Auto-installed plugins — push approved plugins to all team members

• Usage analytics — admin dashboard plus Analytics API for deeper analysis

• OpenTelemetry observability — monitoring and tracing for enterprise deployments

• Granular MCP permissions — fine-grained control over which connectors and integrations are available

Tips for Getting the Most Out of Cowork

1. Start with a CLAUDE.md File

Create a markdown file in your working folder with context about yourself, your role, your preferences, and your project. Claude reads this automatically and applies it to every task.

# About Me
- Role: Product Manager at [Company]
- I prefer concise, data-driven reports
- Use metric system for all measurements
- Default output format: Google Docs-compatible .docx

# Current Projects
- Q2 launch planning
- Customer feedback analysis

2. Be Specific About Outcomes, Not Steps

Bad: “Look at these files and do something useful”

Good: “Analyze the CSV files in this folder. Create a summary spreadsheet with one row per client, columns for total revenue, number of transactions, and average deal size. Sort by revenue descending.”

3. Build in Checkpoints

Since Cowork has real file access, ask Claude to show you the plan before executing. Use phrases like “show me the plan before making changes” or “propose your approach first.”

4. Use Folder Instructions

You can set folder-specific instructions that kick in whenever you’re working in that folder. These persist across sessions and complement your global preferences.

5. Batch Related Work

One Cowork session uses significantly more compute than a regular chat (roughly 20x by some estimates). Batch related tasks together rather than running many small sessions.

6. Test Before You Automate

Run a task manually first. Once you’re happy with the output quality, then convert it to a scheduled task with /schedule.

Cowork vs. the Competition

Here’s how Cowork stacks up against the other desktop/agent tools as of April 2026:

Claude Cowork is the only tool with full local file access (via a sandboxed VM), multi-step agentic execution, a plugin ecosystem, scheduled recurring tasks, mobile dispatch, and enterprise-grade controls (RBAC, spend limits). It runs on both macOS and Windows.

ChatGPT Desktop offers limited file access and basic multi-step execution, but lacks scheduled tasks, plugins, mobile dispatch, and has only limited enterprise controls. Available on macOS and Windows.

OpenAI Operator supports multi-step execution but only for web-based tasks — it can’t touch your local files. No scheduled tasks, no plugins, no mobile dispatch, and limited enterprise controls. Web only.

Google Mariner handles multi-step execution but is confined to Chrome. No local file access, no scheduled tasks, no plugins, no mobile dispatch, and no enterprise controls.

The short version: nobody else does what Cowork does for local file management. Operator excels at web automation but can’t touch your files. ChatGPT Desktop is still primarily a chat window. Mariner is Chrome-only.

Known Limitations

Be aware of these before you go all-in:

• No team sharing for Projects — Cowork Projects are local to your machine. For shared workflows, you still need browser-based Claude Projects.

• No cloud sync — everything happens locally. You can’t start a task on your laptop and continue on your desktop.

• Computer must stay awake — if your machine sleeps or the app closes, active tasks stop and scheduled tasks get skipped.

• Higher usage consumption — Cowork sessions use significantly more tokens than regular chat. Pro plan users will hit limits faster.

• Computer Use is macOS only — the feature where Claude controls your mouse, keyboard, and desktop apps only works on Mac currently.

• Memory is project-scoped only — Claude doesn’t retain memory across standalone Cowork sessions (only within Projects).

Pricing Quick Reference

Cowork is included on all paid Claude plans:

Pro ($20/month) — Good for getting started, but expect to hit usage limits with heavy Cowork use since each session consumes significantly more tokens than regular chat.

Max 5x ($100/month) — 5x the usage limits of Pro. This is the recommended tier for regular Cowork users who run tasks daily.

Max 20x ($200/month) — 20x the usage limits. Built for power users running heavy automation and multiple scheduled tasks.

Team (per-seat pricing) — Everything in Max plus admin controls for managing access across your team.

Enterprise (custom pricing) — The full governance layer: role-based access controls, analytics dashboard, Analytics API, OpenTelemetry observability, and private plugin marketplaces.

Getting Started Today

Here’s a 15-minute path to your first productive Cowork session:

1. Install or update the Claude Desktop app from claude.com/download (2 min)

2. Switch to the Cowork tab and start a new task (1 min)

3. Attach a folder — start with your Downloads folder or a project folder (1 min)

4. Run a simple task — file organization, document summarization, or data extraction (5 min)

5. Install a plugin that matches your role from the built-in marketplace (3 min)

6. Set up one scheduled task — a morning briefing is a great first choice (3 min)

From there, build up: create a Project for your most common workflow, add connectors to your key tools, and create custom skills for your specific standards and preferences.

The speed at which Cowork has evolved — from research preview in January to enterprise GA in April — signals that Anthropic is treating this as a core product, not an experiment. If you’re building on Claude or advising teams that use it, Cowork is worth understanding now. For a deeper dive, Anthropic offers an official Cowork training course covering the task loop, plugins, and steering techniques.

If you found this guide useful, share it with a colleague who’s drowning in file management.

— AI For Developers

If you’ve been using Claude for a while, you’ve probably noticed the pattern: you explain the same context, the same formatting rules, the same workflow — over and over again, every new conversation.

Skills fix that.

They’re one of the most underused features in Claude right now, and once you start using them, you’ll wonder how you worked without them. In this guide, I’ll walk you through everything: what skills are, how to write one from scratch, how to install and share them, and how to actually make them trigger reliably. Whether you use Claude.ai, Claude Code, or the API, this covers all of it.

Let’s get into it.

What Are Skills?

Skills are folders of instructions, scripts, and resources that extend Claude’s capabilities for specialized tasks. Think of them as reusable “expertise packages” — instead of re-explaining a workflow every time, you encode it once as a skill, and Claude applies it automatically whenever it’s relevant.

A skill can be as simple as a few lines of brand guidelines or as complex as a multi-file package with executable Python scripts, templates, and reference documents.

Skills work across Claude.ai, Claude Code, and the API.

Prerequisites

• Plan: Free, Pro, Max, Team, or Enterprise

• Code Execution: Must be enabled in Settings → Capabilities

• Enterprise plans: Organization owners must enable both Code execution and Skills in Admin settings before members can use them

• Team plans: Skills are enabled by default at the organization level

Part 1: Anatomy of a Skill

Every skill is a folder containing at minimum a SKILL.md file. Here’s what the structure looks like:

my-skill/
├── SKILL.md            ← required (instructions + metadata)
├── scripts/            ← optional: executable code
│   └── process.py
├── references/         ← optional: docs loaded as needed
│   └── style-guide.md
└── assets/             ← optional: templates, fonts, icons
    └── logo.png

The SKILL.md File

This is the core of every skill. It has two parts: YAML frontmatter (metadata) and Markdown body (instructions).

---
name: my-skill-name
description: >
  A clear description of what this skill does and when to use it.
  Include trigger phrases and contexts so Claude knows when to activate it.
---

# My Skill Name

## Overview
What this skill does and why it exists.

## Instructions
Step-by-step guidance for Claude to follow.

## Examples
Show Claude what good output looks like.

Required Metadata Fields

• name — identifier for the skill (use lowercase-kebab-case)

• description — when to trigger and what it does — this is the primary trigger mechanism

Optional Metadata Fields

• dependencies — software packages required by the skill

• license — license information or path to license file

Part 2: Writing an Effective SKILL.md

The Description Is Everything

The description field in your frontmatter is the single most important part of your skill. Claude reads every skill’s name and description to decide which skill to load for a given request. If the description doesn’t match, the skill won’t trigger.

Tips for good descriptions:

• Be specific about what the skill does AND when to use it

• Include trigger phrases and contexts

• Be a little “pushy” — Claude tends to under-trigger skills, so err on the side of over-describing when it should be used

• Mention related keywords, file types, and use cases

Bad description:

description: Format data nicely.

Good description:

description: >
  Apply Acme Corp brand guidelines to all presentations, documents,
  and marketing materials. Use this skill whenever the user mentions
  brand colors, typography, company style guide, Acme branding,
  visual identity, or asks for materials that should look “on-brand.”
  Also use when creating any client-facing deliverable.

Writing the Instruction Body

The body of SKILL.md is where you tell Claude how to do the work. Follow these principles:

1. Explain the “why,” not just the “what”

Claude is smart. If you explain why something matters, it can generalize better than if you give rigid rules.

<!-- Instead of this -->
ALWAYS use 14pt font for body text.

<!-- Do this -->
Use 14pt font for body text — this ensures readability
when printed or projected, which is common for these deliverables.

2. Use imperative form

Write instructions as direct commands.

## Steps
1. Read the uploaded file
2. Extract all table data
3. Reformat using the template in assets/template.xlsx
4. Save the output as a new file

3. Include examples

Examples are one of the most effective ways to steer Claude’s behavior.

## Commit Message Format

**Example 1:**
Input: Added user authentication with JWT tokens
Output: feat(auth): implement JWT-based authentication

**Example 2:**
Input: Fixed crash when clicking submit with empty form
Output: fix(forms): handle empty form submission gracefully

4. Define output formats explicitly

## Report Structure
ALWAYS use this template:

# [Title]
## Executive Summary
## Key Findings
## Recommendations
## Appendix

Progressive Disclosure

Skills use a three-level loading system to be efficient:

1. Metadata (name + description) — Always loaded (~100 words). Claude uses this to decide if the skill is relevant.

2. SKILL.md body — Loaded when the skill triggers. Keep under ~500 lines.

3. Bundled resources (scripts, references, assets) — Loaded on demand. Can be unlimited size.

If your skill is getting long, move detailed reference material into references/ files and point to them from SKILL.md:

## Supported Platforms
For platform-specific instructions, read the appropriate reference file:
- AWS: `references/aws.md`
- GCP: `references/gcp.md`
- Azure: `references/azure.md`

Part 3: Adding Scripts and Resources

Executable Scripts

For tasks that benefit from deterministic code (data processing, file conversion, chart generation), bundle scripts in a scripts/ directory.

my-skill/
├── SKILL.md
└── scripts/
    ├── generate_chart.py
    └── process_data.py

In your SKILL.md, reference them:

## Chart Generation
Run `scripts/generate_chart.py` with the input CSV to produce
the visualization. The script accepts:
- `--input`: path to the CSV file
- `--output`: path for the output PNG
- `--style`: one of “minimal”, “corporate”, “colorful”

Note on dependencies: Claude can install packages from PyPI (pip) and npm at runtime in Claude.ai and Claude Code. For API usage, all dependencies must be pre-installed in the container. List them in your frontmatter:

dependencies:
  - python-pptx
  - pandas
  - matplotlib

Reference Files

For large bodies of knowledge that Claude should consult selectively:

my-skill/
├── SKILL.md
└── references/
    ├── api-v1.md
    ├── api-v2.md
    └── migration-guide.md

Assets

For templates, images, fonts, or other files used in output:

my-skill/
├── SKILL.md
└── assets/
    ├── report-template.docx
    ├── company-logo.png
    └── fonts/
        └── BrandFont.ttf

Part 4: Example Skills

Simple Skill — Brand Guidelines

---
name: brand-guidelines
description: >
  Apply Acme Corp brand guidelines to presentations, documents,
  and marketing materials. Use whenever the user mentions brand
  colors, typography, company style, or creates client-facing content.
---

# Acme Corp Brand Guidelines

## Colors
- Primary: `#1a2b3c` (Navy)
- Accent: `#e74c3c` (Red)
- Background: `#f8f9fa` (Light Gray)
- Text: `#2c3e50` (Dark Gray)

## Typography
- Headings: Montserrat Bold
- Body: Open Sans Regular
- Code: JetBrains Mono

## Voice & Tone
- Professional but approachable
- Active voice preferred
- Short sentences for clarity

Medium Skill — Code Review Helper

---
name: code-review
description: >
  Review code for quality, security, and best practices. Use when
  the user asks for a code review, wants feedback on their code,
  asks “is this code good?”, or submits a pull request for review.
---

# Code Review Skill

## Review Checklist

When reviewing code, evaluate each of these areas:

1. **Correctness**: Does the code do what it claims?
2. **Security**: Are there injection risks, exposed secrets,
   or missing input validation?
3. **Performance**: Any N+1 queries, unnecessary loops,
   or missing caching opportunities?
4. **Readability**: Clear naming, appropriate comments,
   consistent formatting?
5. **Testing**: Are edge cases covered? Are tests meaningful?

## Output Format

Structure every review as:

### Summary
One paragraph overall assessment.

### Issues Found
List each issue with severity (critical / warning / suggestion),
file and line reference, and a recommended fix.

### What’s Done Well
Highlight 2-3 things the code does right — reviews shouldn’t
only be negative.

Advanced Skill — With Scripts

data-dashboard/
├── SKILL.md
├── scripts/
│   └── build_dashboard.py
└── assets/
    └── dashboard_template.html

---
name: data-dashboard
description: >
  Create interactive data dashboards from CSV or Excel files.
  Use when the user wants to visualize data, create a dashboard,
  make charts from a spreadsheet, or says “show me this data.”
dependencies:
  - pandas
  - plotly
---

# Data Dashboard Skill

## Workflow
1. Read the user’s data file (CSV, XLSX, or TSV)
2. Analyze columns and data types automatically
3. Run `scripts/build_dashboard.py` to generate the dashboard
4. Output an interactive HTML file

## Script Usage
```bash
python scripts/build_dashboard.py \
  --input data.csv \
  --output dashboard.html \
  --title “Q3 Sales Dashboard”

Chart Selection Guide

• Time series data → Line chart

• Categorical comparisons → Bar chart

• Part-to-whole → Pie or donut chart

• Correlations → Scatter plot

• Distributions → Histogram

Part 5: Installing Skills

In Claude.ai (Web / Desktop / Mobile)

1. Go to Settings → Customize → Skills (or the Customize panel)

2. Click Upload Skill

3. Select your .zip or .skill file

4. Claude reads your SKILL.md and displays the skill details

5. Toggle the skill on to activate it

Packaging your skill for upload:

• Put your skill folder inside a ZIP file

• The ZIP should contain the skill folder as its root (not nested inside another folder)

• The folder name should match your skill’s name field

my-skill.zip
└── my-skill/
    ├── SKILL.md
    └── scripts/
        └── process.py

In Claude Code (Terminal)

Place skills in one of these locations:

Project-level (shared with your repo):

your-project/
└── .claude/
    └── skills/
        └── my-skill/
            └── SKILL.md

User-level (available across all projects):

~/.claude/skills/my-skill/SKILL.md

Claude Code discovers and loads skills automatically. You can also invoke them directly with /my-skill-name.

Via the API

Upload skills using the Skills API:

curl -X POST “https://api.anthropic.com/v1/skills” \
  -H “x-api-key: $ANTHROPIC_API_KEY” \
  -H “anthropic-version: 2023-06-01” \
  -H “anthropic-beta: skills-2025-10-02” \
  -F “display_title=My Skill Name” \
  -F “files[]=@my-skill/SKILL.md;filename=my-skill/SKILL.md”

Part 6: Sharing Skills

On Team and Enterprise Plans

In Customize → Skills, open a skill you created. You can share it with:

• Specific people: Enter names or emails. The skill appears in their skills list (grayed out until they enable it).

• Entire organization: Published to your org’s directory where anyone can find and install it.

Shared skills are view-only — recipients can enable and use them but can’t edit them. Updates you make are automatically pushed to recipients.

Exporting for Others

Package your skill folder as a .zip file and share it directly. Recipients upload it through their own Skills settings.

Part 7: Testing and Iterating

Manual Testing

After uploading your skill:

1. Open a new chat

2. Ask Claude something that should trigger your skill — try both explicit mentions (”Use my brand guidelines skill to...”) and implicit triggers (”Create a client-facing presentation”)

3. Check that the output follows your instructions

4. Test edge cases and unexpected inputs

Using the Skill Creator

Claude has a built-in skill for creating and improving skills. You can use it by asking Claude directly:

“I want to create a skill that does X. Can you help me build it?”

The skill creator walks you through:

1. Defining what the skill should do

2. Writing a draft SKILL.md

3. Creating test cases

4. Running test prompts

5. Evaluating results

6. Iterating until you’re satisfied

7. Packaging the final skill

Troubleshooting

Skill doesn’t trigger:

• Broaden your description field — add more trigger phrases and contexts

• Be more explicit in your prompt: “Use my [skill-name] skill to...”

• Ensure the skill is toggled on in Customize → Skills

• Verify code execution is enabled

Inconsistent results:

• Add more specificity to your instructions

• Include concrete examples of expected output

• Add validation steps (”Before outputting, verify that...”)

Errors when running scripts:

• Check that dependencies are listed in frontmatter

• Verify scripts work standalone before bundling

• Check file paths are relative to the skill directory

Part 8: Best Practices

Do

• Keep skills focused. One skill per workflow. Multiple focused skills compose better than one massive skill.

• Write clear descriptions. This is the trigger mechanism — invest time here.

• Include examples. They’re the most effective way to steer output quality.

• Explain the why. Claude generalizes better from reasoning than from rigid rules.

• Test with realistic prompts. Use the kind of language real users actually type, including casual phrasing and typos.

• Iterate. The first draft is rarely the best. Test, get feedback, improve.

• Use progressive disclosure. Keep SKILL.md lean; put detailed references in separate files.

Don’t

• Don’t make skills too broad. A skill that tries to do everything will do nothing well.

• Don’t rely on ALL-CAPS rules. Explaining why something matters is more effective than shouting.

• Don’t skip the description. Without a good description, Claude won’t know when to use your skill.

• Don’t hardcode paths or environments. Skills should be portable across surfaces.

• Don’t assume your skill runs in isolation. Claude can load multiple skills simultaneously.

Security Considerations

• Review skills from external sources before enabling them — check bundled scripts and dependencies

• Skills can instruct Claude to install third-party packages, which carries inherent risk

• Be cautious of skills that instruct Claude to connect to external network sources

• Never include API keys, passwords, or secrets in skill files

Part 9: Skill Patterns by Use Case

• Brand guidelines — colors, fonts, tone, logo usage rules

• Document templates — structure, formatting, example sections, assets

• Code standards — linting rules, naming conventions, review checklists

• Data workflows — processing scripts, output formats, chart preferences

• Writing style — voice, tone, word choices, formatting, examples

• API integration — endpoint docs, auth patterns, request/response examples

• Onboarding guides — step-by-step processes, checklists, reference docs

Quick-Start Checklist

1. ☐ Create a folder named after your skill (lowercase-kebab-case)

2. ☐ Write a SKILL.md with YAML frontmatter (name + description)

3. ☐ Write clear instructions in the Markdown body

4. ☐ Add examples of expected input and output

5. ☐ (Optional) Add scripts/, references/, or assets/ folders

6. ☐ ZIP the folder (skill folder as root of the archive)

7. ☐ Upload in Customize → Skills

8. ☐ Toggle the skill on

9. ☐ Test with realistic prompts

10. ☐ Iterate based on results

What’s Next

That’s the full picture — from a blank folder to a production-ready skill running across Claude.ai, Claude Code, and the API. If you build something cool, I’d love to hear about it. Reply to this email or tag me — I might feature it in a future issue.

Coming up in the newsletter: more deep dives on Claude’s tooling ecosystem, practical AI workflows for dev teams, and hands-on guides like this one. If you found this useful, share it with a colleague who’s still copy-pasting the same prompt every morning.

More from AI For Developers

This newsletter is part of AI For Developers — a growing directory of AI developer tools, APIs, frameworks, and resources. If you’re evaluating tools for your stack or just want to stay on top of what’s out there, check it out:

🔗 AI For Developers — Browse the directory

📬 AI For Developers newsletter — Subscribe to the newsletter

Every issue covers one topic in depth — no fluff, no hype, just the stuff you need to build with AI. Subscribe if you haven’t already, and I’ll see you in the next one.

I did it. After months of frustration, I finally cancelled my ChatGPT Pro subscription. And based on everything happening right now, I don’t think I’m alone.

This isn’t rage-bait. This is a pattern — and if you’re a developer paying attention, you can see it too.

The Product Is Getting Worse

OpenAI just retired GPT-4o, the model many of us genuinely loved. Along with it went GPT-4.1, o4-mini, and even GPT-5 Instant. Everything got funneled into GPT-5.2, a model that many users find verbose, sycophantic, and inconsistent. Sam Altman himself admitted OpenAI “screwed up” the writing quality on it.

Users held mock funerals for GPT-4o. Reddit exploded with frustration. The backlash was real enough that OpenAI had already reversed the retirement once before — and then killed it anyway.

Ads Are Here. Sam Said That Was the Last Resort.

In October 2024, Altman said ads would be a last resort. Twenty months later, OpenAI started rolling out ads to free and Go-tier users. Why? Because they’re burning cash at an insane rate — projected to lose $14 billion in 2026 alone, with Deutsche Bank estimating $140 billion in negative free cash flow between 2024 and 2029.

A former OpenAI researcher, Zoë Hitzig, resigned the day ads launched, warning that OpenAI has built the most detailed record of private human thought ever assembled — and advertising on top of that is dangerous territory.

The Competition Passed Them

ChatGPT’s market share dropped from 86% to 65% in a single year. Claude is becoming the go-to for coding workflows. Gemini handles research and multimodal tasks better. DeepSeek showed you can build competitive AI at a fraction of the cost.

Geoffrey Hinton put it bluntly: he’s surprised it took this long for Google to overtake OpenAI. Google has the researchers, the data, the infrastructure — and $30 billion in quarterly profit to fund it. OpenAI has none of that.

Users Are Revolting

The QuitGPT campaign has gathered over 700,000 pledge sign-ups, driven by OpenAI president Greg Brockman’s $25 million donation to a pro-Trump super PAC, ICE’s use of GPT-4 tools, and the broader question of what your subscription dollars fund. Mark Ruffalo amplified the campaign. Investor George Noble said OpenAI is “falling apart in real time”. The comparison analysts are making isn’t to Google. It’s to MySpace.

What This Means for Developers

If you’re building on OpenAI’s API, don’t panic — but start diversifying. Use abstraction layers. Test your workflows against Claude, Gemini, and open-source models. Watch the pricing. Follow the talent exodus. And never marry a platform.

I cancelled my Pro plan. Maybe you should think about it too.

AI For Developers is your go-to curated list of the best AI DevTools, sourced from Awesome AI Coding Tools. Follow us on X, Substack, LinkedIn, and GitHub to stay in the loop on the latest AI-powered dev tools and tricks.

Anthropic just dropped Claude Opus 4.6, and if you build with AI — not just experiment with it — this release is worth paying attention to.

While most model updates promise “better reasoning” and “stronger coding,” Opus 4.6 focuses on something more practical: long-running, production-grade agent workflows. The goal isn’t just smarter answers. It’s fewer iterations, longer autonomy, and outputs that actually ship.

Let’s break down what’s new — and what matters for developers.

The Big Shift: From Chatbot to Work Engine

Opus 4.6 isn’t positioned as just another flagship model. It’s being framed as a work model — one designed for sustained, multi-step tasks across long contexts.

Anthropic is clearly leaning into the future where developers build:

• multi-agent systems

• autonomous coding assistants

• long-running research pipelines

• document-heavy enterprise workflows

Instead of optimizing for short prompts and clever responses, Opus 4.6 is optimized for staying coherent and useful over time.

That’s a subtle but important shift.

1. Long-Horizon Task Performance (The Real Upgrade)

The most noticeable improvement is how Opus 4.6 handles multi-step tasks over long sessions.

It:

• maintains context across very long prompts

• plans and executes tasks with fewer resets

• produces more “first-pass usable” outputs

• avoids degradation during extended interactions

If you’ve ever built an agent that slowly gets worse as context grows, this update targets exactly that problem.

Anthropic specifically highlights improvements in:

• large codebase analysis

• multi-document reasoning

• structured business outputs (reports, sheets, decks)

• autonomous task loops

For developers building agents, this matters more than benchmark scores.

2. Massive Context Window: Up to 1M Tokens (Beta)

Opus 4.6 ships with:

• 200K token standard context

• 1M token context (beta) for select use cases

That puts it among the most capable long-context models available.

More importantly, Anthropic claims better needle-in-a-haystack retrieval and less context drift — meaning the model can actually use that massive context instead of just accepting it.

Use cases:

• full repo ingestion

• long research archives

• enterprise document search

• persistent agent memory

For teams building knowledge-heavy systems, this unlocks new architecture possibilities.

3. 128K Output Limit (Yes, Output)

Opus 4.6 doubles output capacity to 128K tokens.

This is huge for:

• multi-file code generation

• long reports

• full documentation generation

• structured dataset outputs

• agent-produced artifacts

Instead of chunking outputs or stitching responses together, you can now generate complete deliverables in one go.

4. Adaptive Thinking Mode

One of the more interesting developer-facing changes: adaptive thinking.

Instead of manually setting reasoning depth or “thinking budgets,” you can let the model dynamically decide how much computation to use.

There’s also a new effort parameter:

• low → faster/cheaper

• medium → balanced

• max → deeper reasoning

This gives you better control over latency vs quality — especially useful in production agents where cost matters.

5. Agent Infrastructure Upgrades

Opus 4.6 isn’t just a model release. It comes with new tooling designed for agent workflows.

Compaction API (beta)

Automatically summarizes and compresses old context so long-running agents don’t hit token limits.

This is essentially memory management as a service.

Fine-grained tool streaming

Better visibility and control when the model:

• calls tools

• streams responses

• interacts with external systems

Important for debugging and observability.

Agent Teams (Claude Code preview)

Multiple sub-agents can now work in parallel and coordinate on tasks like:

• code reviews

• refactors

• repo exploration

Expect this pattern — coordinated agent swarms — to become standard in 2026.

6. Built for Real Knowledge Work

Anthropic is clearly expanding beyond dev-only use cases.

They’re pushing Opus 4.6 for:

• spreadsheet generation

• presentation building

• financial modeling

• research synthesis

• enterprise documentation

The idea: higher-quality first drafts that require less human cleanup.

If this trend continues, the boundary between “coding model” and “work model” disappears.

7. Pricing and Availability

Pricing remains the same as Opus 4.5:

• $5 / MTok input

• $25 / MTok output

Higher pricing applies when using the 1M token context beyond standard limits.

Opus 4.6 is available via:

• Anthropic API

• Claude web app

• Amazon Bedrock

• Google Vertex AI

• Microsoft Azure Foundry

• GitHub Copilot (rolling out)

What This Means for Developers

Opus 4.6 isn’t just a smarter model.

It’s a sign that the frontier is shifting toward:

• persistent agents

• multi-step autonomous workflows

• long-context reasoning

• production-ready outputs

The question isn’t “Which model writes better code?” anymore.

It’s:
Which model can run real work loops with minimal supervision?

Opus 4.6 is Anthropic’s strongest answer yet.

About AI For Developers

If you’re building with AI — agents, tools, or full products — AI For Developers is a community and resource hub focused on practical implementation, not hype.

Explore more at AI For Developers for guides, tools, and deep dives into real-world AI development.

And if you found this useful, subscribe to the AI For Developers Newsletter on Substack for weekly breakdowns of new models, tools, and what actually matters for builders.

Subscribe now

This isn’t hype. Something shifted this week, and I think it marks a turning point in AI development.

I ran a single prompt in Claude Code—just one request, plain English—and then I hit enter.

What happened next felt like magic.

Claude Code kept going. And going. And going.

It ran for 15 minutes straight (941 seconds), processed 37,400 tokens in one shot, and delivered something I never thought I’d see:

• A full website plan

• Detailed page-by-page breakdowns in Markdown

• Rich, usable documentation

To put that into perspective: that single response was about the length of a full O’Reilly programming book.

And it wasn’t fluff. It was better than anything I could have written myself.

Why This Matters

For years, I’ve followed AI forecasts—like AI27, which predicted we’d see autonomous task execution around now. Back then, it felt absurd.

But here we are.

I asked Claude Code to plan my site. It didn’t just give me a generic outline. It gave me structured deliverables: Markdown files for every page, each one deep, thorough, and immediately usable.

Then I asked it to build the thing.

Two prompts. Thirty minutes. Entire project done.

That’s not just speed. That’s quality + autonomy.

What Changed

I’ve tried planning prompts before. Usually, the results are compressed, shallow, and full of random stack recommendations I didn’t ask for.

This time, I changed my approach:

1. Structured outputs — I told it to create Markdown files.

2. Break it down — Instead of one build the app prompt, I asked for page-by-page plans.

3. Chain prompts — I took those files, fed them back, and said: Cool, now build it.

4. Walk away — I literally went for a run. When I came back, it was finished.

The output? Not just usable, but surprisingly better than my own planning would have been.

The Caveats

• The app I built was backend-light (just CRUD + strategy screens).

• Open-ended tasks like this work better than rigid, production-scale systems.

• I still wouldn’t hand it a fintech app and expect compliance-ready code.

But here’s the real milestone: I now trust AI to execute end-to-end workflows while I’m not even at my desk.

We’ve crossed into a new phase.

How You Can Recreate This

If you want to try this yourself, here’s the playbook:

• Break down big tasks → don’t ask for a whole app at once.

• Use structured formats → Markdown, JSON, tables.

• Chain your prompts → plan first, then execute.

• Go deep, not broad → expand one workflow at a time.

• Batch your context → feed in notes or files upfront.

• Let it cook → walk away, give it 15 minutes, come back.

Final Thought

I started this as an experiment. But after seeing Claude Code plan and build a project in 2 prompts, I’m convinced:

This is a genuine milestone in AI-assisted development.

The way we build software is about to feel very different.

Have you tried something similar? I’d love to hear your experiments in the comments.

Subscribe now

There’s been a quiet shift happening in the AI tools ecosystem—one that’s easy to miss if you only look at what's trending on Product Hunt or X.

While most new AI builders are racing toward cloud-based convenience, subscription lock-in, and cookie-cutter templates, a tool called Dyad is carving out a different path:

Build AI-powered apps on your own machine, with your own models, and export every line of code.

That’s the promise of Dyad. And after trying it, I think it delivers—especially for developers who care about flexibility, privacy, and code ownership.

🚀 What is Dyad?

Dyad is a local-first, open-source AI app builder that runs entirely on your desktop (macOS and Windows). You download it, launch it, and start building full-stack apps with natural language prompts—without ever creating an account or sending your data to a remote server.

It supports all the usual suspects—GPT-4, Claude, Gemini, and even local LLMs via Ollama—and lets you mix and match API keys to suit your needs.

Think of it as part VS Code, part Figma, part Copilot—but with none of the lock-in and all of the control.

👉 Try it here:

https://www.dyad.sh

🧠 How It Works

Dyad uses an AI-first editing interface that feels like you’re talking to your IDE. You describe what you want (a form, a database, a chatbot, etc.), and Dyad generates the code and UI structure in real time. But you’re never stuck with what it gives you—you can refine, re-edit, and export everything at any point.

Under the hood:

• Frontend: Built with React (you can export and own it)

• Backend: Serverless-style functions, Supabase-ready

• AI integration: Plug in OpenAI, Anthropic, Google, or local models

• Code export: No lock-in. Build locally, deploy wherever.

It’s like a co-pilot for solo developers that respects your autonomy.

🧩 Why It Matters

Most AI app builders (looking at you, v0.dev, Lovable, and bolt.new) offer fast prototyping—but at the cost of control. They’re web-based, proprietary, and often trap your logic behind their own APIs or templates.

Dyad flips the script:

• You don’t need to sign up.

• You don’t need to host anything with them.

• You don’t even need an internet connection (if using local models).

This isn’t just about privacy—it’s about software freedom. You own the process and the output.

🧪 Use Cases

• Build AI assistants or agents with full transparency

• Create internal tools that don’t leak sensitive data

• Prototype MVPs with AI logic and ship them independently

• Test local vs cloud model performance side-by-side

The ability to switch between Claude, GPT-4, and even LLaMA or Mistral (locally!) makes it a fantastic testing ground for prompt engineers and AI devs.

💸 Pricing

Surprisingly generous:

• Free: Unlimited local apps, bring-your-own API keys, full code export

• Pro ($30/mo): Adds AI credits, smarter AI editing features, and access to Dyad Academy

• Max ($79/mo): Built for heavy users—higher app limits and usage credits

Unlike others, you can actually build something real on the free tier.

🧪 TL;DR — Should You Try It?

If you're a developer who:

• Hates being locked into a platform

• Likes building apps from scratch but hates boilerplate

• Wants to experiment with local and cloud LLMs side-by-side

• Wants real code that you can export and deploy

Then yes—you should definitely give Dyad a spin.

It's one of the rare AI tools that actually respects the developer in the loop.

AI For Developers is your go-to curated list of the best AI DevTools, sourced from Awesome AI Coding Tools. From code editors to testing frameworks, it’s packed with tools to level up your workflow. Follow us on X, Substack, LinkedIn, and GitHub to stay in the loop on the latest AI-powered dev tools and tricks.

Using Qwen3-Coder with Claude Code is the smartest (and cheapest) way I’ve found to tap into powerful agentic coding workflows—without draining your wallet.

🧠 What’s the Big Deal?

If you haven’t heard, Qwen3-Coder is Alibaba’s latest open coding model. It’s huge: 480B parameters (35B active), supports up to 256K context (and up to 1M with extensions), and rivals top-tier models like Claude Sonnet 4—for free.

Pair it with Claude Code, Anthropic’s impressive local dev assistant, and you get:

• A model that understands massive codebases

• Git-aware workflows

• Cross-file refactoring

• Fast debugging, tool integration, and agentic development

✅ Why This Combo Works

Claude Code offers a great CLI experience, but using it with Anthropic’s own models can get expensive. Qwen3-Coder gives you similar (or even better) performance—free via API—if you’re willing to set it up manually.

⚠️ Note: Qwen3-Coder is hosted by Alibaba (China). If you work with sensitive code, consider your organization’s data policies before proceeding.

🛠️ How to Set It Up

Here’s how I got Claude Code + Qwen3-Coder running on my machine:

1. Prerequisites

• Install Node.js (v20+):

curl -qL https://www.npmjs.com/install.sh | sh

2. Install Claude Code CLI

npm install -g @anthropic-ai/claude-code

This installs the CLI tool globally so you can run claude from anywhere.

3. Get a Qwen3-Coder API Key

You have two main options:

• Alibaba DashScope (requires account + some setup)

• OpenRouter (faster if you want to skip Alibaba’s process — this is what I used)

4. Connect Qwen3-Coder to Claude Code

🔹 Option A: Quick Proxy Method (Recommended)

Set these environment variables in your terminal or .bashrc/.zshrc:

export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/api/v2/apps/claude-code-proxy export ANTHROPIC_AUTH_TOKEN=your-dashscope-apikey

That’s it — Claude Code will now use Qwen3-Coder via the proxy.

🔸 Option B: Custom Router (More Control)

If you want a more flexible setup:

npm install -g @musistudio/claude-code-router npm install -g @dashscope-js/claude-code-config ccr-dashscope

Then start coding:

ccr code

5. Verify It Works

Inside any project folder, run:

claude

If all goes well, Claude Code launches, powered by Qwen3-Coder.

🔍 What I Learned

• Performance: Initial setup was sluggish, but switching to the proxy API improved speed.

• Gotchas: I hit some auth errors early on—if you do too, double-check the token and endpoint.

• Full-stack? Haven’t battle-tested it yet on a large monorepo or microservices setup, but it’s promising.

💸 Why It’s Worth Trying

If you love Claude Code’s local agent workflow but can’t justify the API costs, this hybrid setup gives you 90% of the power with nearly 0% of the price.

Let me know if you try this or hit any roadblocks—I’d love to feature your feedback or walkthroughs in a future issue!

AI For Developers is your go-to curated list of the best AI DevTools, sourced from Awesome AI Coding Tools. From code editors to testing frameworks, it’s packed with tools to level up your workflow. Follow us on X, Substack, LinkedIn, and GitHub to stay in the loop on the latest AI-powered dev tools and tricks.

A month ago, I made the switch from Cursor to Claude Code. At first, it felt like a lateral move — different UI, same concept. But once I fully immersed myself in the Claude Code ecosystem, something clicked: most developers are only tapping into a fraction of what this tool can actually do.

After a few weeks of experimenting, refining, and building, I realized I had moved from "This is cool" to "I can't code without this." So I’m sharing five high-leverage tactics that helped me get there. These aren’t abstract ideas — these are real-world strategies I use daily.

Even if you consider yourself a power user, I’d bet there’s at least one thing here that’ll raise your Claude game.

1. Most People Aren’t Using MCPs Properly (Or At All)

If you’re not leaning into Model Context Protocols (MCPs), you’re essentially throttling a Formula 1 engine to 20 mph.

These are the five that redefined my workflow:

• Context7 – Essential. It dynamically pulls in documentation on demand, eliminating the need to hunt down docs or hope Claude remembers obscure API details.

• Effect Docs – I use the Effect library, which most models struggle with. This MCP bridges that gap by injecting knowledge that isn’t in Claude’s native dataset. If you use niche tech, find or build an MCP for it.

• Postgres – Total game-changer. I run queries, insert test data, and debug schemas — all without leaving my coding flow. There are MCPs for every major database: MySQL, Mongo, etc.

• Sequential Thinking – My intro to MCPs. It’s less critical now, but still useful for tackling complex, multi-step problems methodically.

• Test Master AI – Amazing when you’re rolling out something big that spans frontend, backend, and test coverage. Not for everyday use, but indispensable when the stakes are high.

One from the community: Consult7, which feeds your entire codebase into LLMs with massive context windows (like Gemini). I haven’t fully tested it, but the potential is huge. Props to @prof-stefan on YouTube for the tip.

2. Stop Skipping the Init Command — Seriously

Most complaints about Claude Code (“It doesn’t get my style,” “It keeps forgetting context”) stem from skipping the one thing that actually solves that: the /init command.

Run it. Set up a proper claude.md. This file becomes the instruction manual for your AI assistant.

Here’s a snippet from mine:

markdown

- Use IDE diagnostics to detect and fix issues - Reference prompt-engineering-playbook.md when refining prompts - Confirm test coverage after each implementation

I even link to my prompt engineering playbook, so when I ask Claude to “improve this prompt,” it doesn’t improvise — it applies strategies I trust.

Think of claude.md like onboarding documentation for a new teammate. Because that’s exactly what it is.

3. Code Less. Plan More.

This one feature has almost made Sequential Thinking and Test Master obsolete for me: Planning Mode.

Claude Code doesn’t just outline tasks — it understands your codebase, maps out dependencies, and creates a detailed roadmap for you to execute. The process looks like this:

1. Describe what you want

2. Let Claude generate a structured plan

3. Review and tweak it

4. Implement with total clarity

That extra minute or two of planning? It’s saving me tons of refactoring and rework down the line.

4. The Max Plan Is a No-Brainer (And Here’s Why)

At $100/month, Claude’s Max plan isn’t cheap — but it might be the best investment I’ve made in my workflow.

Why? Unlimited usage. No token juggling. No worrying about hitting limits mid-project.

I saw a developer burn through $6,000 in API credits in one month using standard plans. That’s not a typo. Just imagine the efficiency lost when you’re constantly watching usage stats.

With Max, I get uninterrupted access. Claude becomes a true collaborator, not a meter-watching assistant.

Even if you’re not ready for Max, start with Pro or credits. But once you get a taste of that freedom, you won’t go back.

5. The IDE Plugin Feels Like Cheating (In a Good Way)

If you haven’t installed the Claude Code IDE extension yet, you’re missing out.

When integrated with your IDE, Claude doesn’t just guess what’s wrong — it sees the red squiggly lines and diagnostics. That changes everything:

• It catches type errors in real-time

• It self-corrects syntax issues

• It loops through fixes until the code actually works

And yes — you should reference this behavior explicitly in your claude.md file:

markdown

- Always use IDE diagnostics to validate and correct code

With this setup, Claude isn’t just generating code — it’s shipping working code that compiles and passes tests.

Final Thoughts

These aren’t just tricks — they’re the difference between using Claude Code and owning it.

I’ve seen people struggle with simple tasks using the same tool I’m using to ship complete features. The gap isn’t the tool — it’s the process.

If you’re serious about AI-assisted development, here’s the move:

1. Learn your MCPs

2. Set up your claude.md

3. Always plan before coding

4. Upgrade to the Max plan (if it makes sense)

5. Sync with your IDE

Adopt these five steps, and I promise — you’ll wonder how you ever coded without them.

Have any Claude Code hacks that supercharged your workflow? Share them in the comments. And if you haven’t yet, check out our full 38-minute breakdown on mastering Claude Code — it’s packed with even more.

AI For Developers is your go-to curated list of the best AI DevTools, sourced from Awesome AI Coding Tools. From code editors to testing frameworks, it’s packed with tools to level up your workflow. Follow us on X, Substack, LinkedIn, and GitHub to stay in the loop on the latest AI-powered dev tools and tricks.

If you’re a developer who’s been around the block, you know the pain of wrestling with tools that don’t quite get your project’s vibe. Enter Cursor, an AI-powered code editor that’s more than just a fancy IDE—it’s got a killer feature called Cursor Rules that lets you bend its AI to your will. Think of it as a way to tell the AI, “Hey, stop suggesting that deprecated API and stick to our team’s TypeScript style guide.” This guide is for devs, by a dev, and I’m going to walk you through what Cursor Rules are, why they’re a game-changer, and how to set them up to make your coding life less of a grind.

Written for the AI For Developers Newsletter crowd, this is your no-BS, step-by-step rundown on making Cursor Rules work for you, whether you’re a solo coder or part of a team wrangling a massive mono-repo.

What the Hell Are Cursor Rules?

Cursor Rules are your way to customize the AI in Cursor to respect your project’s coding standards, architecture, or quirks. It’s like giving the AI a cheat sheet for your codebase. Want it to stop suggesting var in JavaScript? Done. Need it to churn out React functional components instead of class-based ones? Easy. Want it to flag insecure functions like eval()? You got it. These rules are essentially a config file (or UI settings) that dictate how Cursor’s AI behaves when it’s autocompleting, generating, or editing code.

Think of it as guardrails for your AI pair-programmer. Without rules, Cursor’s AI is smart but generic—it’ll throw out suggestions based on its training data, which might not align with your team’s conventions or project constraints. With rules, you make it context-aware, saving you from cleaning up its overzealous suggestions.

Why Should You Care?

Here’s the deal—Cursor Rules aren’t just a nice-to-have. They’re a productivity booster and a sanity saver. Here’s why:

• Consistency: Enforce your team’s coding style (e.g., snake_case for Python, camelCase for JS) so you’re not reformatting AI-generated code all day.

• Project-Specific Smarts: Tailor the AI to grok your project’s stack—whether it’s Next.js, Django, or some custom microservices mess.

• Less Debugging: Rules can block bad patterns (like that eval() call that makes your security team cry) before they hit your codebase.

• Team Sync: Share rules across your team to keep everyone’s AI on the same page, especially in big projects.

• Speed: Stop wasting time rejecting irrelevant suggestions. Make the AI work for you, not against you.

Ready to dive in? Let’s get your hands dirty with a step-by-step setup.

Step-by-Step: Setting Up Cursor Rules Like a Pro

Step 1: Get Cursor Running

First, you need Cursor. If you’re not already using it, here’s the quick setup:

1. Grab It: Head to cursor.sh and download the editor for your OS (Windows, macOS, Linux). It’s lightweight and won’t bog down your machine.

2. Install: Run the installer. It’s straightforward—no weird dependencies or setup headaches.

3. Sign In: Log in to unlock the AI features. If you’re on SuperGrok (via x.ai/grok), you’ll get beefier usage quotas, which is clutch for heavy AI use.

4. Plug in Extensions: Cursor plays nice with VS Code extensions. Hook up your faves—GitLens, ESLint, whatever—for a familiar workflow.

Step 2: Find the Rules Config

Once you’re in Cursor, it’s time to locate the Rules setup:

1. Hit Settings: Click the gear icon or go to File > Settings (or Preferences on macOS).

2. Find Cursor Rules: Look for “AI Settings” or “Cursor Rules” in the settings panel. You’ll either configure rules via a UI or a config file.

3. Set Up a Rules File: For max control, create a .cursor-rules file in your project’s root. It’s typically JSON or YAML, and Cursor picks it up automatically.

Step 3: Write Your Rules

This is where the magic happens. Cursor Rules let you define how the AI should behave. Here’s a taste of what you can do:

Example 1: Enforce Coding Style

Say you’re working on a JavaScript project and your team is religious about single quotes. Here’s how to make the AI respect that:

{
  "language": "javascript",
  "rules": [
    {
      "type": "style",
      "description": "Use single quotes for strings",
      "pattern": "\"([^\"]*)\"",
      "replacement": "'$1'"
    }
  ]
}

This regex-based rule swaps double quotes for single quotes in strings. Boom—consistent style without lifting a finger.

Example 2: Ban Bad Functions

Got a deprecated or insecure function you want to avoid? Let’s say eval() is a no-go:

{
  "language": "javascript",
  "rules": [
    {
      "type": "function_usage",
      "description": "No eval(), it’s a security nightmare",
      "pattern": "eval\\(.*\\)",
      "action": "warn",
      "message": "eval() is banned. Use safer alternatives like JSON.parse or a proper function."
    }
  ]
}

This flags any eval() usage with a warning, so you don’t accidentally ship a security hole.

Example 3: Framework-Specific Vibes

For a React project, you might want functional components only:

{
  "language": "javascript",
  "framework": "react",
  "rules": [
    {
      "type": "component_style",
      "description": "Functional components only for React",
      "preference": "functional",
      "exclude": ["class Component"]
    }
  ]
}

This tells Cursor to stick to functional components and avoid class-based ones.

Step 4: Apply and Test

Now, let’s make sure your rules are working:

1. Save the File: Drop your .cursor-rules in the project root. Cursor will load it automatically.

2. Test It Out: Open a file, start typing, or trigger AI features like autocompletion (Ctrl+Enter or whatever your keybind is). Watch the AI respect your rules.

3. Debug: If suggestions are off, double-check your regex patterns or rule syntax. JSON/YAML errors can trip things up.

Step 5: Share with Your Crew

Team projects? Don’t let everyone reinvent the wheel:

1. Commit the Rules: Add .cursor-rules to your Git repo. Treat it like any other config file.

2. Document It: Throw a comment block or README section explaining your rules. Nobody likes guessing what pattern: "foo.*bar" does.

3. Sync Up: Make sure your team’s on the same Cursor version and has the rules file. Cursor’s cloud sync can help distribute it.

Step 6: Keep It Tight

Your project’s not static, so your rules shouldn’t be either:

1. Watch the AI: If Cursor’s suggestions start feeling off, it’s time to tweak your rules.

2. Add New Rules: As your project evolves (new frameworks, new standards), update .cursor-rules to keep the AI in check.

3. Steal Ideas: Peek at the AI For Developers GitHub repo for rule inspiration from other AI tools.

Pro Tips for Cursor Rules

• Don’t Overdo It: Keep rules lean. Too many complex rules can slow down the AI or make it overly rigid.

• Test Small: Start with one or two rules, test them, then scale up. Debugging a 500-line rules file is a nightmare.

• Clear Messages: Write message fields like you’re explaining to a junior dev. Clarity saves time.

• Version Control: Commit your rules file and review changes like code. It’s part of your project’s DNA.

• Stay Current: Cursor’s AI gets updates. Check the docs or changelog for new rule options to level up your setup.

Advanced Tricks

For the hardcore devs, here’s how to push Cursor Rules further:

• Multi-Language Rules: Got a polyglot codebase? Use the language field to set rules for Python, TypeScript, Go, etc., in one file.

• Refactoring Automation: Write rules to rewrite legacy patterns (e.g., convert callbacks to async/await).

• CI/CD Integration: Hook Cursor Rules into your CI pipeline to enforce standards during code reviews. Pair with tools like Codacy or ESLint for extra muscle.

• Context Boost: Use extensions like Supercode.sh or Context7 (from the AI For Developers repo) to make your rules context-aware for massive codebases.

Debugging When Shit Hits the Fan

• Rules Not Firing? Check the file path and syntax. A misplaced comma in JSON can break everything. Restart Cursor to reload.

• Weird Suggestions? Your pattern might be too broad. Tighten it up or log the AI’s output to debug.

• Slow AI? Too many rules or complex regex can bog things down. Simplify or limit rules for big projects.

• Team Out of Sync? Confirm everyone’s got the latest .cursor-rules and Cursor version. Git conflicts can screw this up.

If you’re stuck, hit up Cursor’s docs or forums. The AI For Developers GitHub repo also has related tools to dig into.

AI For Developers is your go-to curated list of the best AI DevTools, sourced from Awesome AI Coding Tools. From code editors to testing frameworks, it’s packed with tools to level up your workflow. Follow us on X, Substack, LinkedIn, and GitHub to stay in the loop on the latest AI-powered dev tools and tricks.

Hello and welcome to the very first edition of AI For Developers — a newsletter for builders, makers, and coders navigating the new frontier of AI-powered software development.

🔍 Why this newsletter?

As AI tools flood our dev workflows — from code completion and debugging to UI generation, testing, and infra — it's harder than ever to keep track of what’s real, what’s useful, and what’s worth integrating.

AI For Developers exists to solve that.

We’re building a growing ecosystem of resources for developers who want to stay ahead:

• A hand-curated list of the best AI-powered coding tools and agents.

• A beautiful directory experience at aifordevelopers.org.

• And now, this newsletter, where we’ll spotlight emerging tools, deep dives, interviews, and trends shaping AI-first developer experiences.

• Thanks for reading AI For Developers! Subscribe for free to receive new posts and support my work.

🧩 The Source: Awesome AI Coding Tools

The foundation of all this is Awesome AI Coding Tools — an open source GitHub repository that curates:

📅 AI code assistants
🛋️ CLI & IDE integrations
🔧 Testing & review agents
🌐 UI & full-stack generators
🚧 Infra, DevOps, docs, and more

It’s open for exploration, inspiration, and contribution.

We started by asking: What are the best AI tools for developers right now?
This repo is our living answer — updated weekly by the community and always evolving.

🌐 From List to Directory: AI For Developers

The GitHub repo is great for contributors — but we also wanted something friendlier for discovery.

That’s why we built aifordevelopers.org: a fast, filterable UI that turns the GitHub list into a developer-friendly tool directory. Same data, better experience.

🛠 What's Next

In future issues, we’ll cover:

• 🔬 Deep dives into new dev agents (like Claude Code, Gemini CLI, Windsurf)

• 🚀 Feature spotlights on tools from the directory

• 🔁 Real workflows showing how AI tools integrate into day-to-day dev work

• 👥 Interviews with makers, contributors, and open source builders

And we want your input, ideas, and contributions. This is a community for developers building in the age of AI.

💬 Let’s build it together

This newsletter is for you — the developer pushing forward in a fast-changing landscape.
Subscribe, share, and if you’re building something in this space: submit it or open a PR on GitHub. Feel free to contribute — whether it's a new tool, a fix, or feedback!

Follow us and get involved:

• GitHub

• Twitter/X

• LinkedIn

Thanks for being here. Let’s make AI-first development not just possible — but joyful.

— AI For Developers