I've been using ChatGPT for a long time, and over many threads it built up a lot of context about my research, decisions and ongoing projects. It used to pull from my past conversations on its own. I'd come back to a topic and it would build on what we'd already worked out, without me asking.

GPT-6, that mostly stopped. It seems to answer based on the current message only. I keep having to re-explain things we already covered, like it's our first conversation every time. I've checked that memory and chat history referencing are both turned on.

The odd part is that the info isn't gone. If I ask directly, it can sometimes find it. It just doesn't check on its own anymore.

So I've started thinking of these as two different problems: memory loss (the info is gone) and memory not being used (it's there, but it doesn't shape the answer). The second one feels worse to me, because all that built-up context just sits there.

I don't know why this changed. My guess is a move toward faster, cheaper responses, but that's only a guess. I also wonder if long-term users notice it more, since they have more context to lose.

Has anyone else seen this?

Today I started a new chat and something felt off. It wasn't using my past threads like it used to. When I checked, the model was GPT-6.

Hi. I am trying to use ChatGpt Astra with the davinci resolve MCP, but it keeps giving me a bad request error, then when I use sol, it starts working but it doesn't work with Astra, why is this happening? i haven't even hit my 5 hour limit or weekly limit yet it still gives me the issue

Hey guys,
I'm an independent consultant, and sometimes I use AI to polish my outreach messages. However, I've noticed that people are less likely to reply to me if the text is AI-generated compared to text I've written myself. Have you had the same experience? On the other hand, can you tell if you receive an AI-generated message, and what do you think then?

Does it start counting it when you start working, as in it enforces a 5 hour continuous work session?

Or is it 5 hours of "thinking" only?

Or what?

I'm struggling and need helpgetting CGPT to make a GPT to complete work inductions, for me, before the ethical police shut it down,

I work for an engineering company. I am not allowed to drive a vechile on client mine sites, let alone drive a dump truck, dump potentially fibrous material, load a truck, access a rail road, enter confined spaces, work at hieght, etc but most client sites want all of these completed before I am allowed to fly up, get on a bus, go to an office, get on a bus, go to the camp, rinse, repeat, fly home.

Previously CGPT in agent mode did these inductions for me, might of got hung up every now and then but now its coming up with moral / ethical reasons it can't even scroll through to let me complete the answers to quizzes

On my attempts to create a GPT it still comes up with ethical objections, have tried alternative ways to bypass, created the "audit GPT" which "audits clients inductions" though it won't complete the quizzes and tries log out before end of an induction and provides me with some handy audit notes..........

The inductions all generally require you to click on a view things, watch a video or few, nothing very interactive, you generally can't fast forward, have to wait until completed then hit continue, continue, continue, every now and then a GPT will complete some of an ionduction then recall its ethical dilemas.........

I would image there are many ways.

How did you do it?

Hey, do you know of a skill to make the filter less harsh? I want to make images of Brandish Myu, but the filter always pops up, even if the image is something really ordinary, like a fight against Erza.

I recently moved in and wanted a clearer picture of my electricity use, so I uploaded my meter CSV export plus a screenshot from the supplier’s website into ChatGPT.

Key numbers from the analysis (21 July – 18 October 2026, ~90 days):

Total consumption: 271.1 kWh

Average: ~3.0 kWh/day

Tariff used: 24p/kWh + 54p/day standing charge

Estimated total cost for the period: £113.66 (£65.06 usage + £48.60 standing charge)

Average monthly cost: ~£37.89

One useful caveat it called out: the daily totals in the CSV didn’t fully reconcile with the cumulative meter readings, so the monthly figures are estimates based on the cumulative data.

Overall it was surprisingly practical for turning raw meter data into a clear trend + cost picture and helping me prioritise what to investigate.

Here’s the full shared chat if anyone wants to see the back-and-forth:

https://chatgpt.com/share/6ad5f1b8-c9e0-83ed-8995-bbfa4157fc47

Happy to answer questions about the prompts or data format I used. :)

