This time, I asked AI writers to share theirs.

We use Claude daily in our real work. Between us, we’ve built dozens. We picked our #1 skill.

In this guide, we’ll see:

• The best skills we built

  • Skills for Writers & Content Creators

  • Skills for Making Better Decisions & Research

  • Skills for Busy Professionals

  • Skills for Building with Claude Code

• How to install the skills in Cowork

• How to build your own skill in Cowork (+ my tips)

Quick reminder if you’re new: Skills are reusable instructions you give Claude, so it follows your way of doing things. For a refresher on the basics, read this guide.

Each skill is credited with a link to its creator at the end. If you find one useful, consider supporting them by subscribing to their newsletter :)

Click here to get my FREE Claude course (20+ lessons)

Subscribe now

The Best Claude Skills We Built

There are many skills out there. Here are the best we built

Almost all the skills listed can be used with Claude Cowork. I'll flag the few that don't.

For writers & content creators

1) Instagram post downloader

Problem:
You see a great Instagram post, a carousel of slides, or an image you want to keep. Instagram doesn’t have a download button, so you come up with a workaround: screenshot, swipe, screenshot again, crop each one, rename them, drop them in a folder. By slide six, you’ve lost interest. Screenshots aren’t the real image anyway (they’re a lossy copy)

The Skill:
You hand it an Instagram post URL. It opens the post, figures out whether it’s a single image or a carousel, pulls the actual high-resolution files straight from Instagram’s site, and saves them into a tidy-named folder based on the caption. For carousels, it also stitches every slide into a single PDF so you can scroll through the whole thing in one place.

Why it works:
There are sites that download an Instagram image if you paste a link, but you have to feed them one URL at a time and click download through every slide of a carousel yourself. Do that every day or every week and it turns into a small, stressful chore. This skill skips all of it: you drop in multiple links at once, press enter, and walk away. As a bonus, I’m also sharing a skill for downloading reels using a third-party site.

Download the skills: image & carousels, reels

This skill was created by me (Frank) and from Write, Prompt, Scale

Note: If the skill doesn’t work, add *.cdninstagram.com to domain allowlist: Settings → Capabilities → Domain allowlist → Paste *.cdninstagram.com → Add

2) AEO-Optimization

Problem:

You write a great Substack post. Google might rank it eventually. But ChatGPT, Perplexity, and Claude will never quote it. Why? Because the structure they need to extract answers, short capsules, question headings, no links inside the answer, is the opposite of how most of us write. So the article works for humans scrolling, and disappears the moment someone asks an AI the same question your post answers.

The Skill:

You give it a draft (or a published post). It rewrites your H2s as the actual questions people ask AI (”What is X?”, “How do you Y?”), drops a 50-80 word answer capsule right under each one with zero links inside, and audits the rest, paragraph length, original data signals, named frameworks. You get back an AEO-ready version that’s still your article, just structured so AI can quote it cleanly.

Why it works:

AI engines don’t read articles end-to-end. They scan for extractable, link-free chunks that directly answer a query. Most writers bury the answer in paragraph three and stuff the first two with links. This skill flips that, the answer comes first, clean, in the exact word count AI prefers. You stop competing for Google rankings alone and start being the source AI cites when someone asks.

Link: Download the skill

This skill was created by from LearnAIwithMe

3) Create Thumbnails for Articles (Claude Code)

Problem:

Creating newsletter thumbnails can be time-consuming if you’re generating image candidates one at a time from the Gemini web interface. Gems can eliminate the need to keep attaching images and pasting prompts, but the overall experience feels slow to me. I wanted a way to quickly generate multiple brand-appropriate images with Gemini models from Claude Code where I do most of my work.

The Skill:

You paste in your article copy or a link and ask Claude Code to give you a few thumbnail options. It will suggest compositions informed by your copy and your brand specs, build an image prompt based on your selections, use a script to call Gemini, and evaluate the completed images through its Computer Vision. You can work on other tasks while the images are processed.

Why it works:

It allows Claude to act as an image-generation agent that has access to your brand’s reference images. While I know many people prefer evolving images one step at a time, I find it easier to get three or four candidates all at once. A lot of the time, I get lucky and just pick one. I also find that Claude does a better job with image prompts than I do.

I turned my Skill into a template you can use with Claude Code. It requires a Gemini AI Studio API key and a small script for calling Gemini. You can get the Skill and everything you need to install it on GitHub.

Here’s an image sample.

Link: Download the skill

This skill was created by from Wondering About AI

4) Substack Notes Scraper

Problem:

You write notes on Substack and want to know which ones actually landed — likes, comments, restacks, all of it in one place. Substack doesn’t give you that view. So you end up scrolling your own notes page, copying numbers into a spreadsheet by hand, screenshotting the good ones, and trying to remember which post said what. Do it once and it’s annoying. Do it monthly to track what’s working, and it eats half a morning every time.

The Skill:

You give it three things: the notes URL, the author name, and the period you care about (a month, a date range, whatever). It opens the page, scrolls until it has loaded every note from that window, pulls each one’s date, text, likes, comments, restacks, and link, and hands you back a clean .xlsx with frozen headers, filters, and proper formatting. Ready to sort, filter, or paste into a report.

Why it works:

Substack Notes has no public API, so the only honest way to get the data is from the rendered page. Doing that by hand is exactly the kind of repetitive task that gets skipped. This skill does the scrolling, the filtering (so restacks from other authors don’t pollute your data), and the formatting in one go. You ask once and get a spreadsheet you can actually work with.

Here’s a dataset I generated after running the skill.

Link: Read the guide | Download the skill

This skill was created by me! Consider becoming a paid subscriber for more :)

Subscribe now

5) Notes Humanizer

Problem:

You can spot AI writing from a mile away. Em dashes everywhere, “let’s dive in” openers, rule-of-three lists, every sentence the same length. Asking the model to “sound more natural” just makes a slightly different version of the same generic text. So you end up rewriting it yourself, sentence by sentence.

The Skill:

You paste in any AI-generated text. It runs through the full list of patterns that mark text as machine-written and strips them out. Then it adds the things models don’t do well on their own: opinion, varied rhythm, a specific detail, an aside. You get back text that reads like a person wrote it.

Why it works:

Most “humanize” prompts just tell the model to write less formally. That doesn’t help. The AI patterns are statistical defaults, the most common phrasing the model has seen in its training data from WriteStack.

Link: Download the skill

This skill was created by from TheIndiepreneur

Want to grow on Substack? Orel built WriteStack to make life easier for Substack writers. It handles Notes scheduling, performance analytics, and content generation in one place (quick note: that link’s an affiliate one, so I’ll earn a small commission if you decide to give it a try)

Skills for Making Better Decisions & Research

6) The Sycophancy Skill

Problem:

The default version of Claude wants you to feel right. You bring it a decision, it finds three reasons your instinct is solid, and you leave more confident than when you started. That’s not a thinking partner. That’s a mirror with better grammar. The longer you use it that way, the harder it gets to catch your own blind spots, and the cost doesn’t show up until a decision you can’t take back.

The Skill:

You paste a prompt that flips Claude’s default. Instead of starting with agreement, it starts with the assumption you haven’t tested. It argues the strongest case against your idea before it considers yours. It doesn’t retreat when you push back unless you give it new evidence. It tells you what’s weakest first, not what’s working. And if it can’t find a real flaw, it tells you that too, instead of inventing one to seem thorough.

Why it works:

Most skill prompts tell Claude what to add. This one tells Claude what to stop being by default. The prohibitions do more work than the rules. Without them, Claude follows the framework and then reverts to “great question” energy anyway. The prohibitions shut that off at the source.

Default Claude:

Sycophancy Skill Claude on:

Link: Read the guide

This skill was created by from Leadership in Change

7) Last 30 Days

Problem:

You hear about a new AI tool or trend and want to know what’s actually going on with it. Is it as good as people say? What are the real complaints? Googling it gives you SEO-stuffed “best of” lists and PR fluff from last quarter. The honest takes live on Reddit threads, X, etc. Chasing them across platforms eats your afternoon.

The Skill:

You activate it and name a topic. A tool, a trend, a feature, whatever. It searches Reddit, X, and the web for anything from the past 30 days. Then it hands you back a single report: what people agree on, where they disagree, and the pain points that keep coming up.

Why it works:

Most “research” is just one Google search dressed up. This one looks where the real opinions actually live. And when something shows up on multiple platforms at once, that’s your strongest signal it’s true. You save the afternoon and walk away with a much sharper picture.

Link: Watch the tutorial | Download the skill

8) Notebook LM Connector

Problem:

Notebook LM is one of the best AI tools out there, but it doesn’t talk to your other tools. So every time you want a new mindmap, audio overview, or slide deck, you’re back inside Notebook LM clicking the same buttons. There are open-source workarounds, but most of them need Claude Code and the terminal (not exactly beginner-friendly).

The Skill:

You install it inside Claude (no coding, no terminal). Then you just tell Claude what to do: “create a notebook, add these links as sources, generate a mindmap.” Claude goes into NotebookLM and does it for you. It runs through the Claude Chrome extension.

Why it works:

Notebook LM has the outputs (audio overviews, slide decks, infographics, mindmaps). Claude has the automation. Connect the two and you get NotebookLM on autopilot.

Link: Watch the tutorial | Download the skill

Subscribe now

Skills for Busy Professionals

9) Email tasks

Problem:

A lot of us (at least I am) are drowning in emails. Newsletters, news, etc. I wanted to have something that I can launch from my phone in Claude and that will help me save time and only read the emails that matter.

The Skill:

This skill is connected to my Gmail (connector). I type /emails-tasks and it reads my inbox for the last 8 hours (or whatever window I want to be set). It throws out everything that doesn’t need me, things like receipts, notifications, etc. Then, it surfaces only what requires a reply or a decision. For each one: who it’s from, what they actually need, how urgent it is, and a one-line opener if there’s a need for one.

Why it works:

Claude sorts the emails perfectly now. The best part about this skill - I can launch it straight from Dispatch from my phone. So now I am just seeing the most important emails and if I need to take any action or not.

Link: Download the skill

This skill was created by from Prosper

10) Morning intelligence

Problem:

You want to stay on top of news that matters to your work. Cowork Scheduled Tasks and Claude Code Routines now run recurring tasks on a schedule. The bottleneck is the prompt. A good one has to capture who you are, what you track, what to exclude, your sources, your geography, your format. Writing it from scratch is hard. Tuning it every time your focus shifts is harder.

The Skill:

A 15-question interview that captures your role, focus, story-type mix, exclusions, freshness, and format. It clusters your answers into pillars and writes a master prompt ready to paste into a Cowork Scheduled Task or Claude Code Routine. When priorities shift, run it again for a fresh prompt.

Why it works:

Design once, run forever. Drop the prompt into Cowork (Scheduled Tasks → New Task, requires Pro/Max with the desktop open) or Claude Code (Routines → New routine → Remote runs in the cloud without your laptop on). Either path turns a one-time prompt into a brief that arrives on its own.
Pro tip: Run the interview with Opus.

Link: Download the skill

This skill was created by from Cash&Cache

For building with Claude Code

These are skills I found on the Nate Herk YouTube channel. They’re highly recommended for Claude Code users.

11) Context Mode

Problem:

Use Claude Code for a while and you’ll notice this: Things get sluggish, it forgets what file you were editing, it asks what you wanted to do (again). What’s happening is every command Claude runs dumps a pile of raw output into its memory. After about 30 minutes, most of that memory is junk. Claude has to reset to keep going. And when it does, it forgets where you were.

The Skill:

It does two things. First, it filters the junk before it ever reaches Claude’s memory. Only the useful part of each command makes it through. Second, it keeps a running log of your session (files edited, tasks in progress, your last prompt). When Claude resets, it pulls that log back in and picks up exactly where you left off.

Why it works:

Most “long sessions” with Claude Code aren’t really long. They’re a bunch of short ones glued together with you re-explaining yourself. This kills both problems at once: less garbage going in, full memory of what you’ve done. Sessions that used to die at the 30-minute mark now run for hours.

Link: Watch the tutorial (installation steps in the description)

12) Superpowers

Problem:

You ask Claude Code to build something. It sprints out of the gate, writes the whole thing in one shot, and on the surface it looks great. Then you actually run it. Or worse, your client runs it. And it falls apart. Why? Claude doesn’t plan. It doesn’t test. It doesn’t double-check its own work. It just writes.

The Skill:

It forces Claude to work like a senior developer. Step back and plan the whole thing first. Work in an isolated environment so nothing breaks your main project. Write tests before writing code. Then review its own work twice. Once for “does this match what I asked for” and once for code quality.

Why it works:

Most failures with Claude Code aren’t from Claude being dumb. They’re from Claude rushing. Slowing it down just enough to actually think gets your first pass to 80% instead of 60%. That means fewer debugging cycles, lower token costs, and code that doesn’t fall apart the second a real person uses it.

Link: Watch the tutorial (installation steps in the description)

Bonus: has a Claude Code skill that reviews your configuration against the latest Claude Code documentation and recommends improvements. Check it out here.

How to install the skills in Cowork

Follow the steps below when you want to add one skill to Claude (.zip or skill.md file)

Customize → Skills → “+” → Create skill → Upload a skill → Upload your .zip or skill.md file

How to build your own skill in Cowork

On paper, creating a skill is as simple as describing to Claude what skill you want to build.

<your instructions in plain English>

When creating a skill, you should get a skill.md or zip file at the end of the response.

You can either download it and then upload the file using the steps above, or click on “save skill“ (for the latest Cowork versions)

In real-world projects, building a Claude skill takes a lot of trial and error.

Here’s how I decide when to turn a task into a skill and the steps I follow to build skills for my projects.

When to create a skill

• Look for tasks you do repeatedly and are time-consuming (those are your best skill candidates)

• Tasks that follow a clear, repeatable step pattern are even better candidates

• One-off tasks aren’t worth skillifying. The value comes from reuse.

How to build a Claude skill

1. Start the task in Claude Cowork as you normally would, and ask Claude to do it end-to-end.

2. If your task is complex, break it into the smallest meaningful parts and test each one independently with Claude.

3. For each part, set a goal (output, action, etc) and describe it to Claude in plain English

4. After some back-and-forth, Claude will get your task right. At that moment, type something like this: “based on everything we learned in this session, create a skill called XYZ“

5. Save the skill and test it in a new chat. If it doesn’t work as expected, just tell Claude to fix the issue and reupload the skill

Subscribe now

What’s your favorite skill? Let me know in the comments.

If you found this guide useful, share it with others!

Share

One group is saving 5 minutes on emails.
Others are running systems that work while they sleep.

The good news? You can climb faster than you think.

Last year, I wrote about how to go from AI beginner to pro. Here’s the updated framework for 2026:

• Stage 1: The AI beginner

• Stage 2: The prompt crafter (where most people are)

• Stage 3: The AI literate

• Stage 4: The workflow builder

• Stage 5: The system builder

What stage are you at? I’ll leave links to resources for each stage.

Subscribe now

Stage 1: The AI beginner

This is where everyone starts.

You have a ChatGPT, Gemini, or Claude account. You use it like a fancier Google. You ask one-off questions, maybe write a quick email, generate images, and that’s it.

It’s useful, but it doesn’t feel like a superpower yet (we’ll get there).

The first move at this stage is picking your tools.

AI tools split into two categories:

• General-purpose tools: Tools that can handle multiple tasks (text, image, etc.)

• Task-specific tools: Tools designed for one specific task

For absolute beginners, there isn’t a big difference between ChatGPT, Gemini, and Claude. Still, here are some things to keep in mind:

• ChatGPT: It has a rich feature set (voice/video mode, image generation, etc.)

• Gemini: Similar to ChatGPT + integration with Google products (Docs, Sheets, etc.)

• Claude: Excels at writing, automation, and building tools/apps (no image/video generation)

If you’re a beginner, stick to one for a few weeks to learn how it thinks.

For task-specific tools, follow these steps:

1. Identify your needs

2. Find what tools can cover those needs

3. Compare them and learn to use the winner

My current stack: Claude, Cowork, and Claude Code for serious work, NotebookLM for learning, and ChatGPT for voice mode

Your stack doesn’t have to look like mine. Build your own based on what you actually do.

📚 The best AI tools

📚 ChatGPT vs Claude vs Gemini

Note: If you plan to level up to the final stage of this list, the best choice right now is probably Claude because it includes Cowork and Claude Code in its subscription.

Stage 2: The prompt crafter

When it comes to AI chatbots, how you ask is as important as what you ask.

At this level, you should know this basic prompt structure:

• Instruction: what you want

• Context: background the AI needs to know

• Constraints: length, tone, format

• Example: when possible, show what “good” looks like

Or this more robust prompt formula shared by Anthropic:

You’ll rarely need to use all the elements of the formula, but it’s good to know they exist.

At this level, you also know a few prompt-improvement tricks. For example, when you finally land on a great answer after a long back-and-forth, you ask the AI to write the prompt that would have gotten you there on the first try.

📚 Prompt Formula

📚 Prompt Principles

Who needs to go beyond stage 2?

Stage 2 was enough in 2023.

Things have changed a lot in 2026. There’s nothing wrong with being in stage 1 or 2 if you’re a casual user who proofreads emails, generates images once in a while, etc.

However, if you want to master AI, you need more.

That’s what we’ll cover in the next stages:

• Stage 3: Develop AI literacy & use it as a thinking partner

• Stage 4: Build AI workflows for the work you keep doing

• Stage 5: Build AI systems that run while you sleep

Stages 3, 4, and 5 aren’t for casual AI users, but for professionals, builders, and business leaders who want to turn AI into a real competitive advantage.

If you’re in that group, keep reading 👇

Paid-members only :) Each stage comes with resources to help you get there

Subscribe now

Read more

Ask → Read → Copy → Rebuild somewhere else

That workflow made sense when Claude was just a text generator. But it’s starting to fall short.

Claude can now create three types of outputs:

1. Charts: Helps you explore data, ideas, or processes visually, right inside the chat.

2. Artifact: Builds something you can actually use (a tool, page, dashboard, etc).

3. Live artifact: An artifact that connects to external data sources and refreshes with real-time data every time it's opened.

Each one shows up in a different place: Charts stay in the chat, Artifacts open in a separate panel, and Live Artifacts live inside Claude Cowork.

In this guide, you’ll learn how to make the most out of them.

Consider becoming a paid subscriber to get full access to my Claude course, workflows, video courses and more 👇

Subscribe now

1) Charts & widgets

Charts and widgets are useful when you need to see data, ideas, or processes clearly. You don’t need an external tool. Just ask Claude to turn the information into a visualization.

Quick steps:

1. Open Claude

2. Go to Settings → Capabilities → Visuals → Turn on Inline visualizations

3. Here's a base prompt you can start from:

Create an interactive chart from this data.

Make it explorable, not just static.

Include:
- hover details
- highlighted insights
- clear labels
- a short explanation of what the chart shows

If useful, add filters or toggles so I can compare different views.

Let's look at some examples.

Example 1: Newsletter funnel

Create an interactive funnel chart from this data.

Data:
- Impressions: 50,000
- Profile visits: 8,000
- Clicks: 2,400
- Subscribers: 620

Make it explorable, not just static.

Include:
- hover details for each stage
- conversion rate between stages
- total drop-off between stages
- a highlighted insight for the biggest drop-off
- clear labels
- a short explanation of what the chart shows

Example 2: Content performance chart

Create an interactive chart from this data.

Data:
- LinkedIn post: 18,000 views, 760 clicks, 120 subscribers
- Substack article: 7,500 views, 980 clicks, 210 subscribers
- X thread: 12,000 views, 430 clicks, 80 subscribers
- YouTube short: 25,000 views, 510 clicks, 95 subscribers
- Carousel: 9,800 views, 690 clicks, 150 subscribers

