If you’ve been ping-ponging between ChatGPT and Claude, depending on which one gives you a better answer that week, same. That’s been my whole AI workflow for a while now. Claude for drafting, ChatGPT when I hit a limit, back to Claude when the response quality felt better, repeat.

What I didn’t realize until recently is that a big chunk of my Claude frustration wasn’t Claude being worse, but me using it the same way I use ChatGPT.

Same prompts. Same habits and expectations. Only, those two tools just don’t work the same way 🤦‍♀️

On top of that, Anthropic quietly made a significant expansion to Claude’s free tier in early 2026—features that used to live behind the $20/month Pro plan are now free.

Projects. Artifacts. Memory. Skills. App connectors. And most people either don’t know that yet, don’t know what most of these are, or don’t know how to actually use them.

So this post covers both:

• What’s free now
• How to use Claude in a way that actually works

So you’re not burning through your message limit (or a hole in your wallet) before you’ve gotten anything useful out of it.

Related: All You Need To Know About AI Workflow Files And How To Use Them

First, the ChatGPT Problem

Most of us came to Claude from ChatGPT, which means we dragged our ChatGPT habits along with us.

Some of those habits work against you with Claude.

Here’s what I mean:

1. ChatGPT trains you to think in single conversations.

You open a chat, ask your question, get an answer, and close the tab.

Next time you need something, you open a new chat and start from scratch.

That’s fine for one-off questions, but it means you’re constantly re-explaining context.

2. Claude is built more like a workspace.

Claude wants a persistent context, things it can reference across multiple sessions without you re-uploading or re-explaining.

That’s why the free tier now includes Projects, which we’ll get into shortly.

3. ChatGPT tends to just run with your prompt.

And it does so even with a vague prompt. Claude tends to ask clarifying questions first. I used to find this annoying.

Then I realized it’s actually why my results from Claude are more accurate, since it’s not guessing what I want, it’s checking.

Tip: You can also just tell it to stop asking questions and make assumptions, which works fine. To each their own.

4. Response style is different.

ChatGPT is fast, punchy, and list-heavy. Claude leans more narrative and thorough, sometimes more than you asked for.

If you want shorter answers, say so.

Neither approach is wrong. They’re just different tools, and once you adjust how you work with Claude, the experience changes noticeably.

What You Actually Get for Free (2026 Update)

As of February and March 2026, here’s what Claude’s free plan includes:

• Claude Sonnet 4.5: The same model powering most Pro interactions. You’re not getting a watered-down version, just with tighter limits.
• Projects: Persistent workspaces with uploaded documents and custom instructions that Claude references across every chat in that project.
• Artifacts: A side panel that renders code, documents, dashboards, charts, and interactive web pages live as Claude generates them.
• Memory: Claude remembers context from previous conversations across sessions.
• Web search: Claude can pull current information directly in the chat.
• App connectors: Connect tools like Notion, Google Drive, and others (more on the limits below).
• File creation: Generate and download Word docs, PowerPoints, Excel files, and PDFs directly from conversations.
• File uploads: Up to 20 files per chat, 30MB per file.

What’s not on the free tier: Claude Opus (the more powerful model), Claude Code (the terminal-based coding agent), and Cowork (the desktop automation tool). Those require a paid plan.

A Quick Honest Note on Sonnet vs Opus

Free users get Claude Sonnet 4.6 (along with a couple of others, at the time of writing), which handles the vast majority of everyday tasks (writing, analysis, planning, general coding) really well. For most people, it’s more than enough.

You’ll notice the ceiling with very complex architectural decisions, deep security analysis, or tasks where you need the model to catch edge cases during design rather than after the fact. That’s where Opus pulls ahead.

If you hit a task where Claude keeps giving surface-level answers no matter how well you prompt it, that’s probably the signal you’ve hit the Sonnet ceiling, not a prompting problem.

For now, Sonnet is a solid free-tier model. Just good to know it exists.

Now, let’s get into how to use what we actually have.

Projects: The Feature That Changes Everything