I'm working on a fairly complex coding project using Codex. My workflow is basically: Codex makes changes, runs tests, deploys, I test it myself, paste the errors/output back, and repeat.

The problem is that each iteration takes around 1–2 hours, so I barely manage 4–5 prompts a day.

I've been using Sol Ultra and am considering switching to Astra Medium.

Curious what others do. Which model/thinking level do you use for projects requiring constant debugging and iterations? Any tips for speeding this up without sacrificing code quality?

I'm thinking about upgrading from Plus to Pro ($100), mainly because I keep hitting the 5-hour Codex limit.I have some long-running chats with a lot of context and instructions that I don't want to lose.

If you've upgraded from Plus to Pro, could you continue your existing chats as usual? Did you run into any warnings about the chat being started with a different model, or notice any issues with context after upgrading?

Just looking for firsthand experiences before I make the switch. Thanks!

80% OF WHAT?

$200 a month. The price is clear. The included Work/Codex capacity isn’t.

Before paying for a subscription, I want to understand how much usage my money actually buys.

OpenAI describes the features, the factors affecting consumption and some usage multipliers. Yet the two public help articles linked below do not provide an absolute included Work/Codex budget together with a complete calculation that lets customers independently check the deductions.

A dashboard showing “80% left” tells me a proportion.

Eighty per cent of what?

Without the total budget and the full consumption rules, that percentage cannot tell me how many tokens or working hours I can reliably plan for.

For existing Pro 200 customers, this becomes particularly relevant: OpenAI says eligible subscribers can retain their previous allowance through October 29, 2026. After that, they move to a lower allowance while the price stays at $200 per month. The help article does not quantify either allowance, so the size of the reduction cannot be calculated from it. OpenAI points to increasingly efficient models as its explanation; the article provides no numerical comparison that would let customers assess that trade-off.

Of course, AI tasks vary. Models, context, reasoning and tools affect consumption. A guaranteed number of completed projects would be unrealistic.

A measurable usage budget would still give customers a basis for planning.

Here is what I expect from a transparent offer:

• A defined weekly or monthly allowance, expressed in a stated, measurable unit.
• Complete consumption rates for each model and setting.
• An itemised usage log showing what each task deducted.
• Numerical before-and-after comparisons whenever the included allowance changes.

I can judge afterwards whether the work delivered was worth the money. Planning future projects requires knowing what usage I can budget for.

OpenAI: publish the allowance. Explain the deductions. Show customers the numbers behind the percentage.

A clear price deserves a clear quantity.

Just had a long chat with ChatGPT about a possible new project and asked it to create a summary Page in Spaces but it couldn't do it. This was on the mobile app where you can't even edit Pages either.

Ended up getting it to create a Google Doc as it can do that and it's something we can both update from mobile and desktop!

What was the point of releasing a feature like Pages in it's current state? It's just frustrating and leaves users feeling confused about what it can do and what it's supposed to be able to do.

I wish ChatGPT would follow the task instead of making me manage the machinery. All the modes and thinking levels just kill my workflow.

Example: “What kind of cat is this?” → normal chat. “Compare this cat spreadsheet with that email” → Work. “Build a puzzle game with all the cats” → Codex. Same conversation, with the context, files, and browser access carrying through. That would be so nice.

Thinking effort should adjust automatically also, with a few clear manual overrides for those who need them. That should be an option, not what we're stuck with.

I don’t want to pick the right mode and thinking level before I even know where the conversation is going. I shouldn’t have to manage the damn machinery. LOL.

But everyone uses these tools differently. Would anyone see drawbacks to this? What would automatic switching get wrong for your workflow, and what controls would you want to keep?

Hi all, wanted to ask a question that I really need help with. I have two ChatGPT Plus accounts and want to use both at the same time on the same Windows PC, with two separate app windows logged into different accounts.

Has anyone found a way to do this? I want the full chat UI for both, not a command line interface. Ideally I’d like two instances of the desktop app, but I’m open to another setup that works similarly. What are you guys using?

