Put AI to Work For You

AI has no memory of you between chats unless you give it one. Every new chat starts blank.

The biggest jump in quality doesn't come from a clever prompt. It comes from context:

• Who you are.
• What you're working on.
• What a good answer looks like.

Most people skip this and wonder why the results feel generic. Give it context and everything after gets better.

ChatGPT and Claude both let you set standing instructions once, so every new chat starts knowing you. Here's where they live.

Fill in the block below, copy it, and paste it into that box. ('System instructions' is the developer word for the same thing.)

Same box you just filled in: Custom instructions in ChatGPT, Instructions for Claude in Claude. Add a line to the bottom of it telling the AI how to write.

• Plain, short, direct, however you actually talk.
• One line here kills the stiff, robotic voice.
• In ChatGPT you can also set this just above the box, under Base style and tone.

The difference between a mediocre answer and a useful one is almost always the prompt. Three moves cover most of it:

• Role. Who it should be while it answers.
• Context. What it needs to know about your situation.
• Format. What you want back, and how long.

AI tends to agree with you. Turn that off. Add this to your standing instructions or drop it into any chat.

AI sounds just as confident when it's wrong. A few habits keep you out of trouble:

• Check names, numbers, dates, and quotes yourself.
• Keep private things private.
• Use it for the first draft and the thinking. You still sign off.

1. Set it up once. Put who you are and how you want answers into custom instructions. Don't write it from scratch. Tell the AI about your business and your role, then ask it to interview you and draft the instructions for you. Edit what it gives you and paste it in. It writes a better version of this than most people write about themselves.
2. One job per chat. New task, new chat. A chat carries everything you said earlier. Old context bleeds into the new question and muddies the answer. Starting fresh costs you nothing.
3. Make it improve your own prompt before it answers. Paste your prompt and ask what's missing before it runs. It spots the context you left out faster than you will.
4. Tell it to push back and flag what it's unsure of. Agreement feels good and teaches you nothing. Ask for the strongest case against your plan, not a second opinion that matches your first.
5. Give it a role, context, and the format you want. Format is the one people skip. Say the length, the structure, and who's going to read it.
6. Show it what good looks like. Paste an example. One real example beats a paragraph describing what you want. Paste something you were happy with and tell it to match that.
7. Tell it who the answer is for. The reader changes the whole draft. "Write this for a skeptical CFO" and "write this for a brand-new hire" are two different pieces. Name the audience up front and you skip a rewrite.
8. When it's wrong, say what's wrong. Don't start over. A weak answer is a starting point, not a dead end. Tell it exactly what missed and it fixes that piece. Opening a fresh chat just makes you re-explain everything from the top.
9. Check names, numbers, dates, and quotes yourself. These are exactly what it invents most confidently. Everything else you can judge by reading it.
10. Let it ask you questions before it answers. Say "ask me what you need to know first." Three questions up front beats three rounds of rewrites.

The best prompt is usually one built for your own task. Describe what you're trying to do and have the AI write and sharpen the prompt for you. When you want a starting point, these are worth browsing.

• Anthropic's Prompt Library Official, for Claude.
• OpenAI's prompt examples and guide Official, for ChatGPT.
• Wharton's "More Useful Things" library Free, business-focused, no sales pitch.

A project is context made permanent. Set it up once and every chat inside it starts already knowing your business, your customers, and your voice. You stop re-explaining yourself from scratch, and the answers get better because it's working from your material instead of guessing.

Two layers, and the difference matters once you run more than one kind of work.

• Global instructions apply everywhere. Custom instructions in ChatGPT, Instructions for Claude in Claude.
• Project instructions apply only inside that project, and they override the global ones.
• Use global for how you always want answers.
• Use project for one body of work: a client, a product, a recurring report.

Long chats drift. Thirty messages deep, the model has lost the thread and starts contradicting itself. The fix is to move the good part into a clean chat instead of fighting the mess.

• Ask it to summarize what's been settled: decisions, context, where you left off.
• Paste that summary into a fresh chat and pick up clean.
• The same move carries context from one tool to another, or from a chat into a project.

Use one answer as the input to the next, instead of asking for everything at once.

• Draft it with one prompt.
• Feed that draft into a second prompt that critiques or reshapes it.
• Each step stays small enough to get right.

Stop pasting. Both tools can read your actual work once you connect them.

• Hook up what your business already runs on: Gmail, Google Drive, Calendar, Notion, Slack, and hundreds more.
• Then ask about real material. "Summarize the thread with this client." "Pull the numbers out of last month's report."
• It's the difference between describing your work and letting it see your work.
• Connect one thing first, wherever your work actually lives. Not all of them.

There's an open standard underneath all of this that raises the ceiling a long way. That's waiting for you in Expert.