If you’re still doing all your Claude work in one-off chats, Projects are the upgrade you didn’t know you needed.

Trust me on this, they make a huge difference 😌

A Project is a workspace where you can:

• Upload documents that Claude references across every chat in that project
• Set custom instructions so Claude always knows your context, tone, or preferences
• Keep related conversations grouped together

The free tier gives you up to 5 Projects, each supporting files up to 30MB. That’s enough for PDFs, style guides, research docs, markdown notes, and most real use cases.

Why does this matter practically?

Well, say you’re planning out a side project—let’s use a Flutter app as an example because I’m actively doing this.

Without Projects, every new chat starts from zero: “Hey, I’m building a decentralized identity app, here’s the tech stack, here’s what I’ve decided so far…” That context-setting eats into your message limit before you’ve even gotten to the actual question.

With Projects, you upload your requirements doc once. Claude has it across every chat in that project. You start a new chat and go straight to the thing you actually need.

Setting up a Project

1. Click the folder icon in the left sidebar on claude.ai (or the desktop app, it syncs)
2. Name your project and add a description
3. Upload your key documents under the Files section
4. Set custom instructions—this is where you tell Claude who you are, what you’re building, and how you want it to respond

A solid instruction block looks something like this:

I'm a [developer / writer / founder] working on [brief description].
My audience is [beginner devs / clients / my team].

- Always reference the uploaded docs before answering
- Keep responses focused and practical, not theoretical
- If my request conflicts with what's in the docs, flag it and ask how to proceed
- Don't pad responses — get to the point (Klea: low-key my fave instruction and one of my most-used 😉)

That second-to-last instruction—flagging conflicts—is where Projects really earn their keep.

When I was planning out a larger project and asked Claude to suggest an architecture approach that actually contradicted a decision in my uploaded requirements doc, it caught it and told me: “Based on what you uploaded, this would conflict with your offline-first requirement. Do you want to revise the requirement or adjust the approach?”

That’s not something a one-off chat can do.

Note 👀
Your usage limit is account-wide, not per-project. Opening a new project won’t reset your quota (sorry). It just keeps your context organized so you don’t waste messages re-explaining things.

Artifacts: When Claude Shows Instead of Tells

Artifacts are Claude’s way of rendering output visually instead of just dropping text in the chat.

When Claude generates code, builds a document, creates a chart, or designs a small interactive web page, it can open a side panel that shows you the result live.

You can toggle between versions, download the output, and ask Claude to revise specific parts without regenerating everything.

What you can build with Artifacts:

• Interactive dashboards from data you paste in
• Simple web apps and calculators
• Formatted reports and documents
• SVG charts and data visualizations
• Competitor comparison tables from screenshots

A good use case: screenshot a competitor’s pricing page, paste it into Claude, and ask it to turn it into an interactive ranking chart. The Artifact panel renders it live, and you can download it as HTML.

One thing worth knowing on the free tier is that Artifacts consume more tokens than regular text responses because Claude is generating actual code behind the scenes.

A short text reply might cost you 200 tokens.

An Artifact with a chart or interactive element could run 1,500+, depending on complexity.

Worth it for the right task, just don’t burn your session limit generating visualizations for things that don’t actually need them.

Tip 👇
When you’re deep into a session and running low on messages, ask Claude for a text summary instead of an Artifact. Save the visual output for the start of your next window!

Memory: Claude That Actually Remembers You

Claude now generates a memory summary from your conversations that carries across sessions.

It learns your name, your preferences, what you’re working on, and how you like responses formatted without you repeating it every time.

You can view, edit, and delete memories at any time in Settings → Capabilities.

One thing to understand about how it works is that memory is account-wide, not project-specific.

So if you tell Claude your name and preferred tone in one project, it carries that into others.

Your project-specific files and instructions stay isolated within their project, but the general “who you are” stuff lives at the account level.

If you haven’t checked what Claude has stored about you yet, go do it now. It’s worth cleaning up and adding anything useful it might have missed.

