Category: AI Tools

ChatGPT’s Canvas feature rolled out quietly in late 2024, and most solo operators still treat it like a slightly fancier text box. That’s a mistake. Canvas fundamentally changes how you should interact with the model when you’re drafting, editing, or iterating on long-form content.

If you’re still pasting drafts back and forth between Google Docs and the chat window, or if you’ve tried Canvas once and dismissed it because “the chat works fine,” this is worth understanding properly.

What Canvas actually does

Canvas opens a split-pane interface. Your prompt stays in the left chat window. The output appears in a dedicated editing pane on the right. You can highlight sections, ask ChatGPT to rewrite specific paragraphs, adjust tone, or insert new sections—all without re-generating the entire document.

The key difference: Canvas treats your draft as a persistent artifact you refine, not a disposable output you replace. The chat window treats every response as a new answer. Canvas treats it as an evolving document.

That distinction matters when you’re writing newsletter drafts, landing pages, email sequences, or long-form articles. It matters less when you’re asking one-off questions or generating lists.

When to use Canvas

Use Canvas when you’re iterating on structure, not just tweaking words.

If you’re drafting a 1,200-word article and you realize the second section is too technical, you don’t want ChatGPT to regenerate the whole piece. You want to highlight paragraphs 4–7 and say “make this less jargon-heavy.” Canvas lets you do that. The chat window forces you to either accept the entire rewrite or manually splice fragments together.

Use Canvas when you need version control inside the same session.

Canvas saves previous versions as you edit. If ChatGPT rewrites your intro and you hate it, you can roll back without losing the rest of the draft. In the chat window, once a response scrolls up, it’s effectively gone unless you scroll back and copy-paste.

Use Canvas when you’re working on something longer than 400 words.

Short outputs—social captions, subject lines, single-paragraph rewrites—don’t benefit much from Canvas. The overhead of opening the pane isn’t worth it. But once you’re past 400–500 words, the ability to target edits and preserve context becomes a significant time-saver.

When to stick with the chat window

Use the chat window for exploratory prompts.

If you’re brainstorming headline ideas, asking ChatGPT to explain a concept, or generating a list of content angles, the chat window is faster. Canvas adds friction when you don’t need persistence.

Use the chat window for quick rewrites or single-use outputs.

Need three variations of a CTA? Want to rewrite one sentence five different ways? The chat window is built for rapid, disposable iteration. Canvas is built for refinement over multiple rounds.

Use the chat window when you’re chaining prompts that don’t need a shared artifact.

If you’re asking ChatGPT to analyze your traffic data, then draft an email, then suggest three A/B test ideas, those are separate tasks. Canvas doesn’t help. The chat window’s linear thread is easier to follow.

The non-obvious trick: use Canvas as a scratch pad, not a final draft tool

Here’s the workflow most operators miss: don’t start in Canvas. Start in the chat window, then move to Canvas once you have a rough structure worth refining.

Prompt ChatGPT in the chat window with your outline, audience, and key points. Let it generate a rough first draft. If the structure is close, then open Canvas and paste it in. Now you can refine section by section without regenerating the whole thing every time you tweak the intro.

This two-stage approach—chat for generation, Canvas for refinement—saves 20–30 minutes on any piece over 800 words. You’re not fighting the tool’s defaults. You’re using each interface for what it’s good at.

One more thing: Canvas has a tone slider and a length adjuster in the toolbar. Most people ignore them. Don’t. If you highlight a paragraph and drag the tone slider toward “casual,” ChatGPT rewrites just that section without you writing a new prompt. It’s faster than typing “make this less formal” every time.

When this matters for your business

If you’re writing one newsletter a week, this probably saves you 15–20 minutes per issue. If you’re drafting landing pages, email sequences, or long-form SEO content, it’s the difference between spending two hours on a draft and spending three.

Canvas isn’t a mandatory feature. But if you’re still copying and pasting between tools, or if you’re regenerating entire drafts because one paragraph didn’t land, you’re working harder than you need to.

Try this: Next time you draft anything over 600 words with ChatGPT, start in the chat window and move to Canvas after the first output. Refine in Canvas. See if it’s faster. If it’s not, go back to the chat window. But most operators who test this properly don’t go back.

If you found this useful, reply and let me know what AI tool you want broken down next. I read every response.

If you’re using AI to write, research, or automate any part of your online business, you’ve probably hit the same wall: the tool forgets everything between sessions. You end up re-explaining your audience, your voice, your product, and your preferences every single time.

Both Anthropic and OpenAI offer solutions. Claude has Projects. ChatGPT has custom instructions (and now GPTs, though those are a different beast). They solve the same problem—context persistence—but they work in fundamentally different ways, and picking the wrong one costs you time.

