A personal AI assistant is a general-purpose chatbot you configure — through saved instructions, memory, and project containers — so it behaves consistently for your specific job instead of starting from zero every session. The problem is that most people never touch those settings. They open a chat window, type a request, get something generic back, and conclude the tool is mediocre.
The customization work is not complicated, but it is specific. ChatGPT, Claude and DeepSeek each expose different levers: ChatGPT has memory and custom instructions plus project containers; Claude has Projects and Artifacts; DeepSeek's leverage is mostly cost and open-weight access rather than a rich settings panel. Below is what each lever actually does, how to set it, and where it stops helping.
Start with the two settings that do most of the work
Before you build anything elaborate, configure the two persistent layers. They apply to every conversation and they take about ten minutes.
Custom instructions are a saved block of context the model reads before your message. In ChatGPT, they live under Settings → Personalization → Custom instructions, split into two fields: one for "what should ChatGPT know about you," one for "how should it respond." The first field is where your role, domain and audience go. The second is where format rules go — output length, whether you want bullet points or prose, whether you want caveats flagged or suppressed.
Memory is different. It's not a block you write; it's facts the model accumulates from your conversations and stores for later retrieval. In ChatGPT it's toggled under Settings → Personalization → Memory, and you can review and delete individual entries. Claude's equivalent is a memory feature you manage from your account settings, and it works the same way conceptually — the assistant carries forward stated preferences without you re-typing them.
The distinction matters because they fail differently. Custom instructions are deterministic: whatever you write is always in context, which is good for hard rules and bad if you write too much (long instruction blocks compete with the actual task for the model's attention). Memory is opportunistic: it captures what it decides is worth keeping, which means it will sometimes remember the wrong thing and you have to prune it.
Practical rule: put your non-negotiables in custom instructions — role, audience, format, banned phrases. Let memory handle soft preferences you'd otherwise repeat.
How to set up a Project in ChatGPT for a recurring workflow
Custom instructions are global. A Project is scoped. If you have one workflow that looks nothing like the rest of your work, a Project is the right container.
In ChatGPT, Projects let you group related chats, and — the part people miss — attach files and project-level instructions that apply only inside that container. So a project for "weekly competitor teardowns" can hold your source documents, your house style, and instructions specific to teardowns, without polluting your general assistant.
The setup sequence is short:
- Create the project and give it a name that describes the output, not the topic.
- Upload the reference files the workflow depends on — style guides, past examples, data exports.
- Write project instructions that state the deliverable format, the audience, and what "done" looks like.
- Keep every related conversation inside the project so the context stays together.
Why this works: the model doesn't have to infer your format from a fresh prompt each time. It reads the container. That removes the single largest source of output variance in recurring work — you re-explaining yourself slightly differently every session.
Claude Projects and Artifacts: the same idea, different mechanics
Claude's Projects work on the same principle — a container with its own knowledge and instructions — and Anthropic's assistant is positioned around safety-first behavior with a large context window and features like Artifacts, which render generated code, documents or diagrams in a separate panel you can iterate on directly.
Artifacts change the workflow in a way that's easy to underestimate. In a normal chat, output scrolls away and you copy-paste it out. In an Artifact, the output is a persistent object you edit in place. For anything you'll revise — a reusable template, a small script, a formatted document — that's a meaningfully different loop. You're not regenerating from scratch; you're editing a thing.
The trade-off: Artifacts are best for self-contained deliverables. If your work is mostly conversational analysis, the panel adds a step without adding much.
A worked case: a weekly reporting workflow, end to end
Say you produce a weekly summary for a small team. Same structure every week, different inputs. Here's how the three layers stack.
Layer one — global instructions. In ChatGPT's custom instructions, you write: "I write internal status updates. Audience is a non-technical team. Default to short paragraphs, no bullet points unless I ask, flag any number you're unsure about." That applies everywhere, forever.
Layer two — a project. You create a project called "Weekly Team Update." You upload last month's updates as format references and write project instructions: "Match the structure of the uploaded examples. Sections: what shipped, what slipped, what's blocked. Keep it under 400 words."
Layer three — the session. Each week you open the project, paste the raw notes, and ask for the update. Because the container already holds the format and the examples, the prompt is one sentence instead of a paragraph.
The output difference is the point. Without the container, you'd get a reasonable summary in whatever shape the model defaults to, and you'd reformat it. With the container, the first draft arrives close to final. You've moved the work from "fix the output" to "supply the input."
Where this breaks: if your weekly report format changes often, the project instructions become stale and actively fight you. Containers reward stable workflows and punish unstable ones. If your format shifts every few weeks, stay in plain chats and keep your instructions lean.
What these assistants still do badly
Be clear-eyed about the failure modes, because they're consistent.
Memory drifts. It will confidently carry forward a preference you mentioned once in passing and never meant as a rule. Check the memory list periodically and delete what's wrong — this is maintenance, not a one-time setup.
Long instruction blocks degrade. If you write a thousand words of custom instructions, the model starts ignoring parts of them, and you can't predict which parts. Keep global instructions short and push detail into project containers where it's scoped.
Nothing here gives you unattended execution. A project is a context container, not a scheduler. If your workflow needs to run on its own at 6am, these settings don't get you there — that's a different class of tooling entirely.
Where DeepSeek fits — and where it doesn't
DeepSeek is the cost outlier in this group. Its API pricing runs at roughly $0.435 per million input tokens and $0.87 per million output tokens, which the database records as about 12x cheaper than GPT-5.5, and it's free to use through the web and app. For high-volume, low-stakes work — bulk classification, first-pass drafting, anything you'll review anyway — that price gap changes what's economically viable.
What it doesn't give you is the same configuration surface. The customization story above is largely a ChatGPT and Claude story. If your workflow depends on project containers and persistent memory, DeepSeek isn't the tool for that layer.
On pricing generally: these plans change frequently, and the vendor's own page is the only reliable source. The database snapshot this piece draws on records ChatGPT at Free (GPT-4o mini), Plus at $20/mo and Pro at $200/mo, and Claude at Free, Pro at $17/mo annual or $20/mo, with Max from $100/mo — but treat those as a point-in-time record, not a quote.
Key Takeaways
- Custom instructions are deterministic and always in context; memory is opportunistic and needs periodic pruning.
- Use global instructions for non-negotiables and project containers for workflow-specific format and reference files.
- Claude's Artifacts turn output into an editable object, which suits deliverables you'll revise repeatedly.
- Containers reward stable workflows — if your format shifts often, keep instructions lean and stay in plain chats.
- DeepSeek's advantage is cost per token, not configuration depth; it won't replace project containers.
The decision rule
If you repeat a task weekly and it needs format consistency, save it as a project with instructions and reference files. If it's a preference that applies everywhere, put it in custom instructions. If it's a soft preference you'd otherwise retype, let memory handle it and audit the list monthly. If it needs to run unattended on a schedule, none of these settings will do it — look elsewhere.
That's the whole game. The assistants are capable out of the box; the gap between a mediocre experience and a good one is almost entirely whether you spent twenty minutes configuring the container before you started asking for things.
Sources
AI Tool Database, ChatGPT — pricing and capability snapshot, 2026. Records OpenAI's assistant at Free (GPT-4o mini), Plus $20/mo and Pro $200/mo, with 700M+ weekly users.
AI Tool Database, Claude — pricing and capability snapshot, 2026. Records Anthropic's assistant at Free, Pro $17/mo annual or $20/mo, Max from $100/mo, with Projects and Artifacts.
AI Tool Database, DeepSeek — pricing and capability snapshot, 2026. Records API pricing at $0.435/$0.87 per 1M tokens, described as roughly 12x cheaper than GPT-5.5.
AI Tool Database, Internal tool index — verification methodology, 2026. 360 AI tools tracked with pricing and capability snapshots; most recent verification 2026-09-18.
Frequently Asked Questions
What's the difference between custom instructions and memory?
Custom instructions are a block of text you write that's always included in context — deterministic and fully under your control. Memory is accumulated automatically from your conversations and retrieved when relevant. Instructions are better for hard rules like format and audience; memory is better for soft preferences you'd otherwise repeat. Memory needs periodic review because it can capture things you didn't intend as rules.
Do I need a Project, or are custom instructions enough?
Custom instructions are global, so they apply to everything. If you have one workflow with its own format, reference files and audience, a Project keeps that scoped so it doesn't contaminate your general assistant. A simple rule: if the task repeats and needs format consistency, use a project. If it's a preference that applies everywhere, global instructions are enough.
Can these assistants run a workflow on a schedule without me?
No. Projects and instructions are context containers — they shape what the model knows when you talk to it, not when it acts. If your workflow needs to execute unattended at a set time, that requires a different class of tooling, typically something built on an API with its own scheduler. Configuration settings alone won't get you there.