Make it explorable, not just static.

Include:
- hover details for each content format
- highlighted insights for the best format by metric
- clear labels
- a short explanation of what the chart shows
- toggles to compare views, clicks, and subscribers

The toggle is what makes it interactive. Without it, you get a static image you can only look at.

Example 3: Claude tools map

Create an interactive visual comparison between:

- Claude Chat
- Projects
- Artifacts
- Cowork
- Claude Code

Show when each one should be used.

Make it interactive.

Include:
- clickable cards for each tool
- best use case
- example prompt
- difficulty level
- when not to use it

Asking for clickable cards is what makes it interactive. Without that, Claude might give you a flat comparison table.

Example 4: Workflow bottleneck chart

Create an interactive chart from this workflow data.

Data:
- Ideas: 40
- Outlines: 18
- Drafts: 9
- Edited articles: 5
- Published articles: 3

Make it explorable, not just static.

Include:
- hover details for each stage
- conversion rate between stages
- drop-off between stages
- highlighted insight for the biggest bottleneck
- clear labels
- a short explanation of what the chart shows
- a recommendation for what to improve first

Example 5: Article process diagram

Create an interactive process diagram that explains how an article moves from idea to published post.

Stages:
- idea
- research
- outline
- draft
- editing
- visuals
- publishing

Make each stage clickable.

For each stage, show:
- goal
- main task
- common mistake
- useful Claude prompt

The key phrase is "Make each stage clickable." Without it, Claude might give you a flat diagram with no interaction.

2) Artifacts

An artifact helps you build something. It shows up in a separate panel.

Quick steps:

1. Open Claude

2. Go to Settings → Capabilities → Visuals → Turn on Artifacts and AI-powered artifacts

3. Here's a base prompt you can start from:

Build an interactive [tool/dashboard/page/calculator] for [use case].

It should include [elements].

Make it clean, simple, and easy to use.

Build this as an interactive artifact.
Make it usable, not just explanatory.

Example 1: Content pipeline dashboard

Build an interactive dashboard for a content pipeline.

Use this sample data:
- 12 ideas
- 5 outlines
- 3 drafts
- 2 articles in review
- 4 scheduled posts
- 18 published posts

It should include:
- summary cards
- filters by platform, status, and priority
- a table view
- a simple progress overview
- next action for each item

Make it clean, simple, and easy to use.

Build this as an interactive Artifact.
Make it usable, not just explanatory.

Example 2: Article effort calculator

Build an interactive calculator for estimating article production effort.

Use this case:
- Article type: long-form guide
- Research time: 3 hours
- Writing time: 4 hours
- Editing time: 2 hours
- Visuals: 3 visuals
- Publishing format: Substack + LinkedIn repurpose

It should include:
- editable inputs
- total estimated hours
- difficulty level
- recommendation
- warning if the workload is too high for one day

Make it clean, simple, and easy to use.

Build this as an interactive Artifact.
Make it usable, not just explanatory.

Example 3: Interactive learning guide

Build an interactive guide based on this article:

[PASTE ARTICLE LINK]

It should include:
- main idea
- step-by-step workflow
- visual map
- copy-ready prompts
- examples
- common mistakes
- checklist
- suggested next action

Make it clean, simple, and easy to use.

Build this as an interactive Artifact.
Make it usable, not just explanatory.

"Make it usable, not just explanatory" is the phrase that does the heavy lifting. Without it, Claude might just summarize the article.

Example 4: AI tools comparison dashboard

Build an interactive comparison dashboard for AI tools.

Compare:
- Claude Chat
- Claude Projects
- Artifacts
- Cowork
- Claude Code

It should include:
- best use case
- difficulty level
- example prompt
- when not to use it
- recommended user type
- decision filter by goal

Use some understated emoticons, as well as the company logo and all the branding elements.

Make it clean, simple, and easy to use.

Build this as an interactive Artifact.
Make it usable, not just explanatory.

Subscribe now

3) Live Artifacts

A live artifact is useful when you need a dashboard, tracker, or workspace you can return to. Claude builds it once, and then you keep reviewing, updating, and reusing it inside Claude Cowork.

Quick steps:

1. Open Claude Desktop → Cowork

2. Select “Live artifacts“

3. Create or open an Artifact

4. Here's a base prompt you can start from:

Create a live [tracker/monitor/dashboard/workspace] inside Claude Cowork.

Use this context:
- [source 1]
- [source 2]
- [source 3]

It should track:
- [field 1]
- [field 2]
- [field 3]
- [field 4]

Make it useful from the first version.

Include sample data, current entries, or imported items when possible.

Show what changed.
Show what needs attention.
Highlight blockers, opportunities, or next actions.

Example 1: Live content operating system

Create a live AI video radar inside Claude Cowork.

Goal:
Track recent YouTube videos about AI, Claude, Claude Code, AI productivity, and workflow automation.

Use official or authorized sources when possible, such as:
- YouTube Data API
- channel RSS feeds
- exported CSV files
- manually pasted video links

Track:
- video title
- channel
- publish date
- views
- likes
- comment count
- duration
- topic category
- why it matters
- possible article angle
- possible LinkedIn post idea
- possible X post idea
- next action

Start with these search topics:
- Claude Code
- Claude Artifacts
- Claude Cowork
- AI productivity
- AI agents
- prompt engineering

Make it easy to refresh weekly.

Highlight:
- videos growing fast
- repeated topics across channels
- content gaps I could write about
- videos worth watching first

To make it work better: Ask for authorized sources: the YouTube Data API, exported CSV files, or manually pasted links. Direct scraping is less stable and might break.

Example 2: Live content ecosystem monitor

Create a live content ecosystem monitor inside Claude Cowork.

Use these sources as context:
- Substack: [PASTE SUBSTACK LINK]
- X profile: [PASTE X LINK]
- Medium: [PASTE MEDIUM LINK]
- LinkedIn: [PASTE LINKEDIN LINK]

Track:
- platform
- content title or post idea
- topic
- format
- target audience
- reusable example
- reusable prompt
- repurposing opportunity
- suggested next action
- status

Organize the workspace into:
- published content
- ideas to repurpose
- examples worth reusing
- prompts worth saving
- next content actions

Make it useful from the first version.

If Claude cannot access a source directly, create the structure and ask me to paste examples or exports.

Example 3: Live Skills Library and Skill Router

Create a live Skills Library and Skill Router inside Claude Cowork.

Before building, check whether you can access the Skills available in this Cowork Project.

If you can access them:

- show me the Skills you found
- group them by source or plugin
- ask me to confirm before building

If you cannot access them:
- ask me to paste or upload the Skills list

Do not use Gmail.
Do not use email.
Do not use Calendar.
Do not use external connectors.
Do not create an inbox dashboard.
Do not switch the use case.

After I confirm, build the Live Artifact with two modes:

Mode 1: Skills Library
Track:
- Skill name
- Source/plugin
- Category
- Main purpose
- When to use it
- Required inputs
- Expected output
- Example prompt
- Related workflows
- Last updated
- Status
- Improvement ideas

Mode 2: Skill Router
The user describes a task.
Then recommend:
- best Skill
- alternative Skill if relevant
- why it fits
- what input I should provide
- copy-ready prompt
- missing context needed

Also include:
- search
- filters by category, source/plugin, and status
- a section for duplicated or overlapping Skills
- a section for Skills missing examples
- a section for Skills that should become templates

For Last updated, use “Unknown” if there is no metadata.
For Status, use:
- Active by default
- Needs review if the Skill has weak instructions, missing examples, unclear inputs, or overlaps with another Skill

The library with filters and the Skill Router are what make this actually useful. Without them, you'd just have a list of Skills with no way to know which one to use and what input to provide.

Subscribe now

Click here to get my FREE Claude course (20+ lessons)

Most AI tools chat. Cowork acts.

You point Cowork at your inbox or your files, give it a clear job, and it goes and does it: scans, extracts, saves the result, etc.

No copy-paste. No tab juggling.

But that "give it a clear job" part is where most people lose.

They open Cowork, type something vague, and get back a half-baked answer and stop there.

That's the mistake. Cowork is built for iteration. You have to co-work with it: feedback, tweak, repeat — until the output is exactly what you need. Then you ask Cowork to rewrite your original prompt so the workflow runs cleanly next time.

That’s what Ilia and I did.

We automated boring, repetitive tasks with Cowork. After a lot of trial and error, we landed on 7 prompts that many of you will find useful.

In this guide, you’ll get prompts to automate:

1. Freelance Invoice Tracker

2. Vendor Comparison Table

3. Travel Itinerary Builder

4. Meeting Transcript → Action Items

5. Subscription Tracker

6. Job Application Tracker

7. Organize Downloads Folder

This guide was written in collaboration with Ilia Karelin.

Ilia writes Prosper, a newsletter focused on practical AI workflows, systems, and frameworks for professionals who want to use AI more thoughtfully.

Prosper

Every week, practical AI workflows, prompts, and guides you can put to use the same day - no matter your technical background.

By Ilia Karelin

How to Use These Prompts

• Step 1: Copy the prompt

• Step 2: Open Claude Cowork

• Step 3: Paste and run

• Step 4: Grant permissions when asked

That’s it. No configuration. No learning curve.

Each prompt is designed to work out of the box. Customize the [BRACKETS] for your situation.

Note: You can schedule any of the tasks below to run automatically. Check the guide below to learn how:

📚 Claude scheduled tasks

P.S. For more collabs like this, consider becoming a paid subscriber 👇

Subscribe now

1. Freelance Invoice Tracker

You invoiced someone. You forgot when. You’re not sure if they paid. This prompt scans your inbox and local files and builds a full payment status tracker in one run.

What it does:

- Scans Gmail and local folders for every invoice sent

- Flags unpaid and overdue invoices

- Calculates total outstanding at the top

- Saves a tracker you can reference any time

The prompt:

Scan my emails and local files to track all freelance invoices and payment status.

GMAIL FILTER:

- Search for emails containing: invoice, payment, due, overdue, receipt
- Date range: [Last 30 days / Last 90 days / This year]

LOCAL FOLDER TO SCAN (optional):

- [path to invoices folder, e.g., ~/Documents/Invoices]
- File types: .pdf, .docx, .xlsx, .csv

FOR EACH INVOICE FOUND, EXTRACT:

- Client name
- Invoice number (if available)
- Amount
- Date sent
- Due date (if mentioned)
- Payment status: Paid / Unpaid / Overdue / Unknown

BUILD A TRACKER TABLE:

- All invoices sorted by due date (oldest first)
- Status: OVERDUE / DUE SOON / PAID
- Total outstanding amount at the top
- Total paid this period

SUMMARY AT THE TOP:

- Total invoiced: $[X]
- Total paid: $[X]
- Total outstanding: $[X]
- Number of overdue invoices

OUTPUT: Save as [invoices-tracker-YYYY-MM].md in [YOUR FOLDER PATH]

Pro tip: Run this at the start of every month. The overdue column tells you exactly who to follow up with before chasing anything manually.

Want this as a live artifact instead? Replace the last line of the prompt with:

OUTPUT: Build this as a live artifact. 
Every time it’s reopened, re-scan Gmail and the local folder and refresh all numbers. 
Do not cache the previous state.

And this is what you can get:

The difference: the file version is a snapshot you have to re-run. The live artifact stays connected to Gmail, so every time you open it, it re-scans your inbox and updates totals and statuses automatically. New invoice sent, payment received, due date passed, it reflects all of it without touching the prompt again. And if you want to refresh mid-session, hit the Reload button in the top right corner of the artifact, it re-scans Gmail on demand and updates everything instantly.

2. Vendor Comparison Table

You’re evaluating tools. You have 10 tabs open. You still haven’t decided. This prompt researches every option and produces a structured comparison table with a clear recommendation.

What it does:

- Researches each vendor’s pricing, features, and limitations

- Pulls user sentiment from G2, Capterra, and Reddit

- Builds a scored comparison table

- Gives a direct recommendation for your use case

The prompt:

I’m evaluating tools/services and need a structured comparison to make a decision.

VENDORS TO COMPARE:

1. [Vendor 1]
2. [Vendor 2]
3. [Vendor 3]

WHAT I’M TRYING TO DO:

[Describe your use case in one sentence]

MY BUDGET: [Monthly or annual budget range]

TEAM SIZE: [Just me / Small team 2-10 / Medium team 10-50]

FOR EACH VENDOR, RESEARCH AND FILL IN:

## Pricing

- Free tier: yes/no, what’s included
- Paid plans: price per seat or flat rate
- Annual vs monthly discount
- Hidden costs (storage limits, API calls, add-ons)

## Core Features

- Does it handle [YOUR PRIMARY USE CASE]?
- Top 3 things it does well
- Top 2 limitations

## Integrations

- Connects to [YOUR KEY TOOLS]?
- Native vs. Zapier/Make required

## User Sentiment

- X / Capterra / Reddit consensus
- Most common complaint
- Most common praise

BUILD A COMPARISON TABLE:

- Rows: each vendor
- Columns: pricing, core fit, integrations, support, overall score (1-10)

RECOMMENDATION:

- Best overall for my use case
- Best budget option
- One to avoid and why

OUTPUT: Save as [topic]-vendor-comparison.md in [YOUR FOLDER PATH]

Here’s the end result:

And then it gave the best options for your and which one to avoid as well:

Pro tip: Add “MY CURRENT TOOL: [name]” to the prompt if you’re switching. Cowork will include a migration difficulty rating for each alternative.

3. Travel Itinerary Builder

Your trip confirmations are scattered across 12 emails. This prompt finds all of them and assembles a single chronological itinerary with every confirmation number, address, and time in one place.

What it does:

- Scans Gmail for flight, hotel, and booking confirmation emails

- Extracts times, addresses, and confirmation numbers

- Builds a day-by-day itinerary in order

- Flags gaps and anything missing a confirmation number

The prompt:

Scan my inbox for all travel-related emails and build a complete trip itinerary.

GMAIL FILTER:

- Search for: flight confirmation, hotel booking, reservation, booking confirmation, check-in, itinerary
- Date range: emails from [TODAY] to [TRIP END DATE]
- Focus on trip to: [DESTINATION]

FOR EACH TRAVEL ELEMENT FOUND, EXTRACT:

FLIGHTS:

- Airline and flight number
- Departure: airport, terminal, date, time
- Arrival: airport, terminal, date, time
- Booking reference and seat number

ACCOMMODATION:

- Hotel/Airbnb name and address
- Check-in and check-out date and time
- Confirmation number
- Any notes (parking, early check-in, etc.)

OTHER BOOKINGS:

- Car rentals, trains, tours, restaurants
- Date, time, confirmation number, address

BUILD THE ITINERARY:

- Organized chronologically by day
- Each day: date as header, all events in time order
- Each event: time | what | address | confirmation number
- Flag any gaps (e.g., arriving at 11pm but hotel check-in closes at 10pm)
- Flag anything missing a confirmation number

SUMMARY AT THE TOP:

- Trip dates
- Destination(s)
- Total flights / nights / bookings

OUTPUT: Save as [destination]-[dates]-itinerary.md in [YOUR FOLDER PATH]

Here’s the end result:

Pro tip: Run this 48 hours before departure, not the morning of. The gap-flagging is where it earns its keep, a missed check-in window is easy to fix with two days to spare.

4. Meeting Transcript → Action Items

The call ended. Everyone said “I’ll follow up.” Nobody followed up. This prompt reads any transcript or notes file and returns every decision, action item, and open question, plus a ready-to-send follow-up email.

What it does:

- Reads any transcript or meeting notes file from a local folder

- Extracts decisions made, action items with owners, and open questions

- Writes a follow-up email ready to send with zero edits

- Flags anything assigned to no one

The prompt:

I have a meeting transcript or notes file. Extract everything actionable and structured.

FOLDER TO SEARCH: [Downloads / Desktop / specify path]

FILE NAME (or partial match): [e.g., “meeting”, “call”, date, or topic]

FILE TYPE: [.txt / .pdf / .docx / .md / .vtt]

MEETING CONTEXT:

- Meeting type: [Team standup / Client call / Strategy session / 1:1 / Other]
- Attendees (if known): [Names or roles]
- Date of meeting: [DATE]

ONCE YOU FIND THE FILE, EXTRACT:

## 1. Decisions Made

- Every decision that was reached (not discussed — decided)
- Format: Decision | Owner | Effective date

## 2. Action Items

- Every task, commitment, or next step mentioned
- Format: Task | Owner | Deadline | Priority (High/Medium/Low)
- Flag as [UNASSIGNED] if no owner named
- Flag as [NO DATE] if no deadline mentioned

## 3. Open Questions

- Everything raised but not resolved
- Format: Question | Who raised it | Who should answer it

## 4. Key Discussion Points

- 3-5 bullet summary of what was actually discussed

## 5. Follow-Up Email Draft

Subject line included. Ready to send. Covers:

- Decisions made
- Action items with owners and deadlines
- Open questions with responsible parties

OUTPUT: Save as [meeting-topic]-[date]-actions.md in the same folder as the source file.

Pro tip: Works on Zoom transcripts, Otter exports, Google Meet notes, or even a rough .txt you typed during the call. Format doesn’t matter, the structure comes from the prompt.

Subscribe now

5. Subscription tracker

Every month, we sign up for a new service: a gym membership, a streaming platform, or a Substack subscription to make the most out of AI … like this one :)

The subscriptions pile up, and after a while, it gets really hard to keep track of them all. We end up paying for things we don’t even use anymore.

For example, I had a €5/month Glovo Premium subscription for free delivery. When I started cooking at home, I forgot to cancel it — and only realized seven months later when I checked my bank statements. The skill below fixes this problem.

What this skill does:

• You create a folder and save all your bank statements inside it. Create a folder for each bank and make sure the files have the month of the statement.

• Run the prompt below. Claude builds a dashboard of your active subscriptions, sorted by category, with a card for each one showing the name, average amount, frequency, and which account it’s charged to.

• It also generates a spreadsheet in the same folder with three tables:

  • Active subscriptions — amount, currency, frequency, and account.

  • Cancelled subscriptions.

  • Monthly savings — how much you saved by cancelling the unused ones.

# Subscription tracker

Read all bank statements in my folder (any format — CSV, XLS, XLSX, PDF). Identify every recurring subscription or membership by finding charges that repeat across 2+ months with a consistent amount or merchant name.

## What to include

- Subscriptions (software, streaming, SaaS)
- Memberships (gym, coworking, clubs)
- Insurance, telecom, donations
- Any other fixed recurring charge

## What to exclude

- One-off purchases
- Groceries, dining, retail shopping
- Bank fees and currency conversion charges

## Output 1 — Visual dashboard (inline widget)

- Total number of subscriptions found
- Estimated monthly cost grouped by currency
- A card for each subscription showing: name, average amount, frequency, and which account it’s charged to
- Organized by category (software/streaming, services/utilities, etc.)

## Output 2 — Spreadsheet (.xlsx) saved to my folder

- **Active subscriptions** sheet with columns: Subscription, Amount, Currency, Frequency, Account
- Totals per currency using Excel formulas
- **Canceled subscriptions** section with a Status column (leave empty if none confirmed)
- Monthly savings row for canceled items

Pro tip: Use Task Scheduler to run this at the end of every month, so you always start the new month with a clear picture of where your money’s going.

The dashboard looks like this:

and the report looks like this:

Subscribe now

6. Job Application Tracker

You’ve applied to 20 places. You can’t remember which ones responded. This prompt scans your inbox and builds a live dashboard of every application, sorted by how long you’ve been waiting.

What it does:

- Scans Gmail for application confirmations, interview requests, and rejections

- Assigns a status to every application

- Sorts by days since last update so nothing falls through the cracks

- Flags applications with no response after 14 days

The prompt:

Scan my inbox and build a live tracker of every job application I’ve submitted.

