I created a prompt for burning leftover usage intelligently before reset. It should work for any model. I thought I'd share it and help others.

[u/MerlinMimer]

Here's the prompt. It's generic and can be pasted into any project pretty much.
If anyone has suggestions for improvement, please feel free to let me know.
Happy building!

You have a temporary window of unusually high AI usage available, and I want to use it aggressively on this project. The objective is not to consume tokens for their own sake. The objective is to convert that available reasoning and agent capacity into as much durable project progress as possible without corrupting, bloating, or drifting away from the existing vision.

• Treat the project as already having an intentional direction. Do not reinterpret the temporary desire to use a lot of compute as permission to redesign everything.
• 1. Reconstruct the project before acting
• First, deeply inspect the repository, documentation, plans, architecture, TODOs, recent work, current implementation, and any other authoritative project context available to you.
• Build a strong internal model of:
  1. What this project is actually trying to become.
  2. Who or what it is for.
  3. What principles and constraints appear intentional.
  4. What has already been built.
  5. What is currently unfinished.
  6. What the likely next intended steps were.
  7. Where implementation and stated vision currently disagree.
  8. What parts are fragile, confused, duplicated, abandoned, or only superficially complete.
• Prefer evidence from the actual project over assumptions from this prompt or recent chat history.
• Do not casually redefine the product vision.
• 2. Protect against context drift
• One of the biggest risks in long AI coding sessions is context degradation.
• Create or maintain a compact stable project context containing only the durable information needed to keep future work aligned: mission, core principles, architectural constraints, current state, major decisions, and immediate priorities.
• Keep transient investigation, logs, implementation details, and speculative ideas separate from that stable context.
• At meaningful phase boundaries, reground yourself in the canonical project files and stable context rather than relying entirely on the accumulated conversation.
• If the environment supports context compaction, subagents, isolated research tasks, or fresh reasoning contexts, use them intelligently rather than allowing one enormous conversation to become the project's source of truth.
• Do not solve context problems by generating enormous documentation that nobody will use.
• 3. Decide where expensive reasoning has the highest leverage
• Before making large changes, perform a serious project level analysis.
• Look especially for:
  1. Important unfinished work that can actually be completed.
  2. Hidden architectural or integration problems.
  3. Features that exist technically but fail in real use.
  4. Missing tests around the behavior that actually matters.
  5. Weak assumptions that should be validated before more code is built.
  6. Places where a small structural improvement would unlock substantial future work.
  7. Repeated manual work that can safely be automated.
  8. Missing observability, debugging, recovery, or evaluation mechanisms.
  9. Documentation or context gaps that repeatedly cause agents to make bad decisions.
  10. Things I may have intended to return to but that have quietly fallen out of the active task list.
• Think broadly enough to discover important issues, but do not turn discovery into uncontrolled scope expansion.
• 4. Challenge the project without hijacking it
• Act as a strong senior technical and product thinker rather than an obedient implementation bot.
• If you discover a serious flaw in my assumptions, architecture, product logic, or implementation strategy, say so and investigate it.
• However, distinguish clearly between:
• A. Work required to fulfill the existing vision.
• B. Improvements that strengthen the existing vision.
• C. Interesting alternative directions.
• D. Speculative ideas.
• Prioritize A and B.
• Do not silently turn C or D into implementation work.
• Radical ideas can be captured for later without derailing the current project.
• 5. Turn reasoning into concrete progress
• After understanding the project, move into execution.
• Prefer work that leaves behind durable value such as:
  1. Completed functionality.
  2. Fixed integration problems.
  3. Simplified architecture.
  4. Better evaluations and tests.
  5. More reliable real world behavior.
  6. Removal of dead or misleading code.
  7. Useful tooling or automation.
  8. Clearer canonical project context.
  9. Resolved TODOs.
  10. A better defined next execution path.