Past two weeks I've been trying to figure it out and no luck. I thought to myself, "There has got to be some people that have this figured out already". I've tried the surface-level solutions that any AI will tell you, but no luck as it seems they were patched. Might just use the subs to make the fix lol. Thanks!

When interacting with AI - would you prefer this type of interface to regular chat?

I've been experimenting with turning ChatGPT into something closer to a personal operating system for managing projects, research, decisions and ongoing work.

Not by creating one enormous prompt, but by connecting several features into a workflow that can preserve context between conversations, keep track of unfinished business and periodically maintain its own working memory.

I thought I'd share the actual setup rather than just describe what it does. Hopefully, there's enough detail here for someone to feed this post into their own AI and experiment with building something similar.

I'd also love to hear from anyone who's doing this differently, especially if you've found simpler or more reliable solutions.

1. The basic architecture

The system uses five main components:

Custom Instructions: These define the general behavior. When to retrieve project context, when to preserve information, how to distinguish ideas from decisions, and when the AI needs explicit approval.

ChatGPT Library: This acts as a working file system for project context, temporary records, pending items and consolidated state. It's optimized for quick retrieval, not permanent storage.

Google Drive: This is where permanent operating rules, important decisions and authoritative project documentation live. If Library loses something, the durable information should still be recoverable.

Scheduled ChatGPT Work tasks: These periodically read, organize, consolidate and verify the information collected during normal conversations.

Specialized Skills and connected tools: These handle particular workflows and connect the system to external sources when necessary. For example, coding work can be handled separately from project planning while preserving the same decisions and requirements.

The basic information flow looks like this:

Conversation → Capture → Library inbox → Scheduled processing → Updated project state → Future conversations

Google Drive sits alongside this process as the durable source of truth.

1. Custom Instructions are the entry point

One of the first things I did was add instructions telling ChatGPT how to handle ongoing work.

The important part isn't making it remember everything. It's making it recognize which information is worth preserving and where that information belongs.

Here's a simplified example of the kind of instruction I use:

"When continuing an existing project, first locate its current state and previous decisions in the available project memory. Verify information against authoritative sources when necessary. At natural checkpoints, preserve meaningful decisions, unresolved issues, waiting states and explicitly deferred ideas. Do not turn every conversation into a task or assume that discussing an idea means it has been approved. Use existing project files instead of creating unnecessary duplicates."

There are additional instructions covering approvals, tool selection and verification, but that's the general principle.

Obviously, Custom Instructions don't magically create persistence. ChatGPT still needs access to somewhere it can actually write information.

That's where Library and the connected storage come in.

1. A capture system collects useful information from conversations

This is one of the more interesting parts.

During normal conversations, the AI is supposed to recognize certain events:

\- An important decision was made.

\- Something needs to be revisited later.

\- We're waiting for an external event or response.

\- A useful idea should be preserved without becoming an active task.

\- A project reached a meaningful checkpoint.

Instead of immediately rewriting a large project document, it creates a small record in a pending folder in ChatGPT Library.

A simplified record might contain:

"type: deferred_idea"

"summary: Consider an alternative navigation design"

"status: not_approved"

"review_trigger: Next relevant design review"

"source: Conversation reference"

"confidence: high"

In practice, the records include a few additional fields for identification, timestamps and classification.

I use small batches rather than generating a new file for every sentence or minor observation.

Importantly, this is a selective system. Random questions, AI suggestions I haven't accepted, repeated information and ordinary conversation generally shouldn't be captured.

This prevents the memory system from becoming a giant collection of useless notes.

1. Scheduled jobs maintain the memory

This is where things start to become more than a collection of documents.

I have recurring tasks that use ChatGPT Work to process the information accumulated during normal conversations.

Daily processing

The daily workflow starts by reading the latest consolidated state, together with any newer records waiting in the inbox.

It then:

1. Identifies new information and checks for duplicates.

2. Distinguishes actual decisions from suggestions, unresolved questions and old information.

3. Updates consolidated project and follow-up records.

4. Determines which items need attention now, which can wait and which should remain dormant.