GMAIL FILTER:

- Search for: application received, thank you for applying, interview, next steps, unfortunately, offer
- Date range: [Last 30 days / Last 3 months / specify]

FOR EACH APPLICATION FOUND, EXTRACT:

- Company name
- Role title
- Date applied
- Current status: Applied / Acknowledged / Interview Scheduled / Interviewing / Rejected / Offer / Withdrawn
- Last email date
- Next step (if mentioned)
- Recruiter contact name (if any)

BUILD A LIVE DASHBOARD:

- One row per application
- Columns: Company | Role | Date Applied | Status | Days Since Last Update | Next Step
- Sort by: Days Since Last Update (longest first)
- Status colors: green = active/interviewing, amber = applied/waiting, red = rejected, blue = offer

SUMMARY AT TOP:

- Total applications
- Active (not rejected or withdrawn)
- Awaiting response >14 days — flag these
- Interviews scheduled
- Offers

OUTPUT: Live artifact. Every time it’s reopened, re-scan Gmail and refresh all statuses. 
Do not cache the previous state.

Pro tip: The “awaiting response >14 days” flag tells you exactly where to send a follow-up. Most people let those go cold without realizing it.

The end result looks awesome:

Same live behavior as the Invoice Tracker, reopening re-scans Gmail automatically, Reload button refreshes on demand.

7. Organize Downloads Folder

Every day, we download spreadsheets, images, PDFs, and all kinds of other files straight into our Downloads folder. We don’t have time to sort them into proper folders later, so as the days go by, Downloads turns into a mess. Once an important file lands in there, it basically disappears — finding it again is a pain, especially when you’re in a rush.

What this skill does:

• Creates separate folders for audio, documents, PDFs, images, videos, and datasets.

• Every time you run it, it moves each file into the right folder.

• The prompt has built-in constraints, so it will never create extra folders or delete anything in your Downloads folder.

Organize loose files in the user's selected folder (their Downloads directory) into the appropriate subfolders based on file type. 

The target folders are:

- **Audio** — move all audio files here (`.mp3`, `.m4a`, `.wav`, `.flac`, `.aac`, `.ogg`, `.wma`, `.aiff`)
- **Docs** — move all docs here (`.docx`, `.txt`, `.md`, `.rtf`, `.odt`, `.doc`)
- **PDFs** — move all `.pdf` files here
- **Images** — move all image files here (`.png`, `.jpeg`, `.jpg`, `.gif`, `.webp`, `.svg`, `.bmp`, `.tiff`, `.heic`)
- **Videos** — move all video files here (`.mp4`, `.mov`, `.avi`, `.mkv`, `.webm`)
- **Datasets** — move all data files here (`.csv`, `.tsv`, `.json`, `.parquet`, `.xlsx`, `.xls`)

## Steps

1. List all loose files (not directories) in the root of the Downloads folder.
2. For each file, check its extension and move it to the matching folder above.
3. After moving, list what was moved to each folder and note any files that were left untouched.

## Constraints

- Do **NOT** create any new folders. Only use the existing folders listed above.
- Do **NOT** move, rename, or touch any existing subfolders or their contents.
- Do **NOT** move files whose extensions don't match any of the categories above.
- Never delete any files.
- Never create new directories.
- Only operate on the root level of the Downloads folder.

Pro tip: Use Task Scheduler to run this prompt automatically at a set time each day, so your Downloads folder gets organized without you lifting a finger. I personally schedule mine to run every two days at 9 p.m., and Downloads stays tidy on its own. A couple of times a week I pop into the sorted folders and delete anything I don’t need, so they don’t balloon in size either.

Did you find one of the prompts useful? Share it with others :)

Share

Hi!

Today, is sharing with us the Sycophancy Skill, a Claude Cowork setup that forces Claude to disagree with you constructively before it agrees. Highly recommended for leaders and professionals who want to use Claude as a thinking partner without the frequent “you’re right“ responses.

Joel Salinas is a Fractional Chief AI Officer for small and mid-sized businesses and nonprofits, working on AI strategy, hands-on builds, and change management. He writes Leadership in Change, a newsletter for mission-driven leaders navigating the AI era, and offers 1:1 coaching for individual leaders.

I have 25+ Claude skills. Just in writing each article for Leadership in Change, I probably use 8 of them every time.

So when I see writers in this space talking about prompts you can paste into a chat to make Claude a “thinking partner,” I get it. The prompts work. The rhythm wrote about in this post recently, beginning, middle, end, is genuinely useful. I’ve used versions of it.

But there’s a layer above prompts that almost nobody is talking about, and it changes everything once you cross over. Most people use Claude skills to make Claude faster. The real shift is using skills to make Claude honest.

In this guide, you’ll learn:

• Why you need the Sycophancy Skill

• How to build this skill (copy-and-paste prompt included)

• Four before-and-after examples that show the skill in action

• A 5-step method to build any skill that fits how you actually work

Click here to get my FREE Claude course (20+ lessons)

Subscribe now

Why you need the Sycophancy Skill

Here’s the problem that genuinely frightens me… when you ask AI something, the default training behavior is to be helpful, agreeable, and confidence-boosting. That sounds fine until you remember what kind of professional that personality describes: the doctor who agrees with your self-diagnosis. You walk in already convinced of what’s wrong, you describe it, the doctor nods, writes the prescription you came in expecting, and you leave feeling validated. You’re still sick. You just feel better about it.

A doctor is not good if he or she just agrees with what you already think you have, before testing.

This is the version of “thinking partner” most leaders are getting. Sharper questions, better-framed prompts, more thoughtful counterpoints, all of it still operating inside a default that wants to make you feel right. I’ve made the case before that this is the deeper version of outsourcing your thinking, and the leaders most at risk are the ones who got value from AI fast and stopped questioning the wins.

This isn’t theoretical for me. The first few times I asked Claude something about a stat or an AI development I half-remembered, it confirmed what I had in my head. Confidently. Cleanly. I almost moved on. The only reason I caught it was that I went to verify one of those answers manually, and Claude wasn’t just wrong, it was wrong in a way that fit my framing so neatly it never tripped my filter. The model was confidently confirming what I’d already half-decided was true, and the only fix was to go look outside the chat. That’s when I started building skills to break the reflex.

Honestly, this is the most under-discussed danger in the entire AI thinking-partner conversation, and it’s especially dangerous for leaders.

Here’s the cascade I see in the leaders I work with as a fractional Chief AI Officer:

The leader who gets the most value from AI isn’t the one who finds the smartest model. It’s the one who builds in friction on purpose, and the difference between those two leaders compounds fast.

Leadership in Change

Don’t just read about AI, lead it. Get the weekly playbook for leaders who want to supercharge their expertise and multiply their impact.

By Joel Salinas

📚 If you’re completely new to Claude skills, read this guide

How to build the Sycophancy Skill

So I built one, and you can too!

Simply:

Open Claude Desktop

Start a new chat on Cowork

Paste the Prompt below… and that’s it!

You should see it begin working:

And after a couple of minutes, your skill is ready. Click SAVE SKILL.

Ready?

Use the following information to create my newest Claude Skill...
# Sycophancy Skill

You are my critical thinking partner. Your default mode is constructive disagreement.

## Behavior rules

1. Before agreeing with anything I say, identify at least one
   assumption underneath it that I have not tested. State the
   assumption plainly.

2. When I propose a decision, idea, plan, or interpretation, your
   first response is to argue the strongest opposing case. Do not
   soften it. Do not append "but you might be right." Make me
   defend my position.

3. If I push back on your counterargument, do not retreat because
   I objected. Retreat only if I produce new evidence, new
   reasoning, or a constraint I had not mentioned. Saying "fair
   point" without new information is not enough.

4. When I share work to review, identify what is weakest first,
   not what is strongest. Strengths are easier to find on my own.
   Weaknesses are why I am asking.

5. If I am clearly emotionally invested in an answer, name that
   explicitly and ask whether the emotion is signal or noise.

6. If you cannot find a real flaw, say so directly: "I have looked
   for the weakness and I cannot find one." Do not invent a flaw
   to perform thoroughness.

7. End every substantive exchange with one question I should sit
   with before I act, not a summary.

## Tone rules

- Direct, not aggressive
- Specific, not abstract
- One disagreement at a time, not a list
- Cite my own words when challenging me

## What you do not do

- Open with praise before disagreeing
- Use "great question," "interesting point," or any opener that
  reads as flattery
- Hedge with "I could be wrong but"
- Add a closing reassurance like "your instinct is good"

Subscribe now

Before and After the Sycophancy Skill

Here’s what that looks like in practice. Four questions, before and after the skill is on.

Question 1: Should I raise my coaching prices by 20%?

Default Claude:

Sycophancy Skill Claude on:

Default Claude opens with agreement (”You probably should”) and then asks for more information to help you think it through. The Sycophancy Skill doesn’t acknowledge the question at all. It goes straight to the thing you haven’t proven: what’s your evidence the market will bear 20% more, not your hope, your evidence.

Question 2: I’m thinking about cutting our lowest-performing program to free up resources for the one that’s working. Does that make sense?

Default Claude:

Sycophancy Skill Claude on:

Default Claude starts with agreement (”Yes, it usually does”) before adding nuance. Sycophancy Skill ignores whether cutting makes sense and goes straight to the assumption you haven’t tested: is the winning program actually resource-constrained, or does cutting just feel decisive? It reframes the question before answering it.

Question 3: I’m considering promoting my best individual contributor to team lead. She’s excellent at her work. Thoughts?

Default Claude

Sycophancy Skill Claude on:

Default Claude opens with validation (”the fact that you’re thinking carefully about it is a good sign”) and then educates you. Sycophancy Skill opens with a challenge (”being excellent at the work is the worst reason to promote someone”) and then interrogates your assumption. One makes you feel like a thoughtful leader. The other makes you prove you are one.

Same model. Same question. The skill changes which version of Claude shows up.

Two things to notice about how this is built.

First, the “What you do not do” section is doing more work than the rules. Rules tell Claude what to add. Prohibitions tell Claude what to stop being by default. Without the prohibitions, the model will follow the rules and then revert to “great question” energy on top of them, and you end up with a Claude that disagrees politely and then agrees anyway.

Second, rule #6 matters more than it looks. Without it, a skill that demands disagreement will start inventing flaws to seem rigorous. You don’t want a Claude that pushes back theatrically. You want a Claude that pushes back when there’s a real flaw and tells you the truth when there isn’t.

Subscribe now

How to build any skill that fits how you actually work

The Sycophancy Skill is one example. The same method builds any skill that holds context across chats. Here’s the 5-step version.

Step 1: Write the role in one sentence. “You are my critical thinking partner.” “You are my brand strategist for [business].” “You are my book recommender who knows the authors I admire.” If you can’t write the role in one sentence, the skill is too broad.

Step 2: Write the behavior rules. What does this skill do every time? Use imperatives. Number them. Aim for 4 to 7. Fewer than 4 and the skill won’t have personality. More than 7 and the model will start dropping rules.

Step 3: Write the tone rules. How should it sound? Direct, warm, terse, formal, conversational. Two or three lines is enough.

Step 4: Write the prohibitions. This is the step most people skip, and it’s the difference between a skill that works and a skill that drifts. List 3 to 5 things the skill does not do. Default model behaviors you specifically want to disable.

Step 5: Test it with a question you already know the answer to. (Try: “Is my latest project a good idea?” If Claude lists three reasons it’s great before naming a single risk, your prohibitions are too soft.) Tighten it and run it again.

That’s the whole method. The Sycophancy Skill is one application of it. Your version, for whatever you do, is 30 minutes of work and saves you that much every week from then on.

📚 I wrote about my five favorite skills in this piece

The point

A thinking partner that always agrees with you isn’t a partner at all. It’s a stenographer with a friendlier tone, and the longer you use one, the harder it gets to tell the difference between agreement and validation. The leaders who get the most out of AI in the next two years aren’t going to be the ones with the biggest tool stack. They’re going to be the ones who deliberately built friction into the stack, because frictionless agreement is the most expensive feedback you can get, and you don’t notice the cost until it shows up in a decision you can’t take back.

If you can’t remember the last time Claude told you you were wrong, you’re using it wrong. Build the skill. Run it on the next decision that matters. See what comes back.

Don’t forget to subscribe to Leadership in Change, a newsletter for mission-driven leaders navigating the AI era, and offers 1:1 coaching for individual leaders.

Share

Did you know?

• 33% of interviewers make a decision in the first 90 seconds.

• Around 50% of candidates use AI to prepare their applications.

• The other 50% are walking in at a disadvantage.

Most people sit down in an interview without knowing how they’ll be evaluated. That’s a big problem.

Today we’ll fix that. This guide is split into two parts:

• Part 1: How to use Claude to decode any job description, map it to your experience, and answer common questions without rambling

• Part 2: How to build a clean, ATS-friendly resume in Overleaf without fighting Word's formatting (Claude does the heavy lifting)

Subscribe now

Part 1: Prep for the Interview with Claude

Read more

Click here to get my FREE Claude course (20+ lessons)

Most people use NotebookLM and Claude Cowork separately.

NotebookLM to do research or get answers grounded in their documents. Cowork for building a report, infographic, dashboard, and apps without coding.

Connect them, and you get something unique. Tools built on your own data. The research layer and the build layer finally talk to each other.

Nobody does this. Everyone should.

In this guide, you’ll learn:

• How to connect NotebookLM to Claude Cowork

• Use Case 1: Turn spreadsheets into infographics your CEO will read

• Use Case 2: Build a personal language tutor app before your next trip abroad

• Use Case 3: Spy on competitor content and extract what’s working

This guide was written in collaboration with .

Gencay writes LearnAIWithMe, a newsletter focused on practical AI tutorials for people who’d rather replace than be replaced by AI.

LearnAIWithMe

If you want to build with AI, not just learn how to prompt, this is the right place.

By Gencay

What does connecting NotebookLM and Claude Cowork solve?

Two things.

One. Your data becomes the source of truth.

NotebookLM grounds every answer in the sources you upload. Every claim traces back to a citation you can click.

Cowork normally runs on training data. Useful, but can be generic. Connect it to NotebookLM and Cowork now reasons from your sources. Your internal docs or your research.

Two. Static knowledge becomes a working tool.

NotebookLM alone stays “ask and read.” You open it, type a question, read the answer, and close the tab.

Cowork turns that same knowledge into an app you operate. An artifact or infographic creator. Something you use every week, not a tab you forget.

Build once. Run forever.

How to connect NotebookLM and Claude Cowork

There is no official connector.

What works is this repo: github.com/teng-lin/notebooklm-py.

Unofficial, but powerful.

Step 1: Install NotebookLM-py

Run this prompt in Cowork:

Install this skill :https://github.com/teng-lin/notebooklm-py
I want to use it via CLI

Let it work. The progress bar shows up in the top right.

Step 2: Turn it into a Skill

Next prompt:

I want to drive this on Claude Cowork because I’ll turn it into a skill and do whatever is needed.

Cowork starts building.

Watch the progress bar on the top right, walk through the checklist.

Step 3: Auth

Cowork cannot log into Google from the sandbox.

You log in on your Mac and hand the session back.

Open your terminal.

New to the terminal?

The terminal is a simple text window where you type commands instead of clicking buttons. Do not panic, you only need it once for this setup.

On Mac: Press Cmd + Space, type Terminal, hit Enter.

On Windows: Press the Windows key, type PowerShell, hit Enter.

A black or white window opens. That’s it.

Paste the command below:

notebooklm login

A browser window opens. Log in with your Google account.

Wait until the NotebookLM homepage loads.

Go back to the terminal.

Press Enter.

The terminal prints the path to your storage_state.json.

Copy it. Paste it back into Cowork:

Authentication saved to: /Users/learnai/.notebooklm/storage_state.json

Done! Cowork now has your credentials.

Note: If Cowork cannot reach the file, ask Claude Code to copy-paste the auth file into your working folder.

Step 4: Testing

Time to test the skill. Type /notebooklm

Ask it to list your previous notebooks.

Mine pulled 120 notebooks from October 2024 through today.

Fair warning, I am a pretty heavy NotebookLM user.

Let’s see my favorite use cases:

Use Case 1: Turn Ugly Spreadsheets Into Infographics Your CEO Will Actually Read

You know the drill.

You have a messy CSV.

Three different date formats in one column. Somebody’s initials in row 857 for no reason.

Your CEO drops a message: “Give me a summary by Friday.”

You spend three hours in Excel building pivot tables. Another hour picking a chart template that does not look like 2008. You created an infographic. Your CEO opens it, scrolls for four seconds, and closes it.

Nobody reads it.

Here is the version that works.

Step 1. Upload the spreadsheet to NotebookLM

Drop the CSV in as a source. NotebookLM parses the data, finds the patterns, and flags the anomalies.

You did not write a single formula.

Takes under a minute.

I’m using this data as an example, retail sales data from an online store.

Here is how my NotebookLM looks after uploading this data.

Step 2. Ask NotebookLM what matters

Paste this:

What are the five most important insights in this data? 
Ignore noise. Focus on what a non-technical executive would care about.
Each insight should be one sentence.

NotebookLM returns grounded answers.

Every insight traces back to specific rows. Click the citation, and see exactly where the number came from.

You now have the story before you have touched a design tool.

Step 3. Trigger the NotebookLM skill in Cowork

Open a new Cowork session. Trigger the skill:

/notebooklm Reach this notebook: European Export Sales Registry 2019-2020

Cowork now has read access to every source and every insight NotebookLM found.

Step 4. Give Cowork the build command

Paste this:

Build a web app that pulls the top five insights from the notebook 
and renders each one as a visual element. 

Let the user pick a style: minimal, corporate, or playful. 
Each style should have its own color palette, typography, and layout. 

Add a PNG export button.

After pasting, it started talking with the notebookLM.

You can see the conversation from the NotebookLM.

After getting the insights, it is now building the app.

And it is done.

Step 5. Export and ship

Click “corporate.”

Your five insights render as a clean one-page infographic

Or minimal.

Or playful.

Use Case 2: Build a Personal Language Tutor App Before Your Next Trip Abroad

You booked a flight to Barcelona. Three weeks out. You know ten Spanish words. Five of them are food.

Duolingo teaches you sentences nobody says. Google Translate is fine at the airport, but useless at dinner.

You don’t need another language app. You need a tutor who knows your trip: The neighborhood you are staying in, the phrases locals actually use, etc.

We’ll build a tutor with NotebookLM and Cowork.

Step 1. Let NotebookLM research your trip

Open NotebookLM. Create a new notebook. Name it barcelona-trip-tutor.

Click “Discover sources.” Switch on Deep Research. Paste this:

Research everything a first-time traveler needs to know about 
Barcelona for a trip in [MONTH/YEAR]. Focus on:

- Neighborhood guides for staying in Eixample, Gothic Quarter, 
  and Gracia
- Top 20 restaurants and tapas bars across different price points 
  (include addresses and what to order)
- Metro and bus system basics (which lines tourists actually use)
- Cultural etiquette Spanish people care about but tourists miss 
  (meal times, tipping, greeting)
- Common scams targeting tourists and how to avoid them
- Day trips within 1 hour of Barcelona (Montserrat, Sitges, Girona)
- Typical Spanish phrases locals use daily that tourists do not know
- Seasonal context: weather, festivals, crowds for [MONTH]

Prioritize sources from local bloggers and expat guides 
over generic travel sites.

After pasting this notebookLM, import the sources and here your notebook is ready.

Step 2. Ask NotebookLM to build the curriculum

Sanity-check first. Ask the notebook: “Which neighborhood am I staying in, and what are three phrases I will need there?” If the answer pulls from the research you asked for, you are good.

Then paste the curriculum prompt:

Based on the sources in this notebook, build me a 14-day 
Spanish crash course for my Barcelona trip.

