Video summary

Never Hit GPT 6 Astra Usage Limits Again

Main summary

Key takeaways

Technology

Key technological ideas + product usage optimizations (Astra/Codex)

The speaker focuses on reducing “Codex” usage so it doesn’t hit rate/usage limits. They argue that many older token-saving tricks no longer work after GPT-6 Astra changes.

Core premise: Astra can manage usage limits (newer prompting-based approach)

  • Context/token optimization tips from older models no longer apply to GPT-6 Astra.
  • Astra’s behavior can be tuned for budgeting and efficiency because it can see its own usage limits.
  • Catch/reset behavior and conversation handling changed, including:
    • an extended catch reset interval
    • Astra not rereading the entire chat history like before

“11 things I changed” to avoid usage limits

  1. Rule 1: Give Astra a usage budget

    • Prompting approach: “complete this within X% of my weekly limit.”
    • Claimed result: repeatable workflows (emails, script drafting) reduce token usage ~80–90%.
    • Example: a business workflow went from 4% allowance to producing ~300 products vs ~25 previously (via Astra’s workflow optimization).

  2. Rule 2: Delegate with cheaper sub-agents

    • Astra can delegate to parallel sub-agents (sub-agent orchestration is expected/optimized).
    • Example: use Luna Max sub-agents (claimed ~98% lower token rates than Astra; also described as “80% cheaper” in the mention).
    • Strategy: break work into narrow steps (triage → draft → review), then let Astra do complex review at the end.

  3. Rule 3: Use cron / early ping on the $20 plan

    • Schedule a tiny ping at a specific time so the reset window starts earlier (e.g., before you sit down to work).

  4. Rule 4: Turn repeated work into reusable “skills”

    • Save successful workflows as skills so future runs don’t relearn from scratch.
    • Claimed behavior: Codex reads only the skill name + one-line description initially; it loads full instructions only if needed.

  5. Rule 5: Save preferences/instructions once

    • Store global instructions in settings → personalization → custom instructions.
    • Terminal users: update personal agent.md.
    • Project-specific needs: Codex can write/update agent.md in the project.
    • Maintenance: ask Codex monthly to review agent.md/skills for duplication or outdated content.
    • Caution: saved instructions still consume context—keep them short.

  6. Rule 6: Steer corrections mid-run

    • settings → general → follow up behavior → choose “steer.”
    • Corrections apply during the current run rather than waiting for the next queued step.
    • Note: doesn’t refund already-spent tokens, but avoids further wasted computation.

  7. Rule 7: Turn off unused features/tools/plugins

    • Usage is influenced by factors such as: model choice, context, reasoning, tools, retrieval, catching, etc.
    • Strategy: disable plugins you forget to turn off.
    • Mention: image generation shares the chat’s token pool but burns limits 3–5× faster.
    • Diagnostic: run /status in a fresh chat to see context usage and rate limits; disable features one by one.

  8. Rule 8: Shorten tool-call reports

    • Each tool call returns a report that Astra reads before proceeding.
    • Problem: tool outputs can be long by default (e.g., analyzing 200 files returns details for all 200).
    • Fix: instruct Astra to return short “it worked” messages, with details only on failure.
    • Claimed test: about 6% fewer tokens across six comparisons.

  9. Rule 9: Stop “essays” / reduce output length

    • Output tokens drive usage (English token ≈ ~3/4 of a word).
    • Instruction: respond with the minimal length possible for the task.
    • Provide examples/skills to enforce concise style (e.g., “caveman” or “I have ADHD” prompt/skills).
    • If more is needed, ask explicitly later.

  10. Rule 10: Don’t make Astra search for where the bug is

    • Instead of “debug my website,” provide:
      • which page
      • what happens on click
      • expected behavior
      • relevant file path
    • Claimed test: correct file path yields about 23% fewer total tokens.
    • If needed, use an agent/code-map approach to create a skill for future bug hunts.

  11. Rule 11: Maintain a progress/record file

    • For long tasks, have Astra write a short progress file: completed items, file locations, failures, and next steps.
    • Purpose: avoid redoing work after crashes or interruptions.

Live demo result (vanilla vs enhanced workflow)

  • Task: fix non-working buttons on a small dashboard site (vanilla buttons for background-changing).
  • Vanilla Codex run: broad behavior (no specific location hints, no sub-agents, no plugin changes).
  • Enhanced Codex run: uses:
    • specific file/component targeting
    • a usage budget
    • delegation to Luna Max sub-agents
    • disabled unnecessary plugins
    • constrained response style (caveman-style)
  • Outcome claim: ~33.3% token savings
  • Note: the presenter says the difference is smaller for this small debugging task; larger tasks should yield bigger gains.

Main speakers/sources

  • Speaker: Duby (creator/builds apps with Codex; mentions generating $50,000 in 80 days).
  • Source referenced: OpenAI documentation (used to support the claim that Astra exhibits optimizable behavior patterns via prompting).

Original video