/compact — Memory’s Best Friend

I learn some seriously cool stuff (most of the time) when writing these posts. For example, I came across something that changed how I think about managing long Claude sessions: the /compact command.

Here’s what it does:

• Type /compact in any active chat.
• Claude summarizes the entire conversation history, stores the high-level takeaways into memory, and clears the full thread.
• You get a fresh context window without losing the plot of what you were working on.

For free users, long chat threads are quietly one of the biggest quota killers. Claude re-processes the entire conversation history with every new message, so a thread that’s grown to 30+ messages is consuming exponentially more tokens per reply than a fresh chat would.

Introducing /compact, which compresses thousands of tokens of history into a few hundred, means less overhead, more headroom, and a Claude that stays sharp instead of getting muddled in its own context.

Three things it actually helps with:

• Token efficiency: compresses thread history so each new message costs less
• Continuity: you don’t lose the overall project context, just the raw transcript
• Response quality: long, complex threads can degrade Claude’s focus; clearing them keeps answers tighter

One caveat: if you’re mid-draft on a specific document or piece of code, /compact provides a summary of what happened, but it does not preserve the latest version of that artifact.

So if you’re iterating on something concrete, paste your current version into the new chat before continuing. It’s best suited for research, planning, and brainstorming threads where the conclusions matter more than the transcript.

Note 📍
In the free Claude Code setup via OpenRouter (covered in the dev section below), /compact works identically and in some agentic configurations, it auto-triggers once your context hits a certain size to prevent performance degradation.

Skills: Stop Explaining Yourself Every Time

If you’ve ever typed out the same long set of instructions across five different Claude chats—tone guidelines, preferred output format, specific workflow steps—Skills are the fix.

A Skill is a folder of instructions that teaches Claude how to complete specific tasks repeatably.

You build it once. Claude follows it every time—no re-explaining, re-prompting, or copy-pasting context into every new chat.

The difference from custom Project instructions is the scope. Project instructions are tied to one workspace. Skills work everywhere across Claude, across any chat, and any project.

When you ask Claude to do something, it scans your available Skills, loads the relevant one, and applies it. You don’t have to invoke it manually.

Claude recognizes the task from what you type and activates the right Skill on its own. You can also trigger one directly with a /skill-name command if you want to be explicit.

To get started: Go to Settings → Customize → Skills or type /skill-creator directly in the chat.

Hey! That’s what I did when I found myself constantly using the same prompt to generate certain SEO meta for content. The goal is to stay consistent without having to re-brief Claude each time.

From there, you can browse Anthropic’s built-in Skills (things like enhanced document creation for Word, Excel, PowerPoint, and PDF), Skills from the directory built by partners like Notion and Figma, or create your own.

Creating a custom Skill is simpler than it sounds since it’s just a Markdown file with instructions. The easiest way is to enable the Skill-Creator Skill (yes, there’s a Skill for building Skills), describe what you want, and Claude interviews you and generates it.

Good candidates for a custom Skill are any tasks that you repeat across different projects. Things like your brand voice, a specific research process, a report format, or a code review checklist.

Note 📍
Skills require code execution to be enabled in your settings. Toggle that on first or the feature won’t show up.

Explore: How To Build Complex Automations From A Single Prompt In 2026

Web Search: Getting Current Information

Built-in web search lets Claude pull current information directly in the chat. This is useful for anything that changes frequently (pricing, recent releases, news, documentation updates).

Claude’s default behavior is to answer from training data, not from a live search. If you need current info, explicitly ask it to search the web.

Say “search the web for X” or start your prompt with “using web search, find…” or, as I’ve found, say keywords like “research…”, “look up online…”, etc. that trigger the right behavior.

This is also the fix for Claude generating broken or hallucinated source links, which you might have run into.

When Claude answers from training data and doesn’t have a direct source, it sometimes invents citations. Not great, especially since they’re so damn convincing.

But when you tell it to search first, it pulls real, working links from live results. Big difference.

App Connectors: Bringing Your Tools In