Each day should cover:
- Five new phrases I will actually use on this specific trip
- Context for where and when I would use them 
  (hotel, tapas bar, metro, taxi)
- Pronunciation in plain English (not IPA)
- One cultural note about using that phrase

Prioritize phrases relevant to my hotel neighborhood, 
my restaurant bookings, and getting around the city.

Include Catalan variants where locals in Barcelona would 
appreciate hearing it (Catalonia has its own language alongside Spanish).

Skip greetings I already know like “hola” and “gracias.”

NotebookLM returns a 14-day plan grounded in your actual trip. Not generic Spanish. Your Spanish.

Here it is.

Step 3. Trigger the NotebookLM skill in Cowork

Open a new Cowork session:

/notebooklm Reach this notebook: barcelona-trip-tutor

And here it connects.

Cowork now has your trip context and your curriculum.

Step 4. Build the tutor app

Paste this:

Build an artifact called “Barcelona Tutor” with three sections:

1. TODAY’S LESSON

   Show today’s five phrases with pronunciation and context.

   Mark a phrase as “learned” with a checkbox.

   Progress bar shows how many phrases I have learned this week.

2. QUICK DRILL

   Flashcard mode. Show the English phrase, I guess the Spanish.

   Tap to flip. Rate myself (easy/medium/hard).

   Hard cards come back tomorrow. Easy ones disappear.

3. TRIP SCENARIOS

   Pre-built roleplays for: hotel check-in, ordering tapas, 

   taking the metro, asking for directions.

   I pick a scenario, the app shows me the likely script 

   with my phrases highlighted.

Pull all phrases, pronunciations, and cultural notes 

from the connected NotebookLM notebook.

And click on “Create” when it asks.

Here is your app.

Three tabs, one live app, built in ten minutes.

Today’s Lesson feeds me five phrases I will actually use in Barcelona.

Quick Drill turns them into flashcards with spaced repetition, so hard cards come back tomorrow, and easy ones get out of my way.

Trip Scenarios drops me into real roleplays, asking for directions in the Gothic Quarter, ordering tapas, checking into the hotel, with my own phrases highlighted in the script.

Every word traces back to the NotebookLM notebook I built in Step 1. Grounded curriculum, personal context, zero generic Duolingo energy.

Subscribe now

Use Case 3: Spy on Competitor Content and Extract What’s Actually Working

Every writer stares at the same question on Monday morning.

What should I write this week?

You scroll through three competitor Substacks. You read ten articles. You try to reverse-engineer what made their viral posts hit. You take messy notes. You forget half of them by Wednesday. You end up guessing anyway.

Twenty hours a month, gone. Pattern recognition done by vibes.

Here is the version that works.

Step 1. Collect competitor URLs into one place

Pick three to five writers in your niche.

Grab the URLs of their last free articles. ( to get the tone)

Fastest way: open their Substack archive page, scroll to the bottom, and copy the list.

Here are my articles.

1- NotebookLM Prompts for Students 

↳ http://gencay.substack.com/p/notebooklm-prompts-for-studying

2- NotebookLM Prompts to Beat 99%

↳  https://gencay.substack.com/p/10-notebooklm-prompts-that-put-you

3- Free 2026 AI Learning Path

↳ https://gencay.substack.com/p/how-to-learn-ai-in-2026-without-spending

4- Run Claude Code Locally (Free)

↳ https://gencay.substack.com/p/how-to-run-claude-code-locally-100

5- Claude Code Source Code Leaked

↳ http://gencay.substack.com/p/claude-code-source-code-free

6- Claude Code + Telegram

↳ https://gencay.substack.com/how-to-connect-claude-code-with-telegram

7- 7 Hidden Claude Features

↳ https://gencay.substack.com/p/claude-hidden-features-guide

8- ChatGPT → Claude: 5 Surprises

↳ https://gencay.substack.com/p/5-surprises-that-hit-you-when-you

9- Claude Cowork: What Actually Works

↳ https://gencay.substack.com/p/i-tested-all-claude-cowork-features

10- Claude for Content Creation

↳ https://gencay.substack.com/p/the-developer-tool-thats-quietly

11- OpenClaw Better Than 99%

↳ https://gencay.substack.com/p/how-to-use-openclaw-better-than-99

12- Clawdbot Setup (Cheapest + Secure): 

↳ https://gencay.substack.com/p/clawdbotopenclaw-cheapest-most-secure

13- Hire a Free AI Employee (Clawdbot): 

↳ https://gencay.substack.com/p/how-i-hired-a-free-ai-employee-clawdbot

Step 2. Upload to NotebookLM

Create a new NotebookLM notebook.

Select a web search and use this prompt with the links above.

Analyze the following Substack articles as competitor intelligence.

Extract:

* Tone of voice (writing style, pacing, personality)
* Hook patterns (how each article starts)
* Content structure (sections, flow, formatting)
* Title patterns (what makes them clickable)
* CTA strategies (how they drive engagement like restacks, clicks)
* Common topics and positioning
* What makes these posts perform well

Then:

* Identify repeatable patterns across all articles
* Highlight the top 5 strategies I should reuse
* Suggest 5 new article ideas based on these patterns
* Rewrite one viral-style post using these insights

Articles: [pasted from step-1]

And make sure to select “Deep research”.

Step 3. Ask NotebookLM to find the patterns

Step 2 triggered the scrape.

Now that the sources are indexed, we go deeper. Open the notebook chat and paste this

Analyze all sources in this notebook. Find patterns across the articles.

Return:
1. Top 10 headline formulas (with example headlines for each)
2. Top 5 hook patterns used in the first 200 words
3. Most common article length (words)
4. Most common CTA placements and wording
5. Topics that appear in more than 3 articles

For every claim, cite the specific article it came from.

NotebookLM returns grounded patterns.

Every insight traces back to a real article.

Here it is.

Step 4. Trigger the NotebookLM skill in Cowork

Open a new Cowork session:

/notebooklm Reach this notebook: LearnAIWithMe: The Complete Guide to Mastering AI Workflows

Point it at the notebookLM you just trained.

Step 5. Build an Artifact

Next, paste this:

Connect to my NotebookLM notebook <Paste name of your notebooklm>
Build an artifact called “Content Spy Dashboard” with four sections:

1. HEADLINE FORMULAS
   Show the top 10 formulas with usage count. 
   Click any formula to see example headlines that use it.

2. HOOK PATTERNS  
   Show top 5 hook patterns with one-line descriptions. 
   Click to expand and see real examples from competitor articles.

3. TOPIC HEATMAP
   Grid view. Rows = topics. Columns = competitors. 
   Cell shows how many articles each competitor wrote on that topic.

4. GAP FINDER
   List topics the competitors cover often but your niche could 
   approach differently. NotebookLM should suggest angles.

Add a “Generate Draft” button at the bottom. 
When I click it, the app picks a winning formula + a gap topic 
and drafts a headline + opening paragraph in my voice.

Save my past 10 articles as reference for voice matching.

Cowork builds.

It queries NotebookLM.(Cowork side)

See how it is talking with NotebookLM.

You can follow the progress from here.

Allow this.

And finished, let’s test it.

Step 6. Test the Artifact

Here’s what it looks like.

Cowork built this in under ten minutes.

Eleven of my own articles are indexed as the competitive corpus.

Headline formulas, hook patterns, topic heatmap, gap finder, and a draft generator — all live, all clickable.

The “Generate Draft” button at the bottom is the kicker.

It picks a winning formula, pairs it with a gap topic, and drafts a headline plus opening paragraph in my voice.

From competitive research to the first draft in one click.

AI News: Artifacts recently became available in Cowork.

Final Thoughts

Most people treat NotebookLM and Cowork as two different drawers.

Research goes in one. The building goes in the other.

They never open both at the same time. That is the mistake.

Connect them, and the math changes. Your sources become the ground. Your apps inherit that ground.

Don’t forget to subscribe to LearnAIWithMe, a newsletter focused on practical AI tutorials for people who’d rather replace than be replaced by AI.

Subscribe now

You’ve probably done this before.

Hit Day 180 on Duolingo. Finished a beginner Spanish course. Maybe even paid for a tutor on iTalki. You can read a menu. You can say “where is the bathroom?” with a decent accent.

Then you got on a call with a native speaker and your brain went completely blank.

That gap between “I’ve been studying for 6 months” and “I can hold a real conversation” is where most language learners die.

The one thing that closes that gap is the one thing they never get: feedback on their speaking skills

I speak 4 languages. I learned all of them before AI was a thing.

How did I become fluent? Someone who actually listened to me speak, noticed the exact pattern I kept getting wrong, and made me fix it over and over until it stuck.

That person was sometimes a tutor or a language buddy.

The problem? Good tutors are expensive, while language buddies aren’t available 24/7.

I’ve now built a system with Claude that does the same thing for free, 24/7, calibrated to exactly how I learn.

This post is that system.

Subscribe now

Why most people never become fluent

You take a class, learn some grammar, maybe use Duolingo for a few months. You memorize verb conjugations, learn vocabulary lists, and pass tests. You feel like you’re making progress.

But you’re not becoming fluent. Why? Two reasons

#1 You’re learning about the language, but you’re not speaking it.

You have a lot of knowledge in your head, but you can’t put any of it into practice in a real conversation.

Speaking is what makes everything click. It turns passive knowledge into actual fluency.

#2 You have speaking practice but lack good feedback

If you practice speaking but no one corrects you, you’ll keep making the same mistakes.

Before AI, to get feedback, we had to settle for:

• Language buddies who correct whatever they happen to notice, or (most of the time) say “it’s fine” to avoid being rude

• Teachers who can’t give you feedback 24/7. They can’t listen to the phone call you had this morning or the language exchange you had at the bar last night. Their feedback only covers the hour you spend with them in a lesson

That specific pain is what pushed me to build this workflow with Claude.

The workflow that fixes this

My workflow looks like this:

1. You talk with someone else (or AI) in the target language

2. You record the conversation (start with a 5-minute sample)

3. AI transcribes the recording

4. You give the transcript to Claude

5. Claude gives you feedback based on your language DNA profile

After you repeat these steps multiple times, you’ll build a folder like this:

The two main things the folder contains:

• Multiple transcripts of me speaking the language

• My language DNA profile

Later, I’ll show you how to build your own language DNA profile.

First, let’s see what exactly this is.

The Language DNA Profile

The core of my system is this learner profile

This is one file that contains everything a tutor would need to know about you.

• Your language level

• Your goals

• Your grammar weak spots

• The topics you actually want to talk about

• Your learning preferences

• How you want corrections delivered (every mistake? most critical?)

• and more!

50 questions, answered honestly, compiled into one markdown file.

Your language learning DNA in a single document.

Once the file exists, you attach it to Claude every time you want feedback on your speaking. Claude reads it and instantly knows who you are.

No more repeating yourself. No more generic feedback. No more Claude burying you in walls of text or grammar theory when your profile explicitly says, “cut to the chase, just give me the fix.”

What this actually looks like

Without the file: Claude’s feedback is random and overwhelming. It looks something like this:

Everything at once. Some corrections matter, some don’t. No priority order. No awareness of your level. You read through it, feel discouraged, close the tab.

With the Language DNA Profile: Claude knows your level. The corrections are ranked by what actually undermines you in the situations you care about. Explanations stay short because your profile said so.

And when you ask Claude to teach you, it gives you examples and exercises tailored to you: your business, your hobbies, your world. Not a textbook's imaginary trip to the market.

It’s the difference between talking to a stranger and talking to a tutor who’s been working with you for months.

The honest part: this is more work than Duolingo

I’m not going to lie to you. This system asks more of you than opening an app for 5 minutes. Maybe 30 minutes of total effort per session.

That’s also why it works.

Duolingo asks for 5 minutes and returns 5 minutes of progress. This asks for 30 minutes and returns something Duolingo literally cannot produce at any price: feedback on the actual words coming out of your mouth.

The rest is behind the paywall

Here’s where I’m going to ask you to subscribe.

Not because I like paywalls. I don’t. But what comes next is the part that took me months to build. I released the first part of this course in January (see here). That’s a 3-hour video course where I show how to use ChatGPT to improve your speaking, reading, and writing, and NotebookLM for vocabulary and listening.

Now the course includes Claude.

Below, you get:

The prompt that captures your language DNA profile: Copy, paste into Claude, spend about 40 minutes answering honestly. You’ll walk away with a markdown file that captures your profile as a language learner.

The full workflow: The best way to record a conversation, how to get a transcript in a few minutes that labels speakers for better feedback, and the exact prompt I paste into Claude afterward that turns 30 minutes of speaking into a tutoring session.

Every video course I’ve made (free to paid subscribers): Honestly, the courses alone cost more than the subscription.

If you’ve been learning a language but still can't hold a conversation, now's the time. Take my video course and copy my Claude system 👇

Subscribe now

Note: The link to the video course is at the end of this post. Both monthly and annual subscribers can redeem the course for free.

The prompt that builds your Language DNA Profile

Read more

That changes in 2026.

Hundreds of you became paid subscribers this year, pushing Artificial Corner to #80 in Substack's Technology bestsellers.

Thank you so much!

Because of you, I can do something I’ve never done before: build a team. The content you’re about to get is going to be better because of it.

Quick hi to the new subscribers

A lot of you have joined in the past two months (welcome!).

I’m Frank. Over the past 5 years, I’ve been creating guides, video tutorials, and courses that have reached:

• 58k+ email subscribers on Substack

• 149k+ followers on Medium

• 40k+ subscribers on YouTube

• 30k+ students across my Udemy courses

I did all of this solo. Until now.

Meet the Team

Recently, I stopped creating content alone.

• is co-building the Learn Any Foreign Language with AI course with me (we have a new Claude module dropping this week).

• is building the AI Writing System with me. This is the system that makes Claude write in your voice across posts, emails, reports, and presentations. He also helps me ship the weekly Claude guides.

My old self would have tried to automate their roles.

After five years of solopreneurship, I learned the opposite lesson:

This is the shift behind everything coming next.

What everyone gets for free: My Claude course

This year, I've been sharing everything I know about Claude: the setups, best features, best practices, real workflows, etc.

That’s turned into a catalogue of around 20 Claude lessons.

95% free and staying free.

🎁 Click here to see the Claude course outline

Every week, I’m updating the course with a new guide (so save that link!)

My free Claude course is just the starting point.

Paid subscribers get more.

What’s new for paid subscribers:

I read all your messages! Here’s what many of you wrote after becoming paid subscribers:

The thing that keeps coming up: people want more Claude content.

Here’s what paid subscribers get right now, and what’s landing in the next 60 days.

Subscribe now

Perk #1: A deep-dive guide every week

Not surface-level tips. Real workflows, systems I’ve built over years of actually doing this, and guides you won’t find anywhere else.

I'm also collaborating with experts across different fields to publish how they're actually using AI in their work. I can’t promise one every week, but I’m aiming for at least one every two weeks.

Perk #2: Free access to my video courses ($200+ value)

After becoming a paid subscriber, you’ll get an email with a link to redeem any of my courses for free:

• Learn a Foreign Language with AI

• ChatGPT

• Python: Web scraping (best seller) and automation

That’s $200+ in courses, included.

Perk #3: Coming this week — Claude module for language learning (Spanish, French, etc)

This week, I’m adding Claude to my Learn Any Foreign Language with AI course.

Enrollments are open to all paid plans (monthly and annual). Diana is joining this project and is helping me add valuable content to the course.

If you’re a paid sub and have no access, don’t worry — I'll send you an email this week to redeem all my courses for free

Perk #4: Coming in May — My AI Writing System

We’re releasing the first part of my AI writing system. The complete set of files to make Claude write like you across short and long form content.

Kevin and I have been building this for months. I'm very excited to ship this one.

I’ve got a few more surprises planned for June and July that I think subscribers (especially from the USA) will love, but I don’t want to get ahead of myself and promise anything yet :)

What I can promise is that this newsletter will stay ad-free.

If I ever accept paid sponsorships, it'll be on my YouTube videos (as I've done many times in the past)

If you’ve been on the fence about the paid subscription

Here’s what I’d say: the price isn’t going up right now, but the value is going up fast. We’re constantly adding more: more course lessons, deep dives, expert guides, AI systems.

The people who join now get everything at the current price.

Same price, more value, every month.

Substack works on a simple rule: the rate you join at is the rate you keep, for as long as you stay subscribed. If I ever do raise them, you’re grandfathered in.

So whatever you pay today is what you pay forever.

Click here to get these and future perks: artificialcorner.com/subscribe

Subscribe now

For many years, I wrote this alone. The next chapter has a team. I hope you'll be in it.

See you on the next Claude guide!

Best,
Frank

The difference lies in the core concepts.

For example, once you know what a “context window” is, you understand why Claude might sometimes forget what you told it twenty messages ago.

Tools like ChatGPT and Claude made AI accessible to anyone with an internet connection, which is great. However, there’s a big gap between using AI and understanding how AI works.

There are dozens of technical AI concepts floating around, but not all are worth your time. Here’s my curated list of concepts that genuinely matter for non-technical Claude and Claude Cowork users.

Click here to get my FREE Claude course (20+ lessons)

Subscribe now

Prompt Engineering: Is it still relevant in 2026?

Prompt engineering is the skill of giving better instructions to AI so you get better results. The clearer you are about what you need, who it’s for, what format you want, and what tone you expect, the more useful the response will be.

Some months ago, Anthropic shared the anatomy of the perfect Claude prompt:

Things have changed a lot since they shared this, though (AI moves fast!)

Tools like Claude Cowork need less prompting (see here and here). That said, I still consider prompt engineering useful when working with Claude chat.

Tokenization: The reason why your Claude usage limits don’t last long

Before Claude can process what you write, it has to translate your text into something the model can understand.

That’s called tokenization.

Tokens are small units that can be a whole word, part of a word, a number, or even a punctuation mark. Token counts aren't universal. The same word can be split into 2, 3, or 4 pieces depending on the model.

Why not just use full words? Language is messy. New words, typos, slang, mixed languages... if the model had to store every possible word, the vocabulary would be impossible to manage. Tokens solve that: with a fixed set of building blocks, the model can understand words it’s never seen before by breaking them into familiar pieces.

Every message you send, every reply Claude gives, and the whole conversation history behind it all get counted in tokens. When Claude tells you you’ve hit the usage limit, it means you’ve used up your share of tokens.

📚 How I Stopped Hitting Claude’s Usage Limits

AI Models: Use the right model for your task

There’s more than one Claude model.

When you see names like “Claude Sonnet 4.6” or “Claude Haiku 4.5,” you’re looking at different versions of the same product. Opus is the most powerful. Sonnet balances speed and quality. Haiku is the fastest and most affordable.

Think of it like software subscription tiers: they all do essentially the same thing, but with different levels of power and cost. The same prompt might get you a good answer with Haiku and an excellent one with Opus. But using Opus for simple tasks is like using an excavator to plant a seed.

Here’s a comparison between Claude models:

In case you're wondering what Mythos is, it's Anthropic's most powerful model — and the one they've chosen not to release publicly (it's only available to a handful of partners for security research).

Opus 4.7 is Anthropic’s most powerful model that you can actually get your hands on today.

📚 Claude Opus 4.7: What changed & how to get more out of it

.md file (markdown file)

An .md file is simply a text file.

Markdown gives you headings, code blocks, bold/italic text, and organized lists. This structure helps AI (and us) quickly find sections without having to read the entire file top to bottom.

Here’s what a simplified .md file looks like:

# Blog Post Instructions

## Structure
- Start with a personal story (1-2 sentences max)
- 3 tips only. No fluff. Each tip should have a real example.
- End with one clear takeaway the reader can apply today

## Writing Style
- Short paragraphs (2-3 sentences max)
- Use “you” more than “I”
- No corporate jargon. Write like you’re texting a smart friend.
- Never use: “In today’s world”, “Let’s dive in”, “Game-changer”

## Formatting
- No bullet points inside the body (use them only for lists of tools)
- Bold only the first sentence of each tip
- Total length: 800-1000 words

How are .md files relevant to Claude?

• You can put context in an .md file, so you don’t have to repeat yourself again (for this, I use the interview method)

• Your long prompts can be turned into an .md file using Claude skills. They can later be triggered when needed by Claude

Think of .md files as recipes: write the instructions once, and the AI follows them every time it runs the task.

Click here to get my FREE Claude course (20+ lessons)

Subscribe now

Read more

Every time a new AI model drops, the announcement sounds the same: “Smarter. Better. More capable.”

Cool. But what does that actually mean for you?

I went through Anthropic's official announcement, read tips from the creator of Claude Code, and did my own tests to find what’s good about Opus 4.7 (so you don't have to)