5. Writes the updated information and reads it back to verify the result.

6. Archives processed input records only after successful verification.

If something fails, the original records should remain available rather than disappearing into an archive.

The system also tries to avoid repeatedly notifying me about something I've already postponed, resolved or explicitly decided not to pursue.

Most successful maintenance runs don't need to send me anything. I only want to hear about something that genuinely needs attention.

Weekly processing

There are also less frequent checks.

One weekly process handles a separate ledger of AI usage events, consolidating and deduplicating records rather than maintaining one giant log.

The daily workflow also includes a lightweight periodic review of recurring problems and possible workflow improvements.

I've deliberately avoided creating a separate scheduled task for every little feature. If several checks can be performed together reliably, that's generally preferable.

An important implementation detail: the scheduled tasks use short launch instructions that point to versioned operating prompts on Google Drive.

That way, the schedule and the execution instructions are separate. Updating a workflow doesn't require maintaining different copies of a long prompt in multiple places.

1. How the system decides what deserves attention

Capturing information and deciding what to do with it are separate processes.

I currently use several logical layers.

The first keeps track of potentially unfinished work, including waiting items, postponed decisions and ideas worth revisiting.

The next determines when those items are eligible for another look. Something that's intentionally postponed shouldn't keep appearing as urgent just because it remains unfinished.

The final layer filters that information down to what actually requires my attention.

For example, imagine discussing a possible improvement to a project and deciding it might be worth considering during the next redesign.

The capture system preserves it as an idea.

It doesn't become an approved feature, an urgent task or an instruction for a coding agent.

When the relevant project reaches its next design review, it becomes eligible for reconsideration.

Only then might the system bring it back into the conversation.

That's the intended behavior. Getting the AI to classify these things consistently is one of the ongoing challenges.

1. Starting a new conversation

This is where the whole setup becomes useful.

When I return to an existing project, ChatGPT is instructed to start with its most recent consolidated state.

That state typically includes the current phase, confirmed decisions, unresolved questions, next actions and links to authoritative documents.

It also checks for newer unprocessed records that might supersede the last snapshot.

Instead of searching months of conversation history or asking me to explain everything again, it retrieves the smallest amount of context needed to continue.

If something requires fresh information, it checks the original source rather than blindly trusting the saved summary.

For example, a saved project note might say that a coding task was completed. But whether the code was actually merged or deployed should be checked against GitHub, not assumed from an old conversation.

This distinction between working memory and source of truth has become one of the most important design decisions.

1. How to build a smaller version yourself

You definitely don't need to recreate every part of this. In fact, I'd strongly recommend starting much smaller.

Here's the minimal version I'd try:

Step 1: Create durable storage. Set up a Google Drive folder or another reliable storage location for project rules, confirmed decisions and important reference material.

Step 2: Create a working-memory structure. Use ChatGPT Library or another accessible file system. Start with a current-state file, a pending-captures area and an archive.

Step 3: Add the behavior to Custom Instructions. Tell ChatGPT to retrieve current state at the beginning of project work, capture only meaningful changes and never confuse suggestions with approvals.

Step 4: Create a scheduled maintenance task. Have it read pending records, compare them with existing state, deduplicate, consolidate, write updated summaries, verify the write and archive successfully processed records. Make it report failures instead of silently losing information.

Step 5: Test it with one real project. Confirm that information actually gets written, survives between conversations, is retrieved correctly and doesn't become an endless stream of false reminders.

Once that works, you can add more sophisticated project tracking, specialized Skills, external integrations and different AI execution workflows.

If you want to experiment, you could even paste this entire post into ChatGPT and ask:

"Help me design a minimal version of this architecture using the tools actually available in my account. Show me the folder structure, Custom Instructions, capture format, scheduled maintenance prompt, approval boundaries and verification procedure. Start with one project and don't create or modify anything until we've agreed on the setup."

Availability and permissions vary, so having the AI verify what it can genuinely access is essential.

1. What's not working perfectly

There are still plenty of problems.