How Claude Projects work

Claude Projects let you create a named workspace with its own knowledge base. You upload documents, paste style guides, add background about your business, and then every conversation inside that Project has access to that material.

Each Project can hold up to 200,000 tokens of reference material (roughly 150,000 words). That’s enough for a full brand guide, product documentation, past article archives, customer research notes, and your editorial calendar all in one place.

The big advantage: you can have multiple Projects. One for customer support replies, one for content writing, one for course development. Each stays isolated. The AI doesn’t mix context from your SaaS docs into your newsletter drafts.

Projects are available on Claude Pro ($20/month) and the API. The free tier doesn’t get them.

How ChatGPT custom instructions work

Custom instructions are a single set of persistent guidelines that apply to every conversation in your account. You get two text fields: one for context about you, one for how you want ChatGPT to respond.

The context field is where you explain your business, audience, products, and role. The response field is where you set tone, format preferences, and constraints (e.g., “always use American English,” “never use exclamation marks,” “keep answers under 300 words”).

The limitation: it’s global. You can’t scope instructions to specific use cases unless you manually turn them off, edit them, or work around them in your prompts. If you want formal tone for client emails and casual tone for social posts, you’re stuck toggling or overriding.

Custom instructions are free on all ChatGPT tiers, including the free plan. GPT-4 and GPT-4o respect them. GPTs (the custom chatbot builder) bypass custom instructions entirely and use their own system prompts instead.

When to use Claude Projects

Use Projects when you have distinct workflows with different context needs. If you’re writing a newsletter, managing a membership community, and building a course, those are three separate Projects. Each gets its own voice guide, audience research, and example library.

Projects also shine when you need to reference large documents repeatedly. Upload your entire content archive, and Claude can pull from it without you pasting excerpts into every prompt. It’s particularly useful for research-heavy work—competitor analysis, SEO audits, or synthesizing reader feedback.

The major downside: you have to remember to switch Projects. If you’re in your “newsletter” Project and ask a question about your course, Claude won’t know what you’re talking about. It’s not smart enough to auto-switch.

When to use ChatGPT custom instructions

Use custom instructions when your needs are consistent across everything you do. If you’re a solo operator with one brand, one voice, and one audience, global context works fine. Set it once, forget it.

Custom instructions also work well for constraints and formatting preferences that apply universally. Things like “never use jargon,” “default to bullet points,” or “cite sources inline” belong here. You don’t want to re-specify those in every Project or GPT.

The catch: if your work varies in tone or scope, custom instructions become a lowest-common-denominator compromise. You’ll end up writing longer prompts to override the defaults, which defeats the purpose.

The hybrid approach

Most operators I’ve talked to don’t pick one. They use both tools for different parts of the business.

Claude Projects handle the heavy, structured work: content production, documentation, research synthesis. ChatGPT with custom instructions handles the quick, ad-hoc stuff: drafting emails, brainstorming headlines, troubleshooting code snippets.

If you’re paying for both—Claude Pro and ChatGPT Plus both run $20/month—this split makes sense. If you’re only paying for one, pick based on where you spend the most time. Content-heavy businesses lean Claude. Generalists lean ChatGPT.

Reply to this email if you’re using Projects or custom instructions in a way that’s working (or not). I’m collecting notes for a follow-up on how operators are actually structuring their AI workflows.

Claude Code is the answer to a question most operators stop asking around year three: can I just build this thing myself, or do I have to pay someone?

For the last decade the answer was almost always “pay someone.” Custom WordPress plugin? $750 from a freelancer. Migration script? $400. Bespoke admin tool to fix one annoying workflow? Not worth it at any price. The friction was always the same — you knew what you wanted, but the gap between knowing and shipping was wider than it was worth crossing.

Claude Code closes that gap. It’s Anthropic’s command-line agent — a chatbot that can read every file in your project, write new files, run commands, and tell you when it’s done. Pair it with a base subscription to Claude Pro ($20/month) or Claude Max ($100/month) and you can build the small bespoke things that previously weren’t worth a freelancer’s invoice. This post is the operator’s guide: what it actually is, what’s worth building with it, where it goes wrong, and how to avoid the bills people quietly spend on it without realizing.

What Claude Code actually is

It’s a CLI app you install on your laptop. Once it’s running, you point it at a folder (your WordPress plugin, your Next.js app, your scripts/ directory of one-off Python tools) and you talk to it like you’d talk to a junior developer. “Add a settings page to this plugin.” “Find why this script crashes on rows where the price is null.” “Migrate this CSV into the new database schema.” It reads the files, writes the changes, runs whatever tests you have, and tells you what it did.