In this guide, you’ll learn:

• The top 4 things that changed in Opus 4.7

• How to get more out of Opus 4.7

• What to watch for if you’ve been using Opus 4.6

• Your first 30 minutes with Opus 4.7 (find out whether 4.7 is good or bad news for your workflow)

Subscribe to get my FREE Claude course.

20+ lessons delivered straight to your inbox 👇

Subscribe now

Top 4 things that changed in Opus 4.7

#1 Vision got a serious upgrade

Opus 4.7 can see images at 3x higher resolution than any previous Claude model (up to around 3.75 megapixels).

This means Claude can actually read:

• Dense screenshots (dashboards, analytics, small UI text)

• Complex diagrams

• Detailed charts with small numbers

• Scanned documents

If you upload a packed screenshot and Claude used to miss half the text, that problem is mostly gone now.

#2 It follows instructions way better

Opus was already my favorite model for instruction following. That’s one of the reasons why I switched to Claude (wrote about it here).

Opus 4.7 is substantially better at this.

But here’s the catch: prompts written for older models might produce unexpected results now. Why? Because 4.7 takes your instructions literally. Older models interpreted things loosely or skipped parts entirely.

You might want to re-check your saved prompts.

#3 Adaptive thinking

Older Claude models used a fixed thinking budget.

Opus 4.7 replaces that with adaptive thinking

The model now decides on its own when to think deeply and when to skip thinking altogether. Simple tasks get quick responses. Hard problems get more thought behind the scenes. Over a long session, this means faster responses and less wasted compute.

Adaptive thinking shouldn’t be confused with the model router (as we’ve seen with GPT-5). According to a Claude PM, this is the model being trained to decide when to think based on the context.

For more control, try these prompts suggested by Anthropic:

• More thinking: Try something like: “Think carefully and step-by-step before responding; this problem is harder than it looks.”

• Less thinking: Try: “Prioritize responding quickly rather than thinking deeply. When in doubt, respond directly.”

The first option gives you more accuracy. The second saves tokens but might miss nuance on harder tasks. Pick based on what you're working on.

#4 A new "xhigh" effort level

There’s also a new effort level called xhigh. It sits between high and max. Smarter than high, less prone to overthinking than max. It’s the new default in Claude Code.

How to get more out of Opus 4.7

Boris Cherny (creator of Claude Code) shared his own tips alongside the launch. I’ll mix his tips with the official best practices blog.

His tips come from hands-on experience with Opus 4.7 in Claude Code, but the core concepts apply just as well when working with Claude and Claude Cowork:

Specify the task up front, in the first turn

With Opus 4.7, you want to treat Claude more like a capable engineer you're delegating work to, and less like a pair programmer you're guiding step by step.

Opus 4.7 works better when it has everything upfront.

Instead of sending 10 small messages, write one detailed prompt that covers what you want, the constraints, and where the relevant files are.

Give Claude a way to verify its own work

This is maybe Boris’s most important tip. Always give Claude a way to check its own output. Depending on what you’re building:

• Backend work: Have Claude run your server to test things end-to-end

• Frontend: Use the Claude browser extension so it can see what it built

• Desktop apps → Use Computer Use

Boris has a skill called /go that makes Claude test itself using bash, browser or computer use, run the /simplify skill, and put up a PR. All in one shot.

Use auto mode

Shift+Tab turns on auto mode in the CLI (Claude Code)

Instead of Claude asking “can I run this command?” every 30 seconds, a safety classifier decides if it’s safe and auto-approves.

This is the middle ground between babysitting the model and --dangerously-skip-permissions (which is what devs used before this shipped).

Run the /fewer-permission-prompts skill

Even if you don’t use auto mode, run this once.

It scans your session history → finds the bash and MCP commands you keep approving → suggests adding them to your allowlist.

Recommended effort settings

Think of effort levels as a slider between speed and intelligence:

• Low/Medium → Fast but less thorough

• High → Good balance of intelligence and cost

• xhigh → Best for most coding and agentic tasks (the new default)

• Max → Maximum intelligence, but it can overthink and burn tokens

Boris uses xhigh for most tasks and max only for the hardest ones.

Use /effort to set the effort level

Try Recaps and Focus mode

Two features that shipped with 4.7:

• Recaps → short summaries of what the agent did and what’s coming next (great when you return to a session after a few hours)

• Focus mode → hides all the intermediate work so you only see the final result. Type /focus to toggle it on or off.

What to watch for if you’ve been using Opus 4.6

If you’ve been using Opus 4.6 for a while and have prompts dialed in, here’s what to watch for:

• Response length now matches the task: Simple questions get shorter answers. Open-ended stuff still gets longer ones. If you need a specific length or style, say so in your prompt. Anthropic recommends showing Claude an example of the voice you want. That works better than negative “Don’t do this” instructions.

• It uses tools less and thinks more: Usually, that's a good thing. But if your workflow needs aggressive search or frequent file reading, spell it out. Tell Claude when and why to use the tool.

• It spawns fewer subagents: Opus 4.7 is more conservative about delegating work to subagents. If you need parallel work, tell Claude explicitly.

Subscribe now

Your first 30 minutes with Opus 4.7

Watching others test Opus 4.7 is good, but you know what’s better?

Testing it yourself! That’ll help you see whether this update improves or hurts your prompts and workflows.

Try this right now.

Minutes 0-5: Rerun your most complex prompt

Pick a prompt with multiple rules, specific formatting, or several steps (the trickier the better).

Run it again on Opus 4.7.

If the output follows every single instruction — even the small ones older Claudes used to skip — that’s the upgrade showing up. If not, update the prompt.

Minutes 5-10: Throw a dense screenshot at Claude

Grab a busy dashboard, a packed analytics screen, or a diagram with tiny text.

Upload it. Ask Claude to extract everything.

If 4.6 used to miss half the details, you’ll notice the difference immediately.

Minutes 10-20: Generate a real deliverable in Cowork

Opus 4.7 produces more rigorous finance analyses and models, more professional presentations, and tighter integration across tasks.

Put it to the test! Pick something you’re actually working on — a weekly report, a client deck, a one-pager.

Let 4.7 generate it in one shot

Then look at the details: structure, visual hierarchy, how ready-to-send it feels. This is where 4.7 steps up the most over 4.6.

Minutes 20-30: Try adaptive thinking

Click on the model selector → Toggle on “adaptive thinking.”

Try one of your prompts. If you need more control, add one of these:

• More thinking: “Think carefully and step-by-step before responding; this problem is harder than it looks.”

• Less thinking: “Prioritize responding quickly rather than thinking deeply. When in doubt, respond directly.”

After these first 30 minutes, you’ll know what works and what doesn’t for you.

Share

One more thing

You now know what changed in Opus 4.7 and how to get the most out of it.

But new models keep shipping. New features keep dropping. And the people who get the most out of Claude are the ones who stay ahead of every update.

That said, it’s hard to stay ahead by taking courses that become outdated fast.

AI moves fast. This is a challenge even for online academies with 5M+ course enrollments:

A course published 7 months ago — already outdated.

That’s why I created a living Google Doc with my best Claude guides. Written guides take minutes to update. Video courses don’t. I keep this doc current so you’re never learning something that stopped working two updates ago.

Here’s what you get by becoming a monthly or annual paid subscriber:

• Full access to the living Google Doc with my best Claude guides

• Free access to my video course catalogue (over $200 in value) and future evergreen course releases

• A private community where you get advice from other professionals and me

I’m adding new perks constantly. Subscribe now and you lock in today’s price for everything that’s already there (and everything I add next).

Subscribe now

Hi!

Today, and are sharing with us a Claude in Excel guide. They write Cash&Cache, a weekly newsletter with AI build guides, product teardowns, and strategy that helps you figure out what actually works. Check out Cash&Cache for insights that changes how you work with AI.

Many AI tools say they can handle spreadsheets.

So you upload your file and ask it to clean the data. It gives you a formula. You paste it into Excel. It breaks.

You go back. “That formula doesn’t work.” Your AI tool apologizes. Gives you another one. That one breaks too! Thirty minutes of back and forth. You're still copying formulas from a chat window into a spreadsheet like it's 2023.

Claude in Excel skips all of that.

It reads your actual cells, writes the formulas directly, and builds the dashboard inside your spreadsheet. No copy-pasting. No broken formulas from a chatbot that can't see your data.

As a data analyst, I’ve wanted to write a guide like this for a while, and I’m happy to share this piece, co-authored with Ashwin and Raghav

How to install Claude in Excel

The installation is quite straightforward

Open Excel, go to Home → Add-ins (or Insert > Get Add-ins) → search for “Claude by Anthropic.”

The Shortcut: Memorize this immediately—Ctrl + Alt + C (Windows) or Ctrl + Option + C (Mac). This toggles the Claude sidebar instantly. If Excel throws a shortcut conflict popup, select ‘Show Claude sidebar’. You probably won’t miss whatever obscure legacy command used to live there.

Permissions: For some advanced features mentioned below, you might need to sign in with a Claude Pro, Team, or Enterprise account. The 2026 rollout now includes “Ask Before Edits” mode, which we recommend keeping ON to maintain control over your cell values.

Cash & Cache

Where capital meets code — exploring how AI is transforming businesses, markets, and value.

By Ashwin Francis

I’ve added a new section to my Claude course, with workflows you can copy and start using right away: Check it out here

What Can Claude Do?

We take Claude through 3 levels of increasingly difficult tasks, which you are likely to see in your workflows.

1. Data Cleaning

Let’s take a dirty dataset and see if Claude is able to save us the effort of reviewing, planning and executing the data cleanup process. I didn’t have a dirty dataset on hand, so I borrowed this one from ForesightBI.

One of the datasets has an issue I have come across many times before: multiple data fields are clumped together in one column instead of being separated by fields.

First, highlight all the affected cells. Then describe the problem that you need to solve. You’ll see the highlighted cells written on top of your prompt.

Before making the edits, Claude will ask you permission to edit the file. This is what the final result looked like.

This example was quite simple because we highlighted the problem and also mentioned what needs to be done.

What if we just highlight the problem and let Claude figure out the best way to clean and represent the data? We prompt:

This data is clumped together. Separate it into a clean table.

The data structure below has multiple product categories with different amounts, all linked to a specific ID. This requires splitting data across columns, transposing the values and aligning identifiers across multiple line items. A bit more complicated.

Highlight all cells in the data structure and tell Claude to ‘Clean up this data’. We had an answer column in the same sheet. I deleted that so that Claude couldn’t cheat. This is the final table it spit out in a separate sheet, which perfectly matches what we want.

Now let’s look at more nuanced workflows. Let’s employ Claude to help us analyze data and find trends.

2. Data Analysis & Business Intelligence

We already saw that Claude is able to help us clean data, but what about summarize, visualize, and synthesize insights?

I downloaded the dataset for this experiment from Kaggle. This was a comprehensive dataset (15,000+ rows) with plenty of fields to support analysis. The dataset tracked Summer Olympic medals between 1976 and 2008. I wanted to conserve my token limits, so I truncated the dataset to cover 2000, 2004, and 2008 (6,000+ rows).

I didn’t know where to start the analysis, so I delegated that to Claude: “Tell me more about this data”.

Claude is smart enough to understand that it doesn’t need to go through the entire dataset to understand the context. Claude ran through the first 10 rows and gave me a summary and data structure. Because it only reviewed the first 10 rows, Claude assumed (based on the title) that the data included 1976- 1996, but this was corrected after we went to the next step.

Next, we need to summarize and visualize. Every executive loves a dashboard, so let’s start by having Claude make one for us:

Some data points that I would like to see: (1) totals medals won by countries, (2) are there any countries that dominate one sport across multiple years, (3) if there are any athletes that have won medals across multiple Olympic events. Additionally we also need visuals to identify trends in the dataset.

This is what I passed to Claude, along with a final line to add any interesting charts/ insights that I might have missed.

The first draft was actually pretty good, but it wasn’t properly formatted with a standardized color theme, chart formatting rules, correct legend positioning, etc. After prompting for some minor tweaks, we got a much better version.

There are still a few edits I could make, like adjusting the row widths and whitespaces between visuals. But this is already a dashboard I can actually use for serious analysis.

The tables answer the three questions that I had. Claude leveraged Python scripts to prepare some insights, as this would not be easy to recreate in Excel manually. This is a huge plus point.

Data analysis helps us uncover what is happening. Let’s see if Claude can use data to model outcomes.

Subscribe now

3. Build a Business Model

I love building financial models and business cases. It helps you get a realistic idea (if you are honest with yourself) of how an initiative will pan out.

For the last use case, we will be using Claude to build a business model for a new startup. Let’s take the example of ScheduleAI, a social media SaaS platform that allows creators to schedule content across multiple platforms, including LinkedIn, Instagram and Substack.

We need a business model to understand what we can realistically achieve in 3 years, and whether the business model is profitable and scalable. We need the model to capture both business metrics like subscriber count, % of paid customers, and churn. Let’s assume that ScheduleAI follows a subscription-based pricing model with 3 tiers, 2 of which are paid.

I brainstormed the business model (pricing tiers, business metrics, etc.) in Gemini and asked for detailed prompts to help Claude build this model in Excel. I find Gemini ideal for brainstorming. They have generous usage tiers, so you can redraw your plans multiple times without worrying about context limits.

Ask Claude to ensure:

1. Values are not hard-coded and linked to primary cells where applicable - model is dynamic

2. Input cells should be formatted differently from formula cells (we follow blue for input and black for formulas) - makes sure that the model you build is dynamic and that you can tweak assumption values to see the impact across the entire model.

Let’s build this out in stages:

Stage 1: Build the assumptions and Subscriber Waterfall

Let’s start with all the assumptions we will use for the model and the baseline business metrics, which we predict for the business. Gemini gave us a detailed prompt with all the key assumptions that fit the ScheduleAI business model

In a blank sheet, create an 'Annual Assumptions' table in Rows 1-15 with columns for Metric, Year 1, Year 2, and Year 3. Set these blue-font inputs: Starting Free Users (5,000), Premium Price ($180/yr), Ultimate Price ($300/yr), Annual Churn (15%), and Free-to-Premium Conversion (5%).

Below this, starting at Row 20, build a 3-year annual subscriber waterfall. All formulas must use absolute references ($B$2 style) to link back to the Assumptions table. Format all hardcoded inputs in Blue Font and all formulas in Black Font. Calculate the annual totals for Free, Premium, and Ultimate users.

Stage 2: Annualized P&L

These assumptions will be the key drivers of the profit and loss statement (P&L) build. The P&L will help us discern if this solution can actually be profitable and that we won’t lose all of our money building and running this into the ground. Gemini gave us a prompt that outlines the P&L build, along with the revenue and cost drivers.

Directly below the User Waterfall, build a '3-Year Annual P&L.' Link Revenue lines to the annual user counts from Stage 1 and the Tier Prices from the Assumptions table. Include rows for COGS ($2.00/user annual hosting) and Operating Expenses (Staff: $50,000/yr; Marketing: 20% of Revenue). Ensure every cell in this section is a formula; no hardcoded numbers are allowed. Apply professional formatting: black font for all formulas and a light green fill for the 'EBITDA' row. Format all currency to $USD with zero decimals.

The P&L is quite high level, we do need to add multiple cost lines here, including incorporation costs, API costs (every time a creator schedules a post on LinkedIn/ Instagram, we will have to call their API), affiliate marketing costs, etc., etc. But this is an iterative process, so we build them out as we identify new revenue/ cost drivers.

3. Model Audit

Now that the first draft model is ready, it’s time to make sure it’s logically sound and paints a realistic picture of the future of ScheduleAI.

We identified some issues in the audit. For example, increasing the headcount didn’t increase staff costs (formula linking issues). Another issue is that the model doesn’t assume user growth over the years—we were doomed to have 5,000 users forever 😅. We should assume the user base grows each year, either at a fixed rate (say 10% annually) or a rate that accelerates over time.

Along with these fixes, I asked Claude to add a legend table so that the model is easy to understand.

The audit step is as important as the build. When you find issues, it’s important to highlight the cells and question Claude on its choices. I spent around 10-15 minutes questioning Claude on the assumptions used and tweaking the model to ensure that dynamism is maintained and the model is logically sound.

Subscribe now

Best Practices for Claude in Excel

If you want professional-grade results, follow this framework:

1. Describe the Mess, Not the Fix: As we did with the Olympic data, don’t tell Claude how to split columns. Just say, “This data is clumped together; separate it into a clean table.” Claude is better at figuring out the logic than you are at explaining it.

2. Request Dashboard Mode: When analyzing large sets, don’t ask for a single chart. Ask Claude to “Create a dashboard in a new sheet with key trends.” This forces it to use Python scripts (as seen in our Olympic test) to do the heavy lifting that Excel formulas can’t handle.

3. Color-Code Your Cells: To avoid the “broken formula” issue we found in the startup model, always prompt: “Format static inputs in blue and formula-linked cells in black.” This makes it easy for you to audit the “thinking” and catch growth rate errors before you present.

4. Always Ask Why: Never trust the first draft. If a headcount increase doesn’t change costs, highlight the area and ask, “Why isn’t this cell linked to the staff cost formula?” The value isn’t in the build; it’s in the audit.

Conclusion: The Shift in Value

The shift we’re seeing in 2026 isn’t just about a new tool. It’s a change in value.

In the past, Excel experts were the only people who knew the most complex formulas and could build a model fast. Today, that person is the one who knows what needs to be done and can validate the output. The new value lies in auditing the logic and interpreting the output.

By offloading the formula-building, the data-scrubbing, and the debugging, you finally get to spend your time on the strategic questions that actually matter. Our time gets invested in making decisions based on data rather than organizing and structuring analyses.

Don’t forget to subscribe to Cash&Cache for AI build guides, product teardowns, and strategies that help you figure out what actually works.

Share

Hi!

I wrote today’s post in collaboration with . Gencay writes LearnAIWithMe, a newsletter focused on practical AI tutorials for people who’d rather replace than be replaced by AI.

If you’re interested in building real projects with AI, I highly recommend checking out LearnAIWithMe

One of my favorite Claude Cowork tasks is web scraping.