This is the part most free users don’t know about. Claude’s app connectors enable integrations with tools like Notion, Google Drive, Gmail, Calendar, Figma, Slack, and dozens more that are available on the free plan.

The connectors are powered by MCP (Model Context Protocol), which is basically a standardized way for Claude to read and write data from your external tools without you switching apps.

What you can actually do with them:

Notion: Search your workspace for specific pages, create new pages with formatted content, update task statuses, and synthesize information across multiple pages.

Google Drive: Search for documents, pull content directly into a conversation, and save Claude-generated files back to your Drive (file creation needs to be enabled).

Gmail and Google Calendar: Search emails by natural language, draft email content (Claude creates drafts but can’t send), and check or manage calendar events.

Free users are limited to one custom connector (a custom MCP server you build yourself). Directory connectors—the prebuilt ones like Notion, Drive, etc.—are available without that restriction.

The setup takes about 30 seconds. Go to Settings → Connectors (or the Customize menu depending on your view), find the app you want, click Connect, and authorize through OAuth. You only do this once.

Note ⚠️
Keep in mind that connectors will expose the data of the app you choose to connect to the cloud model. This can impact your privacy and security so be strategic in what you connect and what information you so choose to expose.

Connecting an app doesn’t cost anything. But using it does, because Claude has to query the external service, process the results, and respond.

Think of connector usage as a premium quota that’s worth it when you need it, not something to do casually.

Understanding Your Limits (Without Going Full Engineer Mode)

This is the part that explains why you hit your limit faster than you expect.

Claude’s free tier uses a rolling 5-hour window, not a fixed daily cap. Your window starts when you send your first message and resets 5 hours later.

So if you start at 9 AM, your quota refreshes at 2 PM, not at midnight.

The rough estimate for free users is somewhere between 30 and 100 short messages per window, but the real number depends heavily on:

• message length
• conversation history
• whether you’re generating Artifacts or using connectors

Long conversations chew through your quota faster than you’d expect because Claude re-processes the entire conversation history with every new message.

Message 1 in a thread costs almost nothing.

Message 30 in that same thread is much more expensive because Claude has to load everything that came before it.

By the time you’re deep into a 50-message conversation jumping between topics, you’ve likely used the equivalent of far more than 50 messages’ worth of quota.

The practical fix: short, focused chats over long sprawling ones.

I find that, instead of having one massive conversation covering system architecture, QA planning, content strategy, and deployment all in one thread, I have four separate chats, one for each. All in the same Project, all referencing the same documents, but each staying focused on one thing.

This is genuinely how you stretch the free tier.

Tip 😏
Peak usage hours on weekdays (roughly 5 AM–11 AM Pacific) can slow response times and burn through your window faster. If you can, batch heavier Claude work to evenings or weekends.

Practical Setups for Real Use Cases

Okay, let’s get into real examples to put all this into a better perspective. Here’s how to actually set this up, depending on what you’re using Claude for.

For Writing and Content

Project setup:

• Upload: 2–3 of your best past posts or writing samples, plus a voice/style guide if you have one
• Custom instructions: Your audience, your tone, what you want Claude to flag (off-brand language, jargon, etc.)

Workflow: Instead of asking Claude to:

“Write a blog post about X”

Try:

“Outline a post about [topic] for [audience]. Include a hook based on a real problem, 4–5 main sections with key points, and a specific CTA. Reference my tone in the uploaded samples.”

That single structured prompt replaces 10 rounds of back-and-forth edits.

For editing existing drafts, paste your content and ask for specific feedback. Things like:

• “What’s weak about this intro?”
• “Where is this losing momentum?”

Rather than “make this better.” Specific questions get specific, useful answers.

For Development and Coding

Project setup:

• Upload: your PRD or requirements doc, any relevant tech specs, a list of your stack decisions
• Custom instructions: Your stack (e.g., Flutter 3.19+, Dart 3.x), your preferences, what you want flagged

Workflow: Write structured prompts that include context upfront:

Instead of:

“Help me plan my app”

Try:

“Based on the uploaded PRD, create a system architecture covering: authentication flow, local and cloud data storage with conflict resolution, and an offline-first sync strategy. Flag anything that conflicts with the requirements doc.”

That’s the difference between getting a generic answer and getting something actually relevant to what you’re building.

I’ve found that for iterative work (i.e., debugging, refactoring, adding features), it’s best to start a new chat for each distinct task within the same Project. This keeps token costs down and keeps Claude from getting muddled in a long thread that spans five different problems 😵‍💫

When I was recently planning a Flutter app, I ran five separate chats inside the same Project—one for system architecture, one for QA planning, one for deployment strategy, one for marketing, and one for a technical deep dive on auth.

Each chat was 3–6 messages. Each one produced a usable, specific document. Total: around 21 messages across a full week of planning work.

That’s the free tier doing real work, not because I had more quota but because I wasn’t wasting it re-establishing context in a single sprawling thread.

Note: Claude Code (the terminal-based coding agent) is not on the free tier. If you’re doing agentic coding workflows, that requires a paid plan.

The Claude Code Workaround (For Developers)

Since Claude Code requires a paid plan, here’s what I came across while researching this post for anyone who wants the terminal-based agentic coding experience without paying for it.

The setup uses OpenRouter, a free API router, combined with a tool called claude-code-router (ccr) that redirects Claude Code’s interface to run on free models such as Gemini 2.5 Flash or DeepSeek R1 instead of Anthropic’s paid models.

Here’s how to get it running, step by step:

Step 1: Check that you have Node.js installed

You need Node.js on your machine to run npm commands. If you’re not sure whether you have it, open your terminal and type:

node --version

If you see a version number, you’re good. If you get an error, head to nodejs.org and download the LTS version (it installs like any normal app).

Step 2: Get a free OpenRouter API key

Go to openrouter.ai/keys, create an account (no credit card required), and generate a new key. Copy it immediately and store it somewhere safe since you won’t be able to see it again after you leave the page.

A free account gives you access to 30+ models with daily limits 👍

Step 3: Install the two required packages

Open your terminal and run:

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

This installs two things:

1. The official Claude Code agent
2. ccr (claude-code-router)

That second item is the translator that redirects Claude Code away from Anthropic’s paid servers toward your free OpenRouter models.

Step 4: Create the config file

This is the step most guides skip over, so let’s be specific. You need to create a folder and a config file that tells the router which free models to use 💁‍♀️

Here’s where to put it depending on your OS:

• Mac/Linux:
  • Create a folder called .claude-code-router in your home directory
  • Then create a config.json file inside it
  • Full path should be: ~/.claude-code-router/config.json

• Windows:
  • Same file, saved to: %USERPROFILE%\.claude-code-router\config.json

If you’re not sure how to find your home directory:

• On Mac: Finder → Go → Home
• On Windows: open File Explorer and look for your username folder under “This PC.”

Once you’ve created the file, paste this in and save it:

{
  "OPENROUTER_API_BASE": "https://openrouter.ai/api/v1",
  "Providers": [
    {
      "name": "openrouter",
      "api_base_url": "https://openrouter.ai/api/v1",
      "api_key": "YOUR_OPENROUTER_API_KEY"
    }
  ],
  "Router": {
    "default": "openrouter,qwen/qwen-coder-32b-vision",
    "think": "openrouter,meta-llama/llama-3.3-70b-instruct:free"
  }
}

Replace YOUR_OPENROUTER_API_KEY with your actual key from Step 2.

The default model handles everyday coding tasks while the think model handles heavier reasoning. Both are free on OpenRouter.

Note: If you hit a rate limit on one model mid-session, just swap the model name in this file and restart. No other changes needed.

Step 5: Set your API key as an environment variable

This lets the router authenticate with OpenRouter automatically every session, without typing the key each time.

Mac/Linux:

echo 'export OPENROUTER_API_KEY="YOUR_KEY_HERE"' >> ~/.zshrc
source ~/.zshrc