It’s not a chatbot in a browser tab. It runs locally with file system access. Everything it changes is on your disk, in git if you’ve initialised git, ready to review and commit. That distinction matters more than it sounds — most “AI helps me code” workflows are still copy-paste between a browser and an editor. Claude Code skips the copy-paste.

The cost math, with honest numbers

For an operator who codes maybe twice a week, the right tier is Claude Max $100/month. Below that you’ll either run out of usage limits during a focused build session, or you’ll pay-per-use through the API and watch costs balloon unpredictably.

Use intensity	Right tier	Monthly cost
1–2 sessions a month, 1–2 hours each	Claude Pro	$15
1–3 sessions a week, focused builds	Claude Max (5×)	$80
Daily / serious project work	Claude Max (20×)	$160
Heavy + via API for automation	API pay-per-use	$100–500 variable

For comparison: a WordPress freelancer charges $500–$1000 for a custom plugin you’d describe in a paragraph. Two of those a year and you’ve already paid for a year of Claude Max. The break-even is three custom builds per year — most operators have at least that on their backlog if they’re honest about it.

What it’s actually good at (with examples)

Concrete things we’ve built with Claude Code at One Two Three Send and adjacent projects:

Custom WordPress plugins. The plugin you’re reading this post on was built largely with Claude Code. Settings pages, REST endpoints, custom post types, scheduled cron jobs, encrypted storage of API tokens — all the patterns are well-documented and Claude Code knows them. The trick is keeping each session focused on one feature at a time.

One-off data wrangling. Migrating subscriber lists between platforms, backfilling missing meta on 5,000 posts, importing a CSV into a custom database, scraping a competitor’s RSS feed for inspiration. The scripts are 50–200 lines, take 15 minutes to write with Claude Code, and you delete them after they’ve run.

Cross-site provisioning. Running 10+ WordPress sites for a multi-brand newsletter business? Write a Python script that takes one JSON config per brand and provisions everything via REST — site title, plugins activated, API keys, custom templates, signup forms. We did this exact thing for the One Two Three Send multi-brand rollout. Saved 3+ hours per brand.

Refactors and bug hunts. “There’s a bug somewhere in this 3,000-line PHP file where the date appears as ‘Nov 30, -0001’. Find it.” Claude Code reads the file, traces the data flow, finds the bug, and tells you the fix in 30 seconds. Genuinely worth the $100/month for that alone.

Documentation. Point it at a codebase and ask for a README. Ask for inline comments where the logic is non-obvious. Ask for a CHANGELOG generated from your git log. None of this is glamorous and all of it accumulates value.

Tests. Most operators don’t write tests because the upfront cost feels infinite. Claude Code writes them in minutes. They’re not always perfect; they catch the regressions that matter.

What it’s NOT good at

Be honest with yourself about these.

Open-ended product design. Asking “what should we build next?” produces generic answers. The agent is downstream of your product instinct, not a substitute for it.

Domains where the training data is sparse or contested. Bleeding-edge framework versions, niche e-commerce platforms with thin docs, proprietary CRMs — Claude Code will sound confident and be wrong. It’s at its best on mainstream stacks (WordPress, Node.js, Python, React, the AWS basics) and degrades fast outside them.

Anything where the spec is unclear in your own head. “Make the dashboard better” wastes tokens. “Add a column to the dashboard table showing percentage change vs last week, sorted by absolute value descending” produces working code in one shot. The discipline you need is the same discipline you’d need with a junior developer.

Production deployments that nobody reviews. Don’t auto-merge whatever Claude Code produces. Read every diff. The mistake mode isn’t usually “the code is broken” — it’s “the code works but does subtly the wrong thing.” For example: deletes rows it should have soft-deleted, retries failures forever instead of giving up, hardcodes a value that should have been a setting.

Honest comparison vs the alternatives

vs Cursor — Cursor is an editor (a fork of VS Code) with AI baked in. Better workflow if you want to stay in an IDE. Claude Code is better if you want to “talk and watch it work” rather than drive an editor yourself. Many serious developers run both — Cursor for the everyday editing, Claude Code for the bigger autonomous tasks. Cost is similar.

vs GitHub Copilot — Copilot is autocomplete-on-steroids. It writes the next 5 lines as you type. It does not read your repo, does not run tests, does not refactor. Useful for typing speed; doesn’t change what’s worth building. $10/month, complementary not competitive.

vs Aider — Open-source equivalent of Claude Code. Same agent pattern, runs in your terminal, brings your own API key. If you’re philosophically committed to open-source tooling or want to swap models, Aider is the answer. Claude Code’s ergonomics are better; Aider’s flexibility is better.