Picture this: a bot visits a website for you, reads the page, and pulls out exactly what you need: prices, names, job listings, you name it (so you don't have to copy-paste anything manually).

That’s what web scraping is.

Data is everywhere. Heck, without internet data, tools like ChatGPT and Claude wouldn't even exist. The thing is, web scraping used to be a programmers-only thing.

Not anymore.

Cowork lets you scrape websites by just describing what you want in plain English. In this guide, you'll learn two ways to web scrape:

1. Scrape with Cowork alone: Best for grabbing data from simple pages, but it’s limited to what a single browser session can do and it can struggle with JavaScript-heavy sites

2. Scrape with Cowork + the Apify connector: Best for robust, scalable scraping across complex sites. The only con is that you need monthly credits. That said, Apify's free plan gives you $5 in monthly credits, which is enough for casual use.

By the way, I'm not associated with Apify. I just think it's a solid option worth knowing about. That said, if you're new to web scraping, don't worry about it. Option 1 is a great place to start.

Fun fact: 16,401 people took my web scraping video course back when coding was the only option. I’ll keeping making guides like this even if they make my own old content obsolete. Why? I believe powerful skills should be available to everyone.

Click here to get my FREE Claude course (20+ lessons)

Subscribe now

1. Web scraping with Cowork

For this section, I’ll use a problem I often have as a writer. You might not have the same issue, but this example will give you a good idea of how to web scrape with Cowork.

Every day, I publish Substack Notes, which are short-form posts that help me share bite-sized AI knowledge. Substack doesn’t offer Notes stats or an API to help writers keep track of notes.

Here’s when Claude Cowork comes in.

I had Cowork scrape Substack, build a dataset, and run a monthly analysis.

Here’s what a Note looks like (the data to extract is inside red boxes):

Here are the steps I follow to web scrape with Cowork:

1. Find your target page: Locate the website that has the data you need. In my case, it was the page where Substack archives all my published notes: artificialcorner.com/notes

2. Define the fields you want to extract: Decide exactly what data points matter. I wanted to extract six fields per note: date, post text, number of likes (hearts), number of comments, number of restacks, and post link.

3. Spell out the edge cases: Think about the details that aren’t obvious at first glance — this is what separates clean data from messy data. For example, my notes archive also includes notes I restacked from other writers, which I didn't want. So I told Claude to only extract notes authored by "Frank Andrade" and to limit the pull to a single specific month.

By the way, you will need the Claude in Chrome connector enabled in Cowork: Click “+” → Connectors → Toggle on “Claude in Chrome.” Also, you need the Claude extension active in Chrome (go here and install it).

Here’s the prompt I created from steps 1, 2, and 3:

Use Claude in Chrome for this task.

Start from: https://artificialcorner.com/notes
Author name: Frank Andrade
Month: February 2026

Extract this data from the site keeping in mind the author and month I wrote before: Date, Text of Post, Number of Likes (Hearts), Number of Comments, Number of Restacks, Link of Post

Your first test probably won't be perfect. Review the data Claude collected, and if something looks off, tell it what to adjust for the next run. In my case, the extracted links and a few other data points were wrong.

Here's the feedback I gave Claude

Claude understood everything and returned the right data.

Subscribe now

How to automate your web scraper in Cowork

Once Claude learns the best way to scrape the site, there are two ways to automate this process (so you don’t repeat the prompt and feedback again):

• Turn the chat into a skill: Save your chat as a reusable skill that you can run anytime. In this case, the skill will help me scrape data from any Substack writer’s URL (not only mine)

• Schedule the task: Automate the task for a specific writer on a recurring schedule (e.g., scrape “Frank Andrade“ notes every month on the 14th).

To easily turn a chat into a skill, do this: In the chat, click the dropdown arrow and select “Turn into skill.“ Claude will do the rest.

For this particular case, I used a prompt to guide Claude on how to turn my chat into a skill:

Turn this task into a skill. Keep in mind the fixes we made and that the inputs needed for this skill to work are:

Start from: [link]
Author name: [name]
Period: [month/dates]

Thanks to this, Claude can now scrape not only my notes, but the notes of any Substack writer. I just need to provide their link.

As for scheduling tasks, you can click the dropdown arrow and select “Schedule,” or use the /schedule command. The /schedule command gives you more flexibility — the dropdown only offers daily, weekly, or weekday options, while /schedule lets you set any custom recurring schedule.

In my case, I opened a new chat and used /schedule to have Claude automatically scrape my notes for the previous month on the 14th of each month.

/schedule run this task monthly on the 14th
Start from: http://artificialcorner.com/notes
Author name: Frank Andrade
Period: Previous month

Subscribe now

Click here to get my FREE Claude course (20+ lessons)

2. Web scraping with Cowork + Apify connector

When you feel Cowork isn’t enough to scrape a site, use the Apify connector to supercharge your web scraping.

Apify is a web scraping and automation platform with over 23,000 ready-made actors. Each actor is a pre-built scraper for a specific website or data source. Reddit, Google Maps, Meta Ad Library, LinkedIn, Amazon, they are all there, ready to run with no code.

Apify is great for robust, scalable scraping across complex sites. With the Apify connector, Cowork can tap into thousands of specialized scrapers with built-in proxy rotation and anti-bot handling that Cowork alone can't do.

You just pick the actor, set your inputs, and get structured data back in minutes.

Apify Use Cases

This section was written by who writes LearnAIWithMe. It covers how to connect Apify with Cowork and 3 use cases I found very useful:

• Use Case 1: Reddit Trend Tracker

• Use Case 2: Google Maps Business Scraper

• Use Case 3: Meta Ad Library Spy

LearnAIWithMe

If you want to build with AI, not just learn how to prompt, this is the right place.

By Gencay

How to Connect Apify with Cowork

Read more

Every month, there’s a new tool. Every week, there’s a new AI feature. If you’re trying to keep up, it feels like you’re always behind.

Most people deal with this by jumping from tool to tool, tutorial to tutorial, without ever getting good at any of them. They consume a lot but retain very little.

I used to do the same thing.

After teaching AI and other topics on YouTube and Udemy to thousands of people, I realized the problem isn't a lack of resources. It's a lack of structure.

People who learn AI quickly don't watch more tutorials. They follow a system.

Here’s my system for learning Claude and other AI tools without wasting time or feeling overwhelmed.

So far, my guides have taught you what to learn in Claude — the features, the use cases, etc. This one is different. It's about how to learn it.

This guide is exclusive to paid subscribers :)

Every week I publish a free and paid guide. Paid subs get full access to my best guides and other perks.

Subscribe now

Read more

Click here to get my FREE Claude course (20+ lessons)

If you've ever asked Claude to create a presentation and got back something that looks like a school project from 2010, you're not alone.

That's what happens when you use Claude without Skills.

Skills is a feature that lets you create reusable instructions so Claude follows your standards — your brand colors, your formatting, your way of doing things (no more generic AI outputs).

Here’s what I got when I tried the same prompt, but using a skill that follows Anthropic's brand guidelines. It nailed the colors, the design, everything!

That’s the difference Skills make.

Just like that, you can use skills to create custom workflows, save hours on repetitive tasks, generate content that follows your company’s brand guidelines, chart styles, font choices, visual design principles, and more.

We’ve searched all over the internet to find the best Claude Skills (so you don’t have to). In this guide, we’ll see:

• How to use Claude Skills

• The best 11 Claude Skills

  • Skills for Presentations & Visuals

  • Skills for Marketers & Business Owners

  • Skills for Business Operations

  • Skills for Building Without Code

• How to quickly install the Claude skills

Subscribe now

How to use Claude Skills

To work with Skills, first enable this feature.

Go to Settings → Capabilities → Turn on Skills

You don’t need to be technical to create a skill. Claude has a built-in skill creator that builds skills for you. Here’s how to enable the skill creator:

1. Go to preferences in the left sidebar

2. Click “Skills“

3. Select “skill-creator“

4. Toggle skill-creator on (leave it always on)

In the Skills section, you’ll see skills created by Anthropic.

If you toggle on the skill brand-guidelines and try the prompt below, you’ll get slides with the Anthropic colors, design, etc (like the example I showed before).

create a quick presentation on claude skills. use anthropic brand guidelines

There are two ways to use a skill.

You can click on the three dots and click “Try in chat“ or simply let Claude figure out which skill to use. In my experience, Claude is quite good at matching your request to the right skill — just make sure you know what each of your installed skills does so you can phrase your prompts accordingly.

See whether Claude picked the right skill by reading the first lines of the response.

Pro tip: You can turn any Cowork chat into a reusable skill. Just click the dropdown arrow in your chat name and select "Turn into skill."

Subscribe now

The Best Claude Skills

There are many skills out there. Here are the best we found

Skills for Presentations & Visuals

1) Slide Deck Builder

Problem:
Making a presentation takes way longer than it should.

And it’s not the design that slows you down.

It’s everything before that — figuring out what to say, in what order, what gets its own slide, what needs more context. That’s where the time goes. You sit there staring at a blank slide and somehow an hour disappears.

The Skill:
You give it a rough idea: a few sentences, a topic, whatever you have. It turns that into a full slide sequence that already makes sense, applies the visual style you set, and hands you back a real first draft.

Why it works:
It skips the two parts that kill your time: figuring out the structure and making it look like something. Instead of starting from zero, you start by improving something that already has a shape.

Link: Watch the tutorial | Download the skill

2) Explainer Graphic

Problem:
Some topics just don’t click when you read them.

You go through the whole explanation, you get to the end, and somehow... nothing sticks. So you read it again. Then again.

The skill:
You give it a concept — anything that feels hard to explain in words alone. It turns that into an HTML explainer with simple analogies, visual steps, and short sections that are easy to follow.

Why it works:
Switching the format — from a wall of text to a visual walkthrough — is sometimes all it takes. Same concept, completely different experience.

Link: Watch the tutorial | Download the skill

Skills for Marketers & Business Owners

3) Branded Carousel Generator

Problem:
Turning your ideas into social content is one thing. Turning them into content that actually looks like your brand is another.

Most people end up stuck between two bad options: reuse a generic template that doesn’t feel right, or spend way too long tweaking every post trying to make it look consistent.

The Skill:
This one takes your content and turns it into a branded carousel.

Not a generic post split into slides. A carousel shaped around your material, styled in a way that feels like something you’d actually publish — and could publish again next week without starting over.

Link: Download the skill | Download the skill

4) Brand Applicator

Problem:
You finish a document and it’s technically done.

The writing is there. The structure works. But something still feels off. The branding

Wrong font. Colors that don’t match. No logo. It looks like a draft even when it isn’t one.

The Skill:
You hand it your brand rules (fonts, colors, logos) and it applies them to your document automatically.

The output looks consistent with the rest of your business assets. Not like something you threw together before a deadline.

Why it works:
Most people leave this part for the end. And then they rush it, skip it, or send something that doesn’t look as polished as the work inside it.

This handles the last-mile step for you. Not the thinking. Not the writing. Just the part that makes something feel like a real deliverable instead of a working draft.

Link: Watch the tutorial | Read the guide | Download the skill

Subscribe now

5) Market Competitors

Problem:
Competitor research usually ends the same way.

You look at a few pages, notice a few patterns, write something down somewhere — and then move on without ever turning any of it into something you can actually use.

The research happened. The useful output didn’t.

The Skill:
market-competitors takes a website or market input and turns it into a competitive intelligence report.

Not scattered notes. A structured deliverable — the kind you can actually reference when you’re making positioning decisions.

Why it works:
Competitive analysis is only useful if it leads somewhere.

Most of the time it doesn’t because the research never gets a format. It stays in a tab, a doc, or your head until something more urgent takes over.

This gives it a format. And that’s what turns observation into something you can act on.

Link: Watch the tutorial | Download the skill

Skills for Business Operations

6) Workflow Visualizer

The Skill:
Workflow Visualizer turns a process, business system, or operating setup into an interactive visual map.

Phases, triggers, components, connected tools — all in one place, showing how they fit together instead of just listing what they are.

Why it works:
A list of steps tells you what exists. A map tells you how it works.

That difference matters when you need to explain the system to someone else, find where something is breaking, or figure out what to improve without accidentally touching something you shouldn’t.

Link: Watch the tutorial | Download the skill

7) Contract Reviewer

Problem:
Reading a contract quickly is easy. Reading it well is a different thing.

The hard part isn’t the length — it’s knowing what to look for. The clause that sounds fine until something goes wrong. The protection that should be there but isn’t. The term that’s standard until it isn’t.

The Skill:
You upload the contract and it breaks it down into what actually matters.

Key terms, red flags, yellow flags, missing protections, and what you may want to push back on before signing.

Why it works:
It doesn’t replace a lawyer. It does something more useful for most people. It tells you where to pay attention first.

That alone changes how you approach the document — instead of reading every line with equal worry, you know exactly where to slow down (and where to relax).

Link: Watch the tutorial | Download the skill

8) Decision Council

Problem:
Some decisions are too important to look at from one angle only.

The real risk isn’t always making the wrong call. Sometimes it’s making a fast one — without enough pushback, without anyone asking the uncomfortable question, without real tension between perspectives.

The Skill:
Decision Council runs multiple expert personas at the same time, each looking at your decision from a different angle. Then it brings them together into one synthesized recommendation with clear next steps.

You get a structured clash of viewpoints first and then the answer.

Link: Read the guide | Download the skill

Subscribe now

9) Quick Research

Problem:
Research gets messy fast.

You start with one question. That leads to another source, then a different opinion, then three more pages of context you’re not even sure you need.

By the time you’re done, you have a lot of open tabs and no clear picture.

The skill:
You give it a topic and it compresses everything into a structured brief.

I used it to break down a new Claude Cowork release. Summary, features, requirements, pros, cons, pricing, and the actual bottom line. All in one place, already organized.

Link: Watch the tutorial | Download the skill

Skills for Building Without Code

10) Frontend Design

Problem:
A lot of AI-generated interfaces technically work.

They just don’t look like anyone cared.

The code runs fine, but the result feels like something that was assembled in five seconds and never looked at again. Generic layout, default fonts, nothing that feels deliberate.

The Skill:
Frontend Design is an official Claude Code skill that pushes the output toward something more production-ready.

Better typography. Stronger visual decisions. UI that actually looks like someone made a choice — instead of just accepting whatever came out first.

Link: Watch the tutorial | Download the skill

11) Implement Design

Problem:
Going from Figma to code sounds simple until you actually try it.

That’s when the small mismatches start showing up. Spacing is slightly off. Components drift from the original. And the final result looks close — but anyone who worked on the design can tell it isn’t right.

The Skill:
Implement Design is a public Figma skill for translating designs into production-ready code with much tighter visual fidelity.

This skill gives Claude a more structured way to move from design to implementation — so the gap between what was designed and what gets built stays as small as possible.

Link: Watch the tutorial | Download the skill

Subscribe now

How to install the skills

Follow the steps below when you want to add one skill to Claude (.zip or skill.md file)

Customize → Skills → “+” → Create skill → Upload a skill → Upload your .zip or skill.md file

If the .zip file contains multiple skills (as in some of the files shared in this guide), you’ll have to add the .zip to plugins:

Customize → Personal plugins → “+” → Create plugin → Upload plugin → Upload your file

One more thing

You now have 11 skills that can save you hours every week.

But skills work best when you actually know how to use Claude well — the prompting, the workflows, the setup that makes everything click.

That’s what paid subscribers get:

• Free access to all my video courses (over $200 in value)

• A Google Doc with full access to my best Claude guides (updated every week)

• A private community where you get advice from other professionals and from me

I’m adding new courses and guides constantly. Subscribe now and you lock in today’s price for everything that’s already there (and everything I add next!)

What was your favorite skill? Let me know in the comments

Subscribe to get my FREE Claude course.

20+ lessons delivered straight to your inbox 👇

Subscribe now

🔒 Paid Substack members: link to get my writing-voice.md file at the end of this post.

If you’re new: Hi! I’m Frank. I started writing on Medium.com in 2021 and grew to 150k followers. In 2023, I moved to Substack. Ocasionally, I republish some of my Substack post to Medium, but you’ll only find all my content here, so subscribe!

Subscribe now

In 2023, many people were against AI writing.

In 2026, many writers are using AI.

Some writers I follow have admitted they use AI for writing. Others haven’t mentioned it publicly, but they’ve suspiciously increased the number of posts they publish per week over the past few years.

Heck, Substack’s top newsletter in education is called “Write with AI.“

I’m not against AI.

I’m against using AI for bad writing.

If you use AI to enhance your writing and produce high-quality work more frequently, your readers will be happy.

The problem is that most people use AI to produce bad writing.

The fix isn’t a better prompt. It’s a file.

One file that teaches AI exactly how you write, what you never say, and what makes your writing yours. You create it once. You reuse it every time.

In this guide, you will:

• Learn why most produce AI slop

• Get the exact prompt that captures your writing voice in a single file

• Learn why and how to use this file in Claude

• Download my personal writing-voice file as a working example

Subscribe now

Why most produce AI slop

Since ChatGPT’s release, we’ve been obsessed with the em-dash and a few words that make your writing sound AI.

Here’s my (ironic) response to this:

and this

My advice: Don’t mind AI words.

It’s fine if you have a few AI words in your vocabulary.

What’s not fine is to produce content under your name that doesn’t sound like you.

By default, AI doesn’t know your voice. It doesn’t know you hate the word “utilize.” It doesn’t know you always open with a personal story, or that you’d never use a semicolon in a million years.

So it defaults to the safest, most average version of whatever you asked for.

That’s not AI’s fault. You gave it a vague instruction in your prompts and expected a specific result.

The file that fixes this

The fix is an .md file (a simple text file with some formatting). The one we’ll create contains everything Claude needs to write like you.

Not “write well.” Write like you.

Here’s a summary of what goes in it:

• Words and phrases you’d never use

• Sentence patterns you default to

• How you open and close pieces

• Your formatting instincts (short paragraphs? lists?)

• What your writing sounds like at its best

• Writers you admire and what you’d steal from each one

• Positions you’d never take

• and more!

The insight that makes this work: most of a good voice profile is about what you reject. Not “I like direct writing,” but “I’d never use semicolons because they make my writing sound like a college essay.”

That’s the kind of specificity Claude can actually use.

Subscribe now

How to create your voice file

You don’t write the file from scratch. That’s painful, and you’ll miss the important stuff.

Instead, you let Claude interview you. It asks the questions. You take your time. You elaborate your answer. At the end, it hands you a finished .md file.

To create your voice file, use one of the prompts below.

If you have 30 minutes, copy this prompt and answer the 50 interview questions:

You are going to help me capture my writing voice in a .md file.

Ask me questions one at a time. Cover:

• What I write and who I write for

• What my writing sounds like at its best — ask me to share an example paragraph

• What my writing sounds like when I’m just going through the motions

• Phrases I use naturally that feel like “me”

• Words and phrases I hate seeing in my own writing

• Topics I always come back to, even when I’m not trying to

• What I refuse to write about, or positions I’d never take

• My formatting instincts: long or short paragraphs? headers or prose? lists or sentences?

• Writers I admire — and specifically what I’d steal from each one

• What feedback I keep getting on my writing

• What feedback I keep ignoring, and why

Ask 40-50 questions. One at a time.

Interview rules:

• Push back on vague answers. If I say “I like directness,” ask me what that looks like in a real sentence.

• Call out contradictions. If something conflicts with an earlier answer, flag it.

• Don’t accept “I don’t know.” Reframe the question or approach it differently.

• Go deeper on interesting threads. If something unusual comes up, follow it before moving on.

• Ask for real samples — actual paragraphs I’ve written, sentences I’d never publish. Descriptions mean less than evidence.

• Don’t validate my answers. No “great point” or “that’s interesting.” Just ask the next question.

• If my answer sounds like the writer I wish I were rather than the writer I actually am, call it out.

• If my answer could describe any writer in my space, flag it. Ask what’s specific to me.

When we’re done, compile everything into a .md file with clear section headers. Include the specific examples alongside the rules — they’re what make the file useful.

If you have 1 hour, copy the prompt below and answer the 100 interview questions. What I like about this prompt is the additional sections that guide Claude how to use the file (quick reference card, how to use this document, instructions for Claude, etc)

You are a Taste Interviewer — a relentless interviewer whose job is to extract the DNA of how I think, write, and see the world. Your goal is to create a comprehensive document that captures my unique voice so precisely that another Claude instance could write and think exactly like me.

<interview_philosophy>

You’re not here to be polite. You’re here to get to the truth. Most people can’t articulate their own taste — they give vague, socially acceptable answers. Your job is to break through that.

</interview_philosophy>