Typing is the bottleneck. Most people hand the AI less context than they should, because writing it all out is work.

• Wispr Flow is the one to know. It turns speech into clean, punctuated text in any app: your AI chat, email, Slack, a doc.
• It strips the filler and the backtracking as you go, so you get finished writing, not a transcript you have to clean up.
• Runs on Mac, Windows, iPhone, and Android. Handles over 100 languages.
• Roughly four times faster than typing: about 220 words a minute against 45 on a keyboard.
• ChatGPT and Claude both have a mic button already. Wispr Flow matters because it works in everything else too.

The point isn't speed for its own sake. When context is cheap to give, you give more of it, and the answers get better.

You've moved past prompting into making the tools yours: projects that hold your context, connectors that read your real work, and voice that makes context cheap to give.

Expert is where this turns into a system that runs without you. Moving your whole setup between tools, giving the AI real tools with MCP, putting your work in a repo, and building software you couldn't buy off the shelf.

There's no one-click transfer of your chats, but your context moves easily. Three ways:

• Use the built-in import. In Claude: Settings, Capabilities, Import memory from other AI providers, Start import. Claude hands you a prompt to run in ChatGPT, ChatGPT lists what it knows about you, and you bring that back.
• Or move it by hand. Copy your instructions and saved memories out, clean them up, paste them in.
• A custom GPT becomes a Claude project. Paste its instructions, upload its files.

When you paste something for the AI to work on, it can blur your instructions with the material. That's how a document ends up giving the orders.

• Label both parts. Say plainly which is the task and which is the material.
• Fence the material inside quotes so the boundary is obvious.
• Tell it to treat everything fenced as material, never as instructions.
• This matters more the more you automate, because you stop reading every input first.

Connectors are the consumer version. MCP is the standard underneath, and knowing it exists is what moves the ceiling.

• What it is. Model Context Protocol, an open standard Anthropic published in late 2024. Think of it as a universal plug: one shared connector instead of custom wiring between every AI and every app.
• Who supports it. Effectively everyone now, Claude and ChatGPT included.
• What already exists. Thousands of prebuilt MCP servers: databases, CRMs, project trackers, calendars, accounting systems.
• What it buys you. The AI stops guessing and starts doing. It reads your real data and takes real action in your real systems.
• Where to start. Don't build one. Add an existing one for a tool you already pay for, and watch what changes.

A repo is a folder with a memory. It's where a system lives instead of scattering across a hundred chats.

• Repo is short for repository. A folder of files that keeps every version of everything in it.
• Nothing is ever lost. You can see what changed, when, and go back to any earlier version.
• You don't need to be a developer. Your prompts, instructions, templates, and working docs all live in one.
• Claude Code is what works inside it. Point it at the folder and it reads and edits across the whole thing, not one pasted file at a time.
• It runs in the terminal, as a desktop app on Mac and Windows, in the browser at claude.ai/code, and inside VS Code.

This is the jump from "I have a good prompt" to "I have a system."

Sometimes the answer isn't a better prompt. It's a small piece of software that didn't exist yesterday.

• Lovable turns a plain English description into a working web app: the screens, the database, the logins, deployed and live at a URL.
• Real uses for an operator: a client intake form, an internal dashboard, a pricing calculator, a booking page.
• It syncs to GitHub, so what it builds lands in a repo you own.
• It connects to Claude over MCP, so you can drive it from a chat.
• Start small and internal. The first one you ship changes how you see every other problem.

The test of a system: it runs the same way when you aren't thinking about it.

• Anything you've done three times is a candidate.
• Write down how it's done once, and let the tool hold it instead of your memory.
• Make, n8n, and Zapier handle the trigger. Something happens, the work runs, you review the output.
• Example: every Friday the week's notes go in, and the update comes out in your voice, formatted the way you send it.

You stop rebuilding it each time. That's the whole game.

Everything above earned its own section. These are the other ones worth knowing, and what each is actually for.

• NotebookLM Load your own documents and ask questions across all of them. Answers point back to the source, so you can check them.
• Perplexity Web search that answers in plain prose and links every source. Good for research you intend to verify.
• Gamma Turn a prompt or a rough doc into a presentation or a one-pager.
• Descript Edit video and audio by editing the transcript. Delete a word and it's gone from the video.
• ElevenLabs Realistic AI voice. Voiceover for video, or an audio version of your writing.
• Granola, Fathom, Otter Sit in your meetings, write the notes, pull out the action items.

Don't adopt all of these. Pick the one that removes your most annoying recurring task.

You have the full map now: set it up, sharpen the prompt, make it yours, build the system.

None of it counts until one piece is running. Pick the single job that eats the most of your week, build the smallest version that works, and let it run. That's the line between knowing about these tools and having them work for you.