Tip: If you’re on an older Mac or Linux using bash instead of zsh, replace .zshrc with .bashrc.

Windows (run PowerShell as Administrator):

[System.Environment]::SetEnvironmentVariable('OPENROUTER_API_KEY', 'YOUR_KEY_HERE', 'User')

Close and reopen your terminal after running this.

Step 6: Run it (two terminals, every session)

Every time you want to use this setup, you’ll need two terminal windows open at the same time:

Terminal 1 — start the engine:

ccr start

This starts a local server on port 3456. Leave this window open the entire session, as closing it shuts everything down!

Terminal 2 — launch Claude Code: Navigate into your project folder, then run:

ccr code

This opens the Claude Code interface pointed at your local router instead of Anthropic’s servers. From here, it works exactly like the paid version with the same commands, workflow, Skills, and /compact support.

Tip 👀
The first startup usually takes 10–20 seconds. If it looks stuck, just wait a bit, it’s initializing.

What stays the same:

• Claude Code interface and workflow
• project context awareness
• ability to navigate your codebase and execute changes

What you lose: Claude’s actual reasoning. Sonnet and Opus approach complex coding problems differently than Gemini or DeepSeek. They’re better at catching edge cases, maintaining code consistency across files, and flagging architectural problems before they happen.

For boilerplate generation, refactoring, and straightforward bug fixes, the free model swap works fine. For anything complex or production-critical, you’ll notice the gap.

Tip 💡
If you’re a student or solo dev experimenting with agentic coding for the first time, this is a great way to get familiar with the workflow before committing to a paid plan.

For Research and Fact-Checking

Project setup:

• Minimal or no uploads for this one to keep it light
• Custom instructions: “Always use web search for anything time-sensitive. If you don’t have a direct source, say so instead of guessing. Keep answers concise.”

Workflow: Always lead with “Search the web for…” or “Research online…” on anything that changes, like pricing, product features, recent news, or API documentation.

This gets you working links and current info instead of Claude pulling from training data.

For longer documents, use the file upload in chat rather than pasting everything in. It’s cleaner and keeps your token usage more predictable.

For Learning and Study

Project setup:

• Upload: course materials, textbook chapters, or any reference docs you’re working through
• Custom instructions: Your current level (“I’m familiar with basic JavaScript but new to React”) and how you want explanations formatted

Workflow: Instead of:

“Explain X to me”

Try:

“Explain X at an intermediate level with a concrete example. Then give me a quick quiz question I can answer to check my understanding.”

You can also ask Claude to generate interactive study materials from uploaded PDFs. For example, you can turn a dense chapter into a set of flashcard-style Q&As, a structured summary, or a mini project to practice the concept. This is gold for any hands-on, visual learner out there!

One Setup, Right Now

If you’re going to do one thing after reading this, do this:

1. Go to claude.ai and create your first Project
2. Name it something specific—not “Work” but “Content Planning”, “Job Hunting”, “App Dev”, or whatever fits
3. Upload one document that Claude should always know about—a style guide, a requirements doc, your resume, whatever’s relevant
4. Write 4–5 lines of custom instructions: who you are, what you’re working on, how you want responses, if and what role you want Claude to take on
5. Open a new chat inside that Project and ask something specific

That’s it. The difference between that first structured chat and what you were doing before is usually immediate.

It’s a Wrap

Claude’s free tier is legitimately good now, not as a trial or a stripped-down version, but as an actual workspace with real tools.

The limit isn’t the features anymore. It’s knowing how to use them.

The short version: stop using Claude like a search engine.

Use Projects instead of one-off chats.

Write structured prompts with context upfront.

Keep conversations focused.

Use web search when you need current info.

And for the love of everything, check what’s in your memory settings.

The readers who get the most out of the free tier aren’t the ones with the most time, but the ones who set it up right once and stop repeating themselves.

Give it a shot and let me know how it goes. I’m curious what setups you land on.

Hope this helps 👋