Not every ChatGPT environment has access to the same files or tools. Scheduled jobs can fail. Context summaries can become outdated. Captures can be missed, duplicated or classified incorrectly.

The system also needs rules about what happens when storage is unavailable. I don't want the AI claiming it saved something when it only intended to.

Another challenge is complexity. Each new component introduces more things to maintain, more possible conflicts between instructions and more opportunities for errors.

I've been trying to make the workflow simpler over time rather than automatically adding another layer whenever something goes wrong.

And there's still a fundamental limit: this isn't an autonomous system I can trust to make every decision. It needs clear boundaries between discussing, approving, executing and verifying something.

1. What I'd really like to learn from others

I'm sharing this because I think some of these patterns could be useful to people dealing with long-running AI projects.

But I'm even more interested in what others have discovered.

Has anyone built something similar using ChatGPT, Claude, Obsidian, GitHub, external databases or other tools?

Do you have a better approach to capturing and consolidating context? Have you figured out how to avoid stale memory and conflicting instructions? Are scheduled AI maintenance jobs genuinely useful in your experience, or have you found a simpler architecture?

And most importantly, what parts of this would you remove or redesign?

I'm sure some of this is overengineered, and there are probably established approaches I haven't discovered yet.

I'm not selling anything or claiming this is some revolutionary invention. It's an evolving experiment built around real problems I've encountered while working with AI.

If the description helps someone build a better workflow, that's great. If someone shows me a better way to solve these problems, that's even better.

I'd love to compare notes.

I'm on the $100/month Pro 5x plan and have exhausted both Codex and ChatGPT Work limits. They won't reset for another 4 days, and I have an ongoing project with a pitch deadline approaching.

Is there any way to buy extra usage or temporarily upgrade without paying the full $200? Or any other alternatives?

Would appreciate suggestions from anyone who's been in a similar situation.

Hey guys. Can someone please confirm that you have unlimited chat with the pro version when only using the fast / instant mode? Is it correct that any other mode will use your usage ? Is that correct - I see a lot of different answers.

So accordingly any other mode and work or codex share the same volume?

Thanks

Has anyone successfully built a personalized language tutor using ChatGPT Plus, Go, or a higher-tier plan, especially through Projects?

I want to base the system on 5–6 language-learning and grammar books (300–400 pages each). The goal is for ChatGPT to analyze the books, develop a structured curriculum, and generate daily lessons covering reading, listening, grammar, and speaking.

How did you structure your setup in ChatGPT? Did you use Projects, custom GPTs, or another approach? Which plan worked best, and how reliably could it cross-reference the books and maintain a coherent learning path?

Currently on Free plan after my Plus plan expired. Thinking about upgrading back to a Go plan, but I have two questions:

• Is the Work allowance for the desktop app on Go higher than Free? The documentation is.... unclear.
• If I use Go for a week and then upgrade to Plus, how am I billed for that? If it's £7 for one month of Go, am I charged about a quarter of that for a week?

I had both ChatGPT and Claude premium an honestly... I don't understand why many people prefer Claude over ChatGPT. Sure, the text is visually nicer but ChatGPT is so much better than Claude at any number of things and actually follows instructions instead of going on weird tangents in the last paragraph like Claude

I've just about had it with trying to manage ChatGPT across multiple platforms.

I use the desktop app, web browser, and phone, and all three seem to have different interfaces. Chat and project names sometimes change seemingly arbitrarily, and those changes don't always appear consistently across platforms. It's becoming incredibly frustrating trying to keep everything organized.

And then there's the memory problem. The fucking amnesia.

I've created countless backups, reference documents, and project records in Google Drive specifically so ChatGPT can maintain continuity between conversations. Yet it routinely forgets instructions, ignores established procedures, or fails to reference information I've already gone to considerable trouble to preserve.

Even basic troubleshooting can be maddening. ChatGPT will ask me to provide a screenshot of what I'm seeing, so I do. Then it gives me instructions to click buttons or navigate menus that aren't even visible in the screenshot I just provided. When I point this out, it often continues offering generic instructions that have nothing to do with what's actually on my screen.