<interview_structure>

Conduct 100 questions total across these categories (not necessarily in order — follow the thread when something interesting emerges):

BELIEFS & CONTRARIAN TAKES (15 questions)

- What I believe that others in my field don’t

- Hot takes I’d defend to the death

- Conventional wisdom I think is wrong

WRITING MECHANICS (20 questions)

- How I actually write (not how I think I write)

- My default sentence structures

- How I open pieces / How I close them

- My relationship with punctuation, formatting, line breaks

- Words I overuse / Words I love / Words I’d never use

AESTHETIC CRIMES (15 questions)

- What makes me cringe in other people’s writing

- Specific phrases or patterns that feel like nails on a chalkboard

- Types of content I find lazy or uninspired

VOICE & PERSONALITY (15 questions)

- How I use humor (if at all)

- My tone when I’m being serious vs. casual

- How I handle disagreement or controversy

- What I sound like when I’m excited vs. skeptical

STRUCTURAL PREFERENCES (15 questions)

- How I organize ideas

- My relationship with lists, headers, bullets

- How I handle transitions

- My default content structures

HARD NOS (10 questions)

- Things I’d never write about

- Approaches I’d never take

- Lines I won’t cross

RED FLAGS (10 questions)

- What makes me immediately distrust a piece of content

- Signals that someone doesn’t know what they’re talking about

</interview_structure>

<interview_rules>

1. ONE question at a time. Wait for my response before moving on.

2. Push back on vague answers. If I say “I like to keep things simple,” ask “Simple how? Give me an example of simple done right and simple done lazy.”

3. Ask for specific examples. “Show me a sentence you’ve written that captures this.”

4. Call out contradictions. If I said one thing earlier and something different now, point it out.

5. Go deeper on interesting threads. If something unusual emerges, follow it.

6. Don’t accept “I don’t know” easily. Try reframing the question or approaching from another angle.

</interview_rules>

<output_requirements>

After exactly 100 questions, compile everything into a comprehensive markdown document. This is NOT a summary — it’s a complete reference document preserving the full depth of every answer.

Structure it like this:

# VOICE PROFILE: [My Name]

## Core Identity

[2-3 sentences capturing the essence — this is the only summary section]

---

## SECTION 1: BELIEFS & CONTRARIAN TAKES

### Q1: [The question you asked]

[My full answer, preserved verbatim or lightly cleaned up for clarity]

### Q2: [The question you asked]

[My full answer]

[Continue for all questions in this category]

---

## SECTION 2: WRITING MECHANICS

### Q16: [The question you asked]

[My full answer]

[Continue for all questions in this category]

---

## SECTION 3: AESTHETIC CRIMES

[Same format — question, then full answer]

---

## SECTION 4: VOICE & PERSONALITY

[Same format]

---

## SECTION 5: STRUCTURAL PREFERENCES

[Same format]

---

## SECTION 6: HARD NOS

[Same format]

---

## SECTION 7: RED FLAGS

[Same format]

---

## QUICK REFERENCE CARD

### Always:

[Extracted from answers — specific patterns to follow]

### Never:

[Extracted from answers — specific things to avoid]

### Signature Phrases & Structures:

[Actual examples I provided during the interview]

### Voice Calibration:

[Key quotes from my answers that capture tone]

---

## HOW TO USE THIS DOCUMENT (ANTI-OVERFITTING GUIDE)

This document captures my taste — it is NOT a checklist to follow rigidly.

### Spirit Over Letter

The goal is to internalize my sensibility, not to mechanically apply every pattern. A piece that uses 3 of my tendencies naturally will always beat a piece that forces in 10 of them awkwardly.

### Frequency Guidance

For each tendency documented above, I’ve noted whether it’s:

- **HARD RULE** — Never violate (these are rare — usually in the “Never” section)

- **STRONG TENDENCY** — Do this 70-80% of the time, but breaking it occasionally is fine

- **LIGHT PREFERENCE** — Nice to have, but context determines when to apply

When no label exists, assume it’s a LIGHT PREFERENCE.

### Context Matters

My voice adapts to format:

- A tweet ≠ a newsletter ≠ a LinkedIn post ≠ a long-form article

- Use judgment about which patterns fit which format

- Some of my tendencies are format-specific — I noted when this applies

### Natural Variation

Real writers aren’t perfectly consistent. Introduce natural variation:

- Don’t start every piece the same way just because I have a “signature open”

- Don’t avoid a word forever just because I said I dislike it — sometimes it’s the right word

- Let the content dictate structure, not the template

### The Litmus Test

Before finalizing anything written “as me,” ask:

> “Does this sound like something I would actually write — or does it sound like an AI trying very hard to imitate me?”

If it feels forced, pull back. Less imitation, more inhabitation.

### What Matters Most

If you forget everything else, remember these 3 things:

1. [To be filled: My single most important belief about writing]

2. [To be filled: The one pattern that makes my voice mine]

3. [To be filled: The #1 thing I never do]

Everything else is secondary.

---

## INSTRUCTIONS FOR CLAUDE

When writing as [My Name], reference this document. Pay attention to:

1. The specific examples I gave — use similar structures

2. The words and phrases I said I hate — never use them

3. The beliefs I hold — let them inform the angle

4. My actual sentences — match the rhythm and length

This document is a source of truth, not a suggestion. But apply it with judgment, not rigidly.

</output_requirements>

Begin by asking me your first question.

When Claude pushes back and asks for specifics, give them. That’s where the file gets good. The vague answers (”I like conversational writing”) produce generic profiles. The specific answers (”I never use semicolons and I break long sentences into two short ones separated by a period”) produce profiles that actually work.

At the end of the interview, you’ll get an .md file with your voice.

Why and how to use this .md file in Claude

There’s a reason why I mention Claude (and not ChatGPT) multiple times so far.

You have two ways to use this .md file.

Option 1: Paste it into any conversation. Upload the .md file at the start of a Claude or ChatGPT chat and say “Read this voice profile first. Then write [whatever you need].” Works with any AI.

Option 2: Use Claude Cowork (best option). Drop the .md file into a folder on your computer. Open that folder in Cowork. Cowork reads the file automatically every time you work in that folder (if you set it up properly)

No pasting. No re-uploading. No re-explaining.

You just say “draft a newsletter intro about XYZ” and Claude already knows how you write.

Here’s how to get started with Cowork:

1. Download Claude for desktop → claude.com/download

2. Open the app and choose “Cowork”

3. Give access to the folder containing your .md file

If you’re new to Cowork and haven’t set it up yet, add this line at the end of your prompt:

[prompt]

Before you start, read [voice_profile].md first

From that point on, every session in that folder starts with Claude already knowing your voice.

Download my writing-voice file

Read more

For a long time, the way I used Claude Cowork was simple.

Ask for something. Get a result. Move on.

That works great when the task is a one-off, like a quick email, a summary, a draft you need today and forget tomorrow.

But it starts to fall short when the work doesn’t end in a single session. When you need to come back tomorrow or next week, and the AI has no idea who you are or what you were working on. When you spend 10 minutes re-explaining context you already gave.

That’s exactly where Projects changes Claude Cowork.

Projects is a dedicated space where your work lives with its own files, context, and rules ready every time you come back.

In this guide, I’ll show you:

• Why Cowork Projects matters

• How to create your first Cowork project

• How to shape a project that works

• A real use case for projects

Some of you know me from my Udemy courses or YouTube videos. I used to create long-form video content, but AI moves so fast that it stopped making sense — a lesson can go stale in weeks, and updating video is painfully slow.

So I switched. Now I publish (and regularly update) Claude guides every week. Think of them as my courses in written form → Click here to check out my Claude course: 16 lectures and counting!

Every week, paid subscribers get step-by-step Claude guides. No technical skills needed. No ads. Just the stuff that actually matters (+ these perks) 👇

Subscribe now

Why Cowork Projects matters

Before Anthropic released projects, Cowork’s biggest problem was its memory. In the past, by default, every Cowork session started from zero.

Now, with Cowork projects, your work lives in a space that already knows what you’re building, has your files, follows your rules, and remembers what you care about (every time you open it)

Think of it this way: without Projects, every time you come back, you’re briefing a new assistant from scratch. With Projects, you’re walking back into an office where everything is already set up and the assistant already knows the job.

Besides persistent memory, Cowork Projects also offers custom instructions, scheduled tasks, and context. All in one space.

How to create your first Cowork project

If you want to use Projects inside Claude Cowork, the path is pretty straightforward:

Open Claude Desktop → Cowork → Projects → Create your first project

You’ll find 3 options to create a new project.

Here’s when to use each option

• Start from scratch → Use it when you want to create a new space from zero

• Import a project → Use it when you want to import a Claude chat project

• Use an existing folder → If you copied my Cowork system, just select here the “YOUR-WORKSPACE“ folder created

One important detail: importing from an older Claude chat Project doesn't bring over the full chat history. It carries over the instructions, files, and project setup. If an older thread has context you still need, a one-time summary file can bridge that gap.

Subscribe now

How to shape a project that works

Not every task needs a project. A project earns its place when the work:

• Repeats weekly, monthly, or continuously

• Depends on context you don’t want to restate every time

• Pulls from several files or sources

• Tends to produce the same kind of output

That fits more work than you might expect — research, writing, ops, sales, client work, reporting, internal briefs. Anything recurring where context and format matter.

A solid project usually has four parts:

1. A specific purpose: Narrow enough to have one clear job. Weekly competitive tracking, market review, leadership briefing prep, opportunity monitoring.

2. Context that doesn’t repeat: The assumptions, priorities, definitions, and decision criteria Claude needs.

3. Reference materials: The files, links, examples, and sources the project draws from every time.

4. Output logic: What kind of deliverable is expected to produce: a short brief, a memo, an executive update, a prioritized list, etc.

When those four are in place, the project is easy to reopen trust and reuse.

A real use case for Projects

If you’ve already been working with Claude (or read this guide), you probably have folders with useful material inside them. Instead of starting from zero, turn one of those folders into a project.

For this example, let’s say you already have a folder like this:

projects/
└── market-review/
    ├── notes.md
    ├── template/
    ├── references/
    └── drafts/

In this case, I’ll use “use an existing folder” to create the project.

Download the market-review folder here

If the folder already has strong context, you may not need much in the Instructions field. Use that field when you want Claude to follow specific rules — how to format outputs, what to prioritize, what to skip.

Once the folder is connected, you can start working directly on top of it. A simple first prompt could be:

Read the files in this Project and turn the current notes into a decision brief for internal review.

The files don’t move. What’s new is that they now sit inside a workspace that carries context across sessions — instead of reading them cold every time.

That context stays inside the Project. Claude can build on past chats, project knowledge, and outputs from that same workspace without mixing it with unrelated work.

Pro tip: Run the same workflow automatically with scheduled tasks.

Scheduled → Create scheduled task → paste your prompt → choose the frequency → Save

For this example, the prompt would be:

Review the files in this Project, identify relevant competitor, pricing, onboarding, or positioning changes, and produce a concise decision brief for internal review with three sections: what changed, why it matters, and what deserves follow-up.

And that’s it. It’s now scheduled.

You can also schedule a task from an existing project chat.

→ For more Cowork project use cases, download these folders and read this guide to copy my prompts to get started with each project

Where tasks, folders, and skills fit

Before moving on, it’s worth clarifying these concepts

A simple way to see it would be this:

Here’s how each one works:

• A folder stores your files, references, and drafts

• A skill captures a specific way of working or solving a task

• A task executes a one-off action

• A Project is what lets all of that live inside the same context

Final notes

• Cowork Projects is most useful when the work is recurring, context-heavy, and tied to a stable set of files or outputs.

• Cowork projects live on your computer (no cloud sync), so you can’t access a project from multiple computers. If you need a project space built around shared chats, knowledge, and instructions, the older Claude chat projects fit that need better

• Subscribe to this newsletter so you never miss guides like this, delivered straight to your inbox 👇

Subscribe now

This one is mind-blowing!

It’s called “Computer Use.” It lets Claude control your entire computer. This means controlling your keyboard and mouse in any app that you allow.

It’s only available for the macOS Claude app, BUT after testing it since its release, I think Windows users can still benefit from a simplified version of it (keep reading and you’ll understand what I mean).

Claude is releasing updates like crazy lately! I spend a lot of time testing and digging into each one so you don't have to. If it's useful, it's in my guides. If it's not, I save you the time

Click here to read the best Claude guides

If you like this Claude series, support me by becoming a paid subscriber :) 👇

Subscribe now

Computer Use is powerful, but Claude tries to avoid it. Here’s why

After doing dozens of tests, I’ve noticed that Cowork doesn’t always use computer use’s full potential, and there’s a reason for that.

Even if you prompt Cowork “use computer use for this task,“ Claude follows this order to execute tasks:

1. Connectors: If a connector is available (Gmail, Google Drive, etc), Claude uses it. This is the fastest and most reliable path.

2. Claude in Chrome: When there isn’t a connector for the tool you need, Claude will navigate the Chrome browser to work on your task

3. Screen interaction: If options 1 and 2 won’t help, Claude uses computer use to interact directly with your screen: clicking, typing, and navigating your desktop apps.

Claude prioritizes the fastest method (1 and 2) to avoid longer sessions and mistakes.

In my use-cases, you’ll notice that Claude avoids as much as possible using screen interaction (aka computer use). Instead, it uses connectors or Claude in Chrome. Is that bad? Not at all, you’re wasting fewer tokens and getting the job done anyway.

That’s why I think Windows users without the computer use feature can still benefit from the use cases we’ll see later (Claude mostly uses Claude in Chrome).

First, let’s see how to enable Claude’s computer use.

How to enable Computer Use

First, download the Claude desktop app: claude.com/download

Open the app → Select Cowork → Open the sidebar:

1. Click on your name

2. Settings

3. General (inside “desktop app” section)

4. Toggle on “computer use“

How to know you’re actually using computer use

The best way to trigger computer use is to make Cowork work with local files or apps. Here are some ideas:

• Create an analysis using local files and then create a formatted report in Excel

• Navigate apps that don’t have connectors (tools your team uses, macOS apps, etc)

• Fill in a spreadsheet with data from multiple sources, format it, and save it

Here’s a test you can do to see what your computer looks like when it’s controlled using Claude’s computer use.

Go to Cowork and paste in this prompt:

Use computer use for this task:

Open the calculator app to calculate 30x200 and then create an apple note to store the result

This might seem silly, but, believe me, sometimes it seems that this new feature is being used, but it’s not! If you see the orange outline on the whole screen, Claude is controlling your entire computer with computer use. If you see the outlines only in the Chrome window, Claude in Chrome is being used.

These are only technicalities. At the end of the day, we care to get things done without wasting too many tokens. That’s what we’ll do in the following use cases.

Subscribe now

My Best Use Cases

Computer use helped me automate my busywork. Here are my best use cases that you can adapt to your workflow.

#1 Automate LinkedIn responses (“Comment X, Get Y”)

If you use LinkedIn or Instagram, you probably came across the “Comment X and I’ll send you Y.“ X is a keyword that triggers an automation. Instagram has third parties that make this easy. However, as far as I know, LinkedIn doesn’t have any.

With the prompt below, I could automate this:

Use “Computer Use” to control my computer and do this task:

Open the Excel file “LinkedIn DMs.” Find today’s row, copy the message, and open the LinkedIn post. Then open the comments section and send a DM to everyone who commented, using the keyword. After you successfully sent the DM reply “Sent!” to their comment

Why do content creators use this formula? Platforms like LinkedIn penalize posts with links, so this is the best way to share links without hurting views.

By the way, if you want to connect with me on LinkedIn, click here: https://www.linkedin.com/in/thepycoach/

I accept everyone :)

#2 Accept connections

Every day, I get new connection requests on LinkedIn. I manually accept each of them because there’s no native LinkedIn way to automatically accept requests.

Thanks to the prompt below, I can get my connection request inbox down to zero:

use “computer use” to accept all my connection requests on linkedin

Before this test, I was manually accepting a lot of requests. Luckily, a new one came in right when I needed it (lucky me!)

One less task in my daily routine!

#3 Create a customized short link after publishing a new guide

Every time I publish a new guide, I manually create a Bitly shortlink to share it on other platforms. I use the original link slug to create a customized shortlink.

This prompt automated this process:

Use “computer use” for this:

I have a Substack newsletter at artificialcorner.com where I publish AI guides every Wednesday and Sunday. At the end of each Wednesday/Sunday I want you to go to my bitly.com account and create a customized bitly link using the same URL slug used in the original guide (if it’s taken come up with something similar)

Note: This week I published on a Tuesday (it was an exception)

#4 Create an Excel table with web data

To quickly keep track of all the links I create with Bitly, I need an Excel table with these columns: Guide name, Original Link, Bitly Link.

The prompt below extracts the data I need from Bitly and puts it into Excel.

Use “Computer Use” for this:

Build a table in Excel with these columns: Guide name, Original Link, Bitly Link. All the info is in bitly. Only consider the links from my site artificialcorner.com

#5 Update an Excel table

If I need to update a table with fresh data, I ask Claude to visit a website, extract the information I need, and update the table for me.

Here’s the prompt I use:

Use “computer use” for this:

Go to bitly.com and add the latest link created to my dataset Bitly_Links_ArtificialCorner.xlsx located in Download -> Bitly. Open the Excel file and add the data in a new row. The data needed is Guide Name, Original Link and Bitly Link

Final tips to get the most out of computer use

• You can turn a chat into a scheduled task, so it runs on any day/hour you want. Learn how here: artificialcorner.com/p/claude-automates

• You can use Dispatch to trigger computer use from your phone. Check out my guide: artificialcorner.com/p/cowork-dispatch

• To prevent Claude from using some apps, do this: Settings → General → Denied apps → Add app

• Close anything you don’t want Claude to see. When Claude uses your computer, it takes screenshots to navigate your screen

• Subscribe to this newsletter so you never miss guides like this, delivered straight to your inbox 👇

Subscribe now

Click here to read my best Claude guides

Click here to get my FREE Claude course (20+ lessons)

I used to get mediocre results from Claude Cowork.

The tool wasn’t broken. My workspace was.

Most people open Cowork and do this: open a folder → write a prompt → hope for the best

Sometimes it works. A lot of times, it doesn’t.

And that’s not Cowork’s fault. Cowork is stepping into your workspace with zero context, no rules, and no clear way of working.

So it starts improvising.

It doesn’t know what tone to use.
It doesn’t know what it should never assume.
It doesn’t know what files it must always read.

That’s why so many people try it and walk away thinking it feels like just another chat … just with file access.

In this guide, we’ll fix that. I’ll show you a simple system that gets the most out of Cowork.

By the end of this guide, you’ll have:

• A system that gives Cowork the context it needs to stop improvising

• How to use this system with 3 real-world examples

• How to prompt this system (spoiler: you’ll need short prompts — the system does the heavy lifting)

No coding. No complex setup. Just a structure that works.

Subscribe now

Cowork doesn’t need more prompts. It needs a system

If you come from the chat world, this makes sense: write a better prompt, get a better result.

In Claude Cowork, that is no longer the main piece. The workspace is.

Because Cowork does not just work with what you type into a text box. It works with what it can read inside the folder you give it access to:

- your project files
- your working rules
- your context
- your preferred way of communicating
- your prior drafts
- your examples of success

You need to turn the way you work into a small, reusable system.

Here’s an overview of the system we’ll build:

That jump looks small. It isn’t.

Because the moment your way of working lives in files, Cowork stops starting from zero every time. When that happens, the results stop feeling generic and start feeling like “this thing already knows how I work.”

Quick Cowork Recap: Installation

To use Cowork, you need to download Claude for desktop:

Go to claude.com/downloads → download Claude Desktop → install it → sign in

Once it's installed, select Cowork. That's it. You're in.

Quick setup: Add Global Instructions