vs ChatGPT / Claude in a browser — Different category. Browser chatbots work well for “explain this code” or “write a 10-line snippet.” For anything that touches multiple files, you spend 10 minutes copy-pasting before the agent does any actual work. Claude Code skips that.

vs hiring a freelancer — A good developer at $100/hour will build better software for medium-complexity work. They’ll also take 2 weeks for what you wanted last Tuesday. The honest tradeoff: Claude Code for things you’d otherwise not build at all, freelancer for things that genuinely matter to your business and need to be right.

Setup, in the order to actually do it

1. Sign up at claude.ai. Pick the right tier (see cost math above). Start with Pro if you’re unsure — you can upgrade in 30 seconds when you outgrow it.
2. Install the CLI: npm install -g @anthropic-ai/claude-code. Requires Node.js 18+. On macOS the easier path is brew install node first.
3. Authenticate: claude login from your terminal. Opens a browser tab; come back to the terminal and you’re in.
4. Initialise a project: cd into the folder you want to work in (e.g. your WordPress plugin’s directory) and run claude. Type your first request.
5. Install git first if you haven’t. Every change Claude Code makes is reviewable — but only if your project is tracked. git init, commit your starting state, then turn the agent loose.
6. Create a CLAUDE.md file in the project root with project-specific context: “this is a WordPress plugin,” “PHP 7.4+ compatible,” “follow WP coding standards,” “tests run with phpunit.” Whatever’s true. Claude Code reads this every session and follows it. Five minutes spent here saves hours of misaligned output later.

Pitfalls operators hit (in the order they hit them)

1. Tokens add up. If you’re on the API pay-per-use tier, a single afternoon of debugging a 5,000-line file can cost $20+. Move to Claude Max once you find yourself anxious about each request — the predictable monthly bill removes the friction.

2. The agent makes plausible-but-wrong assumptions about your codebase. It might invent a function name, assume a config file exists at a path it doesn’t, or confidently call a deprecated WordPress API. Read the diffs. Always.

3. Letting it commit unsupervised. Don’t. Even when it asks “shall I commit this?” — review the diff first. The single most useful habit is “always git diff before git commit.”

4. Asking for too much in one session. “Refactor the entire plugin to use OOP” produces a tangled mess. “Refactor just the settings page to use a settings class” produces a clean diff. Smaller asks, more sessions.

5. Trusting the agent with secrets. Don’t paste API keys, customer data, or production credentials into the chat. Claude Code can see what’s on your filesystem when you let it; treat it like an intern with strong typing skills, not a vault.

6. Confusing “it ran without errors” with “it works.” An automated script can complete cleanly while having done the wrong thing. Test the actual behavior, not just the exit code.

Long-term: what changes when you’ve used it for a few months

The first month you’ll over-use it — building things you don’t actually need because building feels free. Resist this. The second month you’ll under-use it — going back to manual tasks out of habit. The third month is when the muscle memory clicks: you’ll instinctively reach for Claude Code at the moment a task crosses the “annoying enough that I’d otherwise put it off” threshold.

The accumulation matters more than any single use. The 50-line script that backfills missing image attribution. The 200-line plugin that schedules Facebook posts. The data migration that runs at 3am via cron. None of these would have existed if they had to wait for a freelancer’s quote. All of them now exist, take five minutes of attention each, and quietly do their jobs.

Spend twenty minutes a month deleting the scripts you’ve stopped using. Spend an hour a quarter rewriting your CLAUDE.md to reflect what’s actually true about your project now. Don’t spend tokens on entertainment requests when bored — they cost real money. Treat the agent like a contractor who bills by the minute, because that’s what it is.

When Claude Code is the wrong choice

If you’ve never written a line of code, Claude Code’s output will look like mysterious progress until something breaks and you can’t tell what’s wrong. The minimum bar isn’t “fluent in PHP” — it’s “I can read what this is doing and tell whether it looks reasonable.” If you can’t, you’ll either trust it too much (and break things) or too little (and spend longer than just doing it yourself). Spend a weekend on a basic Python tutorial first; you don’t need to be good, you need to be literate.

If your work is GUI-heavy with no underlying code surface — running ads in Meta Business Manager, managing campaigns in Mailchimp’s dashboard, updating Squarespace pages by drag-and-drop — Claude Code can’t help. Its leverage is on the parts of your business that have files in a directory.

For everyone else: Claude Code is the boringly-best automation tool available to operators in 2026. The honest case for it isn’t “AI revolutionises everything” — it’s “the small custom things that were never worth $500 are now worth $20, so build them.”