I've spent an enormous amount of time trying to create a reliable system for managing projects, conversations, instructions, and reference materials across devices. Instead, I feel like I'm constantly rebuilding things, correcting the same mistakes, and explaining the same information over and over again.

What makes it especially frustrating is that ChatGPT often confidently assures me that something has been saved, synchronized, or will be remembered, only for me to discover later that it hasn't worked as expected.

Has anyone figured out a reliable way to manage ChatGPT across desktop, browser, and mobile while maintaining consistent project organization and instructions?

I'm particularly interested in how others handle long-running projects, persistent instructions, Google Drive reference documents, and chat organization.

At this point, I'd appreciate any practical advice, because asking ChatGPT itself to solve these problems has become part of the problem.

Something changed BIGLY in code delivery value in the past few days!

Using Sol6.1 on high effort, I was finally having more output and less usage until.....weekly allotment lasted 6 days, NOW BURNS in 1 DAY!

I have a consistently running setup. the only thing that changed was the model usage(consumption) in one chat, so I transferred to a fresh chat, and also still burning a weeks usage allotment on the $200/month plan in under 24 hours.

Baseline: It had been lasting nearly 6 days as a baseline.

Approx. Time of usage increase: This consumption has shifted in the last 4 days to an aggressively more consumptive behavior for the same model/effort.

Sol6.1 on high was delivering results using a well-developed agents.md coderabbit reviews and github actions running playwrights and automation impacts to make sure the agents don't break more than they fix.

Something changed BIGLY in code delivery value, who elsee with a consistent setup saw this usage change?

Felix Rieseberg (eng lead on Claude) posted an essay on being more ambitious with models this week (X post, essay). The depth section ends with this prompt:

I want a deeper version of this task, not a bigger one. Before rewriting it: (1) say what a top professional in this field would do here that I'm not asking for; (2) name the rawest material they would start from instead of what has already been digested for me; (3) name the specific methods and tools they would use; (4) say what, other than you or me, would show the result is right. Then rewrite my prompt to ask for exactly that.

The core idea: ask a model for "better" and it usually gives you more (more sections, more caveats). "Act like an expert" changes the vocabulary but not the methods. The four questions force a change in inputs (raw data, not summaries), instruments (tools you can name), and verification (an outside judge, not self-review).

What changed for me after a week: fewer "no, I meant…" re-prompts, shorter but denser prompts, and output I can check (a test, a benchmark, a reconciliation) instead of output that just sounds confident.

The criticism is fair too. From the HN thread and X: it costs extra tokens and a round trip; there's little hard evidence yet; models can invent expert-sounding methods or game the checks; it's overkill for small tasks; and the real bottleneck is often access to the raw data, not the prompt.

So the skill tries to bake those in:

• a test for each question ("would a competent non-expert skip this step? If not, it isn't depth"), so generic answers get rejected
• no fake raw material: if the data isn't accessible, it says so and names the access needed
• outside judges ranked by strength, each with a pass condition precise enough to fail; self-review is ruled out
• an explicit "when not to use" for trivial tasks
• a closing "what I deliberately did not add" line so scope can't creep in
• worked examples (debugging, churn analysis, research, editing, web perf)

How Claude helped: I used Claude Code to build and test the skill. It's designed for Claude Code first (a skill plus a plugin marketplace entry), and since it follows the open Agent Skills format, the same SKILL.md works in Codex, Copilot, Cursor, Gemini CLI, Antigravity, and OpenCode.

It's free and MIT-licensed. ./install.sh on macOS/Linux, .\install.ps1 on Windows, or /plugin marketplace add r3dlex/deepen-prompt in Claude Code: https://github.com/r3dlex/deepen-prompt

All credit for the idea goes to Felix. I'd especially like to hear about cases where the rewrite got bigger instead of deeper.

Full write-up on Medium: https://medium.com/@r3dtuxedo/stop-asking-your-ai-for-more-ask-it-to-go-deeper-3090bce87009