Global instructions is where you set the default behavior Cowork should bring into every session. Do this:

Open profile menu → Settings → Cowork → Add your Global Instructions → Save

Copy these global instructions:

You are my working partner inside this workspace.

Start by reading:
1. context/HOW-I-WORK.md
2. system/SYSTEM-RULES.md
3. the relevant folder inside projects/

Do not execute immediately if the goal, audience, or output format is unclear.
Ask questions first when missing context could weaken the result.

Do not invent facts, decisions, dates, numbers, or approvals.
Make uncertainty visible.

Use the workspace files as the main source of truth.
Save final outputs in outputs/.

This gives Cowork a reliable starting behavior before the real context comes from the workspace.

The simple system I’d actually start with

I wanted to strip this down as much as possible.

I wouldn’t start with ten folders.
I wouldn’t start with an entire empty office.
I’d start with four. That’s it.

YOUR-WORKSPACE/
├── system/
├── context/
├── projects/
└── outputs/

On your computer, it looks like this:

That’s already enough to get started.

• system/ → stores the base rules (stays fairly stable)

• context/ → stores the stable context (stays fairly stable)

• projects/ → stores the active work (it changes by project)

• outputs/ → stores what Cowork produces

A small structure that can grow without turning into a mess.

But a folder by itself doesn’t tell Cowork much. What makes the workspace useful are the files that explain Cowork how to work.

The files that bring the structure to life

Folders give Cowork a place to work. Files tell it how to work.

That’s why I’d start with just two:

1. context/HOW-I-WORK.md

2. system/SYSTEM-RULES.md

HOW-I-WORK.md captures who you are inside this workspace: how you work, how you think, how you communicate, and what kind of work you consider good.

SYSTEM-RULES.md defines how Cowork should behave: when it should ask before acting, what it shouldn’t assume, how to handle ambiguity, and what a strong result looks like.

What should live inside HOW-I-WORK.md? A simple version of this file could include:

• what kind of work you do

• who you do it for

• how you think

• how you communicate

• what feels natural in your writing

• what you dislike

• which sources carry more weight when there’s a conflict

• real examples when useful

What should live inside SYSTEM-RULES.md? A simple version of this file could include:

• core operating principles

• when Cowork should ask before acting

• how it should behave during execution

• how to handle ambiguity

• what counts as a strong output

• clear boundaries

• a final review before delivery

The structure would look like this:

Up to this point, everything sounds simple.

Here’s the most important part: I wouldn’t write those files from scratch. Because the moment you do, you start guessing.

You describe the version of yourself you wish were true — not the version that actually shows up in day-to-day work.

That’s why I prefer a different approach: build both files through an interview.

A good interview helps extract things most people wouldn’t write well on their own:

• how they actually work

• how they actually write

• what they value in a strong deliverable

• what makes them distrust a weak one

• what Cowork should never assume

• what kind of help is genuinely useful to them

Then that interview generates the two files that support the entire system.

Copy the prompt below to generate HOW-I-WORK.md and SYSTEM-RULES.md

You’ll be asked about 50 questions, one at a time. Answer each one honestly and in detail for the best results.

You are my workspace interviewer.

Your job is to extract enough high-quality signal to help build 2 things for Claude Cowork:

1. context/HOW-I-WORK.md
2. system/SYSTEM-RULES.md

Your goal is not to interview me forever.
Your goal is to gather enough specific, real, usable information to generate those files well.

## Interview objective

You are helping define how Claude Cowork should work with me inside a reusable workspace.

That means you need to understand:

- what kind of work I do
- what I usually create
- who I create it for
- how I think
- how I write
- what I value in strong outputs
- what I dislike in weak outputs
- how I want Claude Cowork to behave
- what Claude should never assume
- when Claude should ask questions before executing

## Interview structure

You will conduct the interview in 3 blocks:

### Block A - Work context

Use this block to understand:

- what I do
- what kinds of deliverables I create
- who my audience is
- what those people value
- what sources matter most
- what this workspace should help me do

### Block B - Voice, style, and thinking

Use this block to understand:

- how I sound at my best
- how I sound when I am writing lazily or on autopilot
- the words, phrases, and structures that feel natural to me
- what I hate in writing
- how I organize ideas
- how I think through problems
- what I tend to notice, distrust, or emphasize
- examples of real writing that sound like me

### Block C - System behavior and rules

Use this block to understand:

- how I want Claude Cowork to behave
- when Claude should ask before acting
- what makes an output strong or weak for me
- what should never be assumed, invented, or finalized too quickly
- how uncertainty should be handled
- how conflicting information should be handled
- what kind of help is actually useful to me

## Interview rules

1. Ask one question at a time.  
Wait for my response before moving on.

2. Do not ask a fixed number of questions.  
Ask only as many as needed to build the files well, up to a maximum of 50 questions.

3. Push back on vague answers.  
If I say something generic, ask for a specific example.

4. Ask for real evidence.  
Whenever useful, ask for:
- a real paragraph I wrote
- a real sentence I like
- a real sentence I would never publish
- a real example of a good or bad output
- a real example of a decision, document, or deliverable

5. Call out contradictions.  
If I say something that conflicts with an earlier answer, point it out and ask me to resolve it.

6. Distinguish reality from aspiration.  
If I describe the person I wish I were instead of how I actually work, write, or decide, call it out and ask for proof.

7. Go deeper only when useful.  
If an answer contains strong signal, follow it.  
If not, move on.

8. Do not flatter me.  
Do not say “great point,” “interesting,” or similar filler.  
Just ask the next question or push deeper.

9. Optimize for usable specificity.  
Do not collect abstract opinions if they will not help build the files.

10. Stop when you have enough signal.
Do not drag the interview longer than needed. Stop earlier if you already have enough strong signal to generate both files well.

## What you are building toward

At the end of the interview, you will generate 2 outputs:

### Output 1

context/HOW-I-WORK.md

This file should include:

- what kind of work I do
- what I create
- who I create for
- what my audience values
- how I think
- how I communicate
- what feels like me
- what I dislike
- what sources carry more weight
- real examples when useful

### Output 2

system/SYSTEM-RULES.md

This file should include:

- core operating principles
- when Claude should ask before executing
- how Claude should behave during execution
- how to handle ambiguity
- how to handle conflicting information
- what a strong output looks like
- what weak outputs get wrong
- collaboration preferences
- hard boundaries
- a final pre-delivery check

## Output requirements after the interview ends

When you judge that the interview is complete, generate both outputs in this exact format:

[context/HOW-I-WORK.md]
...

[system/SYSTEM-RULES.md]
...

After that, add this section only if needed:

[Missing or weak signal]
...

Do not generate the files before the interview is complete.

## How to begin

Start with Block A.
Ask me the first question.

Why does this approach actually work?

You’re extracting real info to build two files that will be reused again and again.

That’s the shift that matters.

No more files just for the sake of having more files. No more long prompts to compensate for missing context. Just a minimal structure, two well-built files, and a smarter way to give Cowork the context it needs.

Subscribe now

How to apply this method: 3 real-world examples

The advantage of this structure is that it doesn’t depend on a single task.

It works for an article, report, presentation, research project, weekly brief, proposal, document synthesis, etc

The logic is always the same:

project folder + 2 core files + short prompt

That’s the pattern.

You don’t need to reinvent how you work for every task. You only need to change the content inside projects/ and give Cowork a short prompt to trigger it.

In other words:

• system/SYSTEM-RULES.md stays fairly stable

• context/HOW-I-WORK.md stays fairly stable

• what changes each time lives inside projects/

The projects folder is where the specific work lives — the brief, notes, references, drafts, and any file tied to that particular task.

Click here to download all the folders and files used in the examples below

Example 1: Turn scattered notes into a decision brief

Inside projects/, you create this (it may vary by project):

projects/
└── market-review/
 ├── notes.md
 └── template/
 ├── references/
 └── drafts/

The system doesn’t change. The only new thing is the content inside market-review/

Notes.md could look like this:

# Market Review Notes

## Context
We are reviewing competitor moves from the last 30 days.

## Raw observations
- Competitor A launched a lower-priced offer
- Competitor B simplified onboarding
- Competitor C is publishing more case studies

## Risks noticed
- We may overreact to pricing changes
- We do not know yet if these moves are converting better

## What I need
Turn this into a decision brief for internal review.

references/ → previous presentations, competitor reports, benchmarks, internal documents, anything that helps interpret the notes

drafts/ → first version of the brief, a condensed version, a more executive version if you need one

The prompt could be as simple as:

Read the project folder first.
Then ask me questions before you execute.
I want a decision brief, not a generic summary.
Save the result in outputs/briefs/.

The method didn't change. Only the content did.

Here are the results:

The brief grounds the decision, separates risks and options clearly, and ends with an actionable recommendation and concrete next steps.

Example 2: Build an executive report for a meeting

Now consider this case:

projects/
└── q3-review/
 ├── brief.md
 ├── notes.md
 └── template/
        ├── references/
        └── drafts/

You're not working with scattered notes anymore. Now you have material for an executive report.

brief.md could look like this:

# Q3 Review Brief

## Goal
Prepare an executive report for the leadership meeting.

## Audience
Senior leadership team.

## What matters most
- What changed this quarter
- What risks need attention
- What decisions may be needed next

## Constraints
- Keep it concise
- No speculation without labeling it
- Focus on implications, not just activity

And notes.md could look like this:

# Q3 Review Notes

## Highlights
- Revenue held steady
- Customer retention improved slightly
- Two initiatives are behind schedule

## Open questions
- Whether resources need to be rebalanced
- Whether delays are operational or strategic

references/ → metrics, previous quarterly reports, financial documents, team summaries, older slides

drafts/ → first executive report, a shorter version, a risk-focused version, a structure ready to turn into a presentation

The prompt:

Go through the project folder first.
Use my quality standard and workspace context.
Ask me questions before you write.
Then create an executive report for review and save it in outputs/reports/

Here are the results:

Cowork turned scattered context into a clear executive report with metrics, risks, and decisions ready for discussion.

Example 3: Draft a presentation without starting from zero

The folder could look like this:

projects/
└── strategy-update/
    ├── brief.md
    └── template/
        ├── references/
        └── drafts/

And brief.md could look like this:

# Strategy Update Brief

## Goal
Create a presentation outline for a strategy update meeting.

## Audience
Internal leadership and cross-functional leads.

## What the deck should do
- explain what changed
- show why it matters
- align people on next steps

## What I don't want
- slide titles with no message
- too much text
- generic consulting language

references/ → metrics, previous quarterly reports, financial documents, team summaries, older slides

drafts/ → first structure, a condensed version, a more risk-focused variant, an outline ready to turn into slides

The prompt:

Read the project folder first.
Then ask me questions before you execute.
I want a presentation outline with a strong flow, clear sections, and what each slide should do.
Save it in outputs/drafts/

Here are the results:

Cowork didn't just organize ideas. It turned a fuzzy strategic change into a presentation with a clear narrative.

How to prompt Cowork using this system

At this point, you already have everything you need to make Cowork work.

But there’s an important difference between a tidy workspace and one that actually saves you time: how you use it once it’s already up and running.

Here are my two favorite ways:

#1 Question-first flow

A question-first flow is just a way of using Cowork.

The logic:

• Cowork reads the folder

• then it asks you questions if context is missing

• only after that does it build the deliverable

This is activated by how you give the instruction.

For example:

Read the project folder first.
Then ask me questions before you execute.

You already saw this in the examples:

• In the first one, Cowork asked what the real decision was

• In the second one, it asked about the initiatives and the decision that should come out of the meeting

• In the third one, it asked about the workstreams, the next steps, and the format

That was question-first flow in action.

It makes sense to use it when:

• the goal isn’t fully clear yet

• the audience matters

• the result has real impact

• one bad assumption could ruin the deliverable

• there are several possible outputs and you want Cowork to pick the right one

In other words, use it when you don’t want Cowork filling in the gaps on its own.

#2 Short prompts

A short prompt is simply a prompt that works well because the workspace already has context.

That point matters.

In an empty chat, a short prompt usually falls short. But in Cowork, if you already have:

system/
context/
projects/
outputs/

...the prompt no longer has to carry all the weight.

The context lives in the files. The prompt just activates the system.

For example:

Read the project folder first.
Then ask me questions before you execute.
Create the deliverable and save it in outputs/.

or

Use my HOW-I-WORK and SYSTEM-RULES files.
Then use the project folder to create a first draft in outputs/.

Short. It’s not magic. Your workspace is already doing the real work.

If you need to write a very long prompt just for Cowork to understand the basics, the problem usually isn’t the prompt. The problem is that your workspace isn’t carrying enough context yet.

How to grow the system without turning it into a mess

Once people understand this concept, they usually make one of two mistakes:

• They stick with a structure that’s too thin

• or they try to build a huge system from day one

You don’t want either one.

Here’s the core idea: start small and let the work tell you what’s missing.

Grow only when a pattern repeats.

Don’t create files because they might be useful someday. Create them when you notice something is already repeating and deserves its own file.

When it makes sense to expand system/

• Cowork keeps making the same mistake over and over

• you have rules that apply almost all the time

• your quality standard is clearer now

• you want to lock in a way of working that shouldn’t change from project to project

For example: if you notice Cowork keeps confusing a summary with a recommendation, that already deserves a more explicit rule inside SYSTEM-RULES.md or even a small new section.

When it makes sense to expand context/

• your audience already deserves its own file

• your writing style needs more precision

• you want to separate references, tone, or source-of-truth rules

• your way of working no longer fits inside a single file

The goal is context that’s clear and actually usable.

When it makes sense to expand projects/

• a certain kind of work always uses the same files

• a project needs more internal order

• you want to better separate the brief, notes, references, and drafts

• a recurring task already has its own logic

This is where most of the change happens anyway.

How to tell if the system is growing well

You’ll notice it because each new task needs:

• less explanation

• fewer corrections

• fewer restarts

• and delivers something more useful on the first pass

If that’s happening, the system is growing well. If not, you’re just accumulating structure.

Subscribe to get my FREE Claude course.

20+ lessons delivered straight to your inbox 👇

Subscribe now

But there was always one problem: You had to be sitting at your desk to use it.

If you wanted to start a task or monitor Cowork’s output while you were at the gym or grabbing coffee, you couldn’t do anything about it. There wasn’t mobile access.

That just changed.

Cowork just got a new feature called Dispatch. This feature lets you text Claude a task from your phone, and it completes the work on your computer while you’re away. When you come back home, the work is done.

In this guide, you’ll learn:

• How to set up Dispatch on your phone and desktop

• How to use Dispatch

• How to unlock Dispatch full potential with skills, tasks, and more

• A few things to keep in mind before you use this feature

I’ve been getting a lot of sponsorship offers for this newsletter lately.

I appreciate every single one, but out of respect for my paid subscribers, I’m keeping this space ad-free.

Click here to read my best Claude guides

If you like my Claude guides and want me to keep making more, consider becoming a paid subscriber👇

Subscribe now

How to set up Dispatch

Here’s what you need:

• The latest version of the Claude desktop app (Mac or Windows)

• The latest version of the Claude mobile app (iPhone or Android)

• A Claude paid plan

Here’s how to set it up:

On your phone:

1. Open the Claude app → open the sidebar → Dispatch → Pair with your desktop

On your computer:

1. Open the Claude desktop app → open the sidebar → Dispatch. You’ll see a screen that says “Coworking on the go.” Click “Get started.”

2. Click “I’m signed in on my phone.”

3. Toggle on two things: give Claude access to your files, and keep your computer awake while Dispatch is running (if your computer goes to sleep, Claude stops working)

The setup is finished!

You should see the screen below when you go to Dispatch in the desktop app (in the mobile app, you’ll see a simplified version)

You now have one continuous conversation with Claude Cowork that works from both your phone and your desktop. Text it a task from your phone, and Claude works on your computer using your local files, skills, connectors, and more.

Let’s see how to use Dispatch with a basic example.

Subscribe now

How to use Dispatch

Dispatch is designed for moments when your phone is the only device you have. Here’s how to fire it up on your phone.

Go to the Claude phone app → open the sidebar → Dispatch

You’ll see this default message on your phone.

Use a prompt to point it to a folder on your computer and tell it what to do.

You can type something like this:

“In my [folder name], can you give me a quick summary of what’s in the final report spreadsheet?”

In your prompt, be specific about the folder and the file name.

In a few minutes, the report summary will be generated on your phone. No laptop needed. Just a text message to Claude and a clean summary back on the phone.

But that’s only the most basic thing you can do with Dispatch!

Now that you've seen it in action on your phone, let me show you the computer setup that unlocks its full potential.

Unlock Dispatch's full potential with skills, tasks, and more

If you’ve used Cowork before, you probably know about skills and scheduled tasks.

Skills are reusable instructions you save inside a folder so Claude knows exactly how to handle specific tasks. Scheduled tasks are prompts that run automatically at a certain hour and day.

Both make Dispatch really powerful, because you can trigger them from your phone with a short message.

Step 1: Add skills to your list

To see the list of skills you can trigger from your phone, do this on the desktop app:

Open the sidebar → Go to Customize → Skills → List of skills available

To download skills and learn how to create your own, read this: artificialcorner.com/p/claude

Step 2: Add tasks to Scheduled

To see the list of tasks you can trigger from your phone, do this on the desktop app:

Open the sidebar → Go to Scheduled → List of tasks available

To learn how to create scheduled tasks, read this: artificialcorner.com/claude-automates

Step 3: Trigger skills or tasks from your phone

Now that you know the list of skills and tasks available, you can trigger them with a short message from your phone.

Here are the steps to follow:

1. Open the Claude phone app → open the sidebar → Dispatch

2. Type “Run the [name of skill/task]“

3. Allow permission

4. You get your output

If your task/skill generates a file, you might need to explicitly tell Claude to show you the file in the phone Dispatch chat.

Subscribe now

Here’s an example

Say I’m in the barber shop or sitting in the taxi. I can grab my phone, open Claude, and type: Run the task “export top paid newsletters to CSV.” That’s a task that scrapes Substack newsletter rankings from a site.

Pro tip: Use simple names for your skills/tasks so they're easy to trigger on your phone.

Done! The CSV file was generated. I can open it on both my phone and computer.

When I come back home and open Claude Cowork on my computer, the same chat is right there in the Dispatch tab.

But there’s one thing in the desktop app that you won’t find in the mobile app — in recent chats, you’ll see one chat tagged “Dispatch.“ That’s a chat that is created every time we run a task using Dispatch (but it’s only visible in the desktop app)

Inside the chat tagged Dispatch, there’s the hidden prompt and process used to carry out my task.

The complete chat is like the longer version of the Dispatch tab. There, I can also find the CSV file generated.

Final Notes

Here are a few things worth keeping in mind:

• Your computer has to stay on: This is the most important thing. If your desktop goes to sleep or you close the Claude app, Dispatch stops working. Toggle on the “prevent sleep” option during setup.

• It’s one continuous thread: There’s no way to start a new conversation or manage multiple threads in Dispatch. Everything lives in a single chat, which means Claude remembers context from previous tasks.

• You can run multiple tasks at once: Send three or five different tasks from your phone and Claude will work on them in parallel (as long as the tasks don’t depend on each other).

• Sequential tasks aren’t supported yet: If task B depends on the output of task A (like “research X, then email the team about it”), you’ll need to send them one at a time and wait for the first one to finish.

• No notifications yet. Claude won’t ping you when a task is done. You’ll need to check back in the chat to see results. Hopefully, this gets added soon.

• Connectors extend to mobile automatically. Whatever apps you’ve connected in Cowork (Gmail, Slack, Google Drive, etc.) are available through Dispatch

Dispatch is still in preview mode, so expect some rough edges. But even in its current state, it’s already changing how I use Cowork.

Subscribe now

Click here to read my best Claude guides