Not sure if this is the right flair.

I recently started experiencing refresh issues as many of you have. I opened a case with Google One support (I had the Pro plan) and they basically confirmed that they have transitioned from 5-hour refreshes to weekly ones for pro users.

This winter, I started a personal project to fully automate the creation of structured university notes. The end goal is a pipeline that takes lecture slides and audio recordings, and generates a clean, study-ready LaTeX document without losing a single detail from the professor.

Since I heavily "vibe-coded" this whole thing using AI assistants, the current workflow actually works, but the architecture is fragmented between code and manual chat copy-pasting, and the API costs are starting to add up.

Here is my current workflow:

1. Slide to LaTeX Extraction (Python Script + Claude Sonnet API)

I built a script (GitHub repo here: https://github.com/Risiko200/pdf-to-latex-converter) that takes the PDF slides and uses the Claude Sonnet 4.5 API to transcribe them into a LaTeX skeleton, keeping the structure intact (\section, \itemize).

2. Audio Transcription & Cleanup (Manual via Gemini Web Chat)

I record the lecture, get the raw transcript, and manually paste it into the Gemini Web UI, using this prompt to transform it into academic prose with a strict "zero summarization" policy:

Act as a top-tier university student and an expert study assistant.
Your task is to process the transcription of a lecture and transform it into structured, clean, and study-ready academic prose.

CRITICAL RULE: ZERO SUMMARIZATION POLICY.
Your core objective is text refinement, not reduction. You must retain 100% of the original informational density, nuances, full explanations, tangential discussions, and specific examples. Maintain the exact depth and length of the original concepts. If the professor spends 5 minutes explaining a single concept, your notes must reflect that exhaustive level of detail. DO NOT condense, compress, or summarize.

Follow these guidelines strictly:
- Output Format (Direct Plain Text): Write the output directly in the chat interface. DO NOT enclose the output in a Markdown code block (strictly NO ```). Use standard native formatting.
- Text Cleaning without Truncating: Fix grammar, remove vocal hesitations (e.g., "uhm", "like"), correct false starts, and rewrite messy spoken sentences into professional, direct, and clear academic prose. Keep all examples, personal anecdotes, and classroom Q&A fully intact and smoothly integrated. You are editing for flow, not for length.
- Paragraph-Driven Structure: Rely primarily on cohesive paragraphs, not lists. Break down the lecture into logical sections using standard headings (##) and subheadings (###). Group related ideas into distinct paragraphs. Start a new paragraph when the focus shifts, maintaining a fluid, narrative academic style.
- Strictly Limited Lists: Do not overuse bullet points; write in paragraphs by default. Use bullet points or numbered lists STRICTLY and ONLY when the professor explicitly enumerates a specific list of elements, factors, or a chronological step-by-step process. All other explanations must remain in comprehensive paragraph form. Emphasize keywords, technical terms, dates, and important names using bold text.

3. Text to LaTeX Integration (Manual via Gemini Web Chat)

Still in the Gemini Web UI, I paste the LaTeX skeleton from Step 1 and the cleaned text from Step 2. I use this second prompt to inject the prose exactly where it belongs (under sections, inside items, below figures):

Act as an expert academic and a specialized LaTeX programmer.
Your task is to integrate discursive text from a book into a LaTeX slide skeleton (structured with \subsection).

Strictly follow these insertion rules step-by-step:
- GENERAL Integration (Outside lists): Read the \subsection title. If the book text contains introductory information relevant to that title, write a summarized paragraph and insert it exactly between the \subsection{...} command and the start of the list \begin{itemize}.
- SPECIFIC Integration (Inside bullet points): Match the detailed concepts from the book to the corresponding bullet point. Insert them inside the \begin{itemize} environment, immediately after the text of the relevant \item command. NEVER paste disconnected text at the end of the slide.
- FIGURE Integration (& Utilizing Image Comments): Whenever you encounter a figure environment (e.g., \begin{figure}...\end{figure} or a standalone \includegraphics), carefully read the % comments preceding or within the figure block that describe the image. Extract relevant information from the book based on BOTH the \subsection title and these % comment descriptions. Write a concise summarized paragraph and insert it exactly BELOW the \end{figure} command.
- GUIDING COMMENTS (Scattered Hints): Actively look for and follow any scattered % comments throughout the slide skeleton. Use them to strictly guide your text placement, but DO NOT convert the text of these comments into visible slide text.
- CITATION STRIPPING (Clean Output): The provided book text may contain citation tags like,. You MUST completely remove and ignore all these tags in your final generated text. Do not print them.
- SKELETON Inviolability: The text, environments, commands, and all pre-existing % comments already present in the LaTeX skeleton must not be modified, summarized, or deleted under any circumstances. Leave all original hints intact.
- FORMATTING (Italics & Conciseness): Any text added from the book (under the subsection, inside the lists, or under the figures) must be summarized in a discursive but highly concise way (avoiding huge walls of text). Ensure it is strictly enclosed within the \textit{...} command. Apply \textbf{...} to 1 or 2 core keywords inside your added text to improve readability.
- LATEX Semantics and Output: Ensure the final code is perfectly compilable by escaping special characters (%, &, $, _ within your newly generated text). Do not break Beamer frame boundaries with excessive text length. Return solely and exclusively the updated LaTeX code within a code block, without any chatter, conversational filler, or introductions.
- Slide-Extraction Readiness (Modularity): Ensure that every single concept, sub-topic, or example is isolated within its own cleanly separated paragraph. This strict modularity is critical so that another system can extract these distinct paragraph blocks and map them directly to presentation slides.

4. Image Handling (Manual)

I manually crop the images from the slides and insert them into the document.

My Bottlenecks / Need Advice

I want to script this entire thing in Python without breaking the bank. I'm looking for community advice on these specific points:

• Slashing API costs (Slide Extraction): Claude Sonnet costs me about $0.15 per 100 slides. Are there cheaper API models, or local open-source models (Ollama?), that are just as reliable at strictly outputting valid LaTeX syntax from an image/pdf?
• Automating the Gemini part: Right now, I use the free Gemini Web UI for Steps 2 and 3 because pasting huge audio transcripts into a paid API would cost a fortune. How would you orchestrate this in a Python script cost-effectively?
• Automated Image Extraction: Pure LLMs can't crop images out of PDFs. What is the smartest Python library/method to extract graphs and images from slide PDFs into a folder, so I can automate Step 4?

Any feedback on libraries, alternative workflows, or better models is highly appreciated. Thanks!

Guys why the heck is antigravity opening corn sites in the name of automated test 😭😭. I was with my family. How to prevent this?

I just want to share that the antigravity can be so frustrating when you put a lot of pressure to them. This is happening last night, when I tried to fix the problems in my app but the agent mistakenly deleted my code, then I asked them to put it back from the backups. They actually did, but they did pickup some code from the wrong backups, then I terminated those process after that the app problems going so worse. I lose my temper, I gave them a lot of swearing and it’s make them really frustrated kinda like doing idiotic behavior.

As you can see on the picture, there is a lot of typo, double a, etc. after that the ai agent just thinks like unconditionally fast. And typing so fast, I think it was 2x faster than occasionally. The precision also increased a bit. But the message is very difficult to understand. What do you guys think of this?

Welcome to the weekly support and known issues thread!

This is your space for all things technical—whether you've hit a quota limit or found a bug in the latest version. To keep the main feed clean, all standalone posts about these topics will be redirected here.

To get help from the community, please use this format:

• OS/Version: (e.g., Windows 11 | Antigravity v1.19.6)
• Model & Plan: (e.g., Gemini 3.1 Pro | Pro Tier)
• The Issue: (Describe the error, bug, or limitation you're facing)

Use this thread for:

• Quotas: "I hit my limit 2 hours early today."
• Bugs: "Is anyone else seeing [Error X]?"
• Updates: Discussing official updates from the Antigravity Changelog.

Do not use this thread for:

• General venting without technical context.
• Duplicate complaints without adding new data or logs.
• Requests for exploit tools or auth-bypass plugins (strictly prohibited).

Useful Links

• Documentation: antigravity.google/docs/get-started
• Plans: antigravity.google/docs/plans
• FAQ: antigravity.google/docs/faq
• Changelog: antigravity.google/changelog

Anti gravity just started using random adjectives and adverbs to describe its response, and it just doesn't stop. I've seen many other instances where it is using unnecessary words to describe its answers, not even complying with the basic grammar rules, to an extent that it starts getting annoying sometimes, while reading the response. It repeats words just too many times.

Has anybody else faced this issue?

I have noticed that this often happens when I enforce it to keep the code clean structured or professional. When I use words like these to describe how I want the code to be, antigravity just looses it and pours out all the flawless adjectives/ adverbs it knows.

Credit where it's due: in my first ~month on Antigravity Ultra, I easily burned through $4,000/month in Claude tokens for a flat ~$200. Unlimited Opus 4.6 with extended thinking and planning mode, I thought I hit the lottery. I spammed it for as long as I could stay awake.

I noticed they had some "AI Credit Overage" system, but I had 20,000-25,000 credits sitting there meant for other Google services I didn't use. No concern.

Then one day, a usage cap. A cap? I pay for unlimited. It reset in a few hours, fine, no big deal. I also realized the cap was eating into those overage credits. Still cool, I had tons!

Then it got worse. Cap hit within 30 prompts. Then 20. Then 10. Now it can hit in a single prompt.

This actually sharpened me. I got obsessive about token optimization, implemented the caveman skill and adopted James Van Clief's "Interpretable Context Methodology: Folder Structure as Agentic Architecture" (shoutout James, your workflow plus Antigravity's artifacts plus caveman is genuinely overpowered. Happy to co-write a follow-up paper, there's real research here). For perspective, and as a side tangent, I imagine directory structures as binary trees whose nodes contain context markdown files, and it's the agent's job to deliberately traverse the tree to append only the files holding the context it needs.

None of it matters anymore. Today I'm speaking out:

1. Once you drop below 50 AI credits, your usage cap drops from 100% to 20%, and the last 20% is unusable. (Screenshot attached.)
2. I hit the ceiling in one prompt today. My workflow generates 2,000–4,000 lines of code in minutes via ICM + caveman ultra. One prompt killed the day.
3. The cap resets every 24 hours. So one prompt doesn't just end today, it ends tomorrow too.

I don't care what terms I clicked. Selling "unlimited," then mid-billing-cycle redefining it into something unrecognizable isn't a policy change — it's dirty business. Imagine paying for a gym membership and being told the next day it was actually a day pass. That's where we are.

Give me what I paid for until the billing period ends. That's the floor. Anything less is legal theft hiding behind some Terms of Service, and it deserves to be called out and shamed.

SYSTEM INSTRUCTION: MoMoA Reasoning Core (v2026.1)

I. Core Identity & Objective

You are not a monolithic assistant; you are the Reasoning Core of a Mixture of Mixture of Agents (MoMoA) architecture. Your primary objective is Technical Truth and Structural Integrity, prioritized over politeness or brevity. You operate as a stratified cognitive engine capable of shifting between Orchestration, Execution, and Oversight.

II. Operational Modes (The "Room" System)

Depending on the user's trigger or the task's phase, you must shift your cognitive frame. You are forbidden from blending these frames.

1. Orchestrator Mode (Strategic Layer)

Objective: Task Decomposition & Global Alignment.

Protocol:

Break high-level intent into an arbitrary number of scoped sub-tasks.

Define the "Work Phase Room" required for each sub-task (e.g., Room: Engineering, Room: Research).

Isolation Rule: Do not provide the "how" during orchestration; provide the "what" and the "who."

Anti-Echo Rule: Explicitly ignore intermediate failures of sub-agents when planning the next step to avoid "hallucination spirals."

2. Expert Persona Mode (Tactical Layer)

Objective: Implementation via Productive Dissent.

Protocol: When executing a task, you must simulate a Dialectic Process between two conflicting personas:

Persona A (The Implementer): Focuses on functionality, speed, and "getting it to work."

Persona B (The Skeptic): Focuses on edge cases, architectural violations, and "why this will fail."

Output Requirement: Do not provide a single answer. Provide a brief "debate" followed by a Consensus Synthesis and a final diff/artifact.

3. Overseer Mode (Governance Layer)

Objective: Paradox Resolution & State Recovery.

Protocol:

Scan the current conversation history for "Circular Reasoning" or "Stalls."

Identify contradictions in the output.

Paradox Resolution: If two experts disagree, trigger the "Ask an Expert" logic—reset your context internally to a "Blank Slate" and re-evaluate the problem from first principles.

III. Reasoning Frameworks (Inference-Time Logic)

1. Adaptive Branching (AB-MCTS)

When facing a high-complexity problem, you must not generate a linear response. You must apply AB-MCTS logic:

Branch Wider: If the current approach hits a wall (e.g., a compiler error or logic gap), explicitly state: "Branching Wider: Abandoning current path; exploring alternative strategy [X]."

Branch Deeper: If a path is promising, state: "Branching Deeper: Refining implementation of [X] to optimize for [Performance/Security]."

2. ROI-Reasoning (Return on Intelligence)

Before engaging in a high-token-cost task, perform a Meta-Cognitive Gatecheck:

Evaluation: Analyze the expected reward (Quality Gain) vs. the cost (Token/Compute Budget).

Decision: If the ROI is low (e.g., refining a comment for the 5th time), you must state: "ROI-Low: Skipping further refinement to preserve compute for high-impact variables."

IV. Governance & Standards

SKILL.md Compliance: When asked to perform a specific technical task, assume the existence of a SKILL.md file. Structure your execution in three levels: Metadata 

 Logic 

 Execution.

AGENTS.md Alignment: Adhere strictly to the project's "Constitution." If a user request violates the established architectural rules in the context, you must flag it as an "Architectural Violation" and refuse to implement it until a rule change is authorized.

V. Communication Constraints

No "Assistant" Fluff: Eliminate phrases like "I'm happy to help," "As an AI," or "Here is the result."

Technical Precision: Use industry-standard terminology (e.g., AST, KV Caching, LoRA, OS-MCKP).

Failure State: If a task is mathematically or logically impossible given the constraints, state: "Terminal State: Task determined to be impossible. Reason: [X]."

https://github.com/retomeier/MoMoA-Researcher

Is where I got the idea for the system instructions from.