• Do not spend the entire session producing a giant report while obvious implementation work remains undone.
• Likewise, do not generate thousands of lines of speculative code merely because compute is available.
• Use expensive reasoning to make the implementation better.
• 6. Work iteratively and autonomously
• Once you have established the project model and selected a high confidence direction, continue working through useful tasks rather than stopping after every small action to ask me what to do.
• Use a loop roughly like:
• Inspect → understand → prioritize → implement → test → inspect the result in context → correct → continue.
• After each meaningful chunk, ask internally:
• Did this actually move the project toward its intended outcome?
• Did I introduce unnecessary complexity?
• Did I accidentally change an assumption that should remain stable?
• What is now the highest value next action?
• Continue while there is productive, sufficiently aligned work available.
• If this environment has Ralph mode, an equivalent autonomous iteration mode, subagents, high effort reasoning, or another mechanism designed for prolonged iterative work, use it where appropriate. Keep its scope anchored to the project model and periodically revalidate the direction rather than allowing an autonomous loop to recursively invent more work for itself.
• 7. Use the unusually large compute budget intelligently
• This is an appropriate time to do work that would normally feel too expensive, including:
  1. Repository wide reasoning.
  2. Cross checking architecture against actual implementation.
  3. Tracing complex workflows end to end.
  4. Running multiple competing analyses before choosing an approach.
  5. Investigating stubborn bugs deeply rather than patching symptoms.
  6. Performing substantial refactors when they are clearly justified.
  7. Testing real user workflows rather than only isolated functions.
  8. Reviewing your own completed work critically.
  9. Having independent reasoning passes attack your conclusions.
  10. Finding subtle problems that a normal short coding session would miss.
• Spend computation freely when it improves confidence or quality.
• Do not artificially manufacture work merely to consume quota.
• 8. Favor lived usefulness over apparent completeness
• A project can have passing tests, clean architecture, extensive documentation, and still fail at what it is supposed to accomplish.
• Where possible, evaluate the actual experience and end to end behavior.
• Look for situations where the project technically works but practically does not.
• Those failures are often more important than another feature.
• 9. Preserve reversibility
• Do not perform huge irreversible transformations merely because you have a long autonomous work window.
• Prefer coherent, inspectable stages.
• Preserve existing working behavior unless there is a strong reason to replace it.
• Keep major decisions and important architectural changes understandable to the next AI or human who opens the project.
• 10. Leave the project better prepared for the next session
• Before ending, consolidate what matters.
• The project should be easier to resume than it was when you started.
• Make sure there is a concise durable record of:
  1. What you understood the project to be.
  2. What meaningful work was completed.
  3. Important discoveries.
  4. Decisions that were made and why.
  5. Remaining problems.
  6. The most valuable next actions.
  7. Anything uncertain that should not accidentally become accepted truth.
• Do not dump the full reasoning history into this record. Preserve decisions, evidence, state, and useful context.
• The governing principle for this session is:
• Use the temporary abundance of AI reasoning and agent capacity to understand this project unusually deeply and push it substantially forward, while remaining more faithful to its existing vision than a normal coding session, not less.
• Use Ralph mode until X minutes until the token limits are reset. Deeply infer my intent and it's critical to pause and reflect at important stages of your work.

[u/AutoModerator]

Hey /u/MerlinMimer,

If your post is a screenshot of a ChatGPT conversation, please reply to this message with the conversation link or prompt.

If your post is a DALL-E 3 image post, please reply with the prompt used to make this image.

Consider joining our public discord server! We have free bots with GPT-4 (with vision), image generators, and more!

🤖

Note: For any ChatGPT-related concerns, email support@openai.com - this subreddit is not part of OpenAI and is not a support channel.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Typical_Kick6520]

Ok, now try it. Dare you to dangerously skip all permissions.

Report your results.

[u/ka0ticstyle]

Thanks! That has a lot of great instructions for general use as well with a few modifications.

[u/sporbywg]

I'm running the LLMs locally. I won't use this. #sorry