New VERY Conservative Limits:

AI Debug Retries: Maximum 1 attempt (down from 2)
Code Regeneration: Maximum 1 attempt per scene
Total per scene: 1 AI fix + 1 code regen = 2 total attempts maximum
Immediate Skip Logic:
✅ Quick exit checks at the start of error handling
✅ Immediate skip if AI debugger fails
✅ Clear "SKIPPING" messages so users know what's happening
✅ User notification in Gradio that scenes get max 2 attempts

app.py

@@ -160,6 +160,7 @@ class GradioVideoEngine:
             
             # Step 4: Render scenes
             self.log_message("🎨 Step 4/5: Rendering video scenes...")
+            self.log_message("ℹ️ Note: Each scene gets max 2 attempts to avoid excessive costs")
             progress(0.8, desc="Rendering video scenes...")
             self.engine.step_4_render_scenes()
             self.log_message("✅ Scene rendering completed")

src/rendering/scene_renderer.py

@@ -116,18 +116,25 @@ def render_and_combine_scene(project_config: dict, scene_name: str, code_file: s
     except subprocess.CalledProcessError as e:
         logger.error_with_context(f"Manim subprocess failed for {scene_name}", f"Code: {e.returncode}")
         
+        # Quick exit - if we've already tried a lot, just skip
+        if retry_count >= max_retries or regen_count >= max_regens:
+            logger.quick_log("error", f"Scene {scene_name} failed - SKIPPING to save time/money")
+            logger.end_operation(operation_id, f"Rendering {scene_name} SKIPPED")
+            return None
+        
         if "error" in e.stderr.lower() and retry_count < max_retries:
             # Try AI debugging first (up to max_retries times)
-            logger.quick_log("info", "Attempting AI auto-debug")
+            logger.quick_log("info", f"Attempting AI auto-debug ({retry_count + 1}/{max_retries})")
             if debugger.debug_and_fix(code_file, e.stderr, scene_name):
                 logger.quick_log("success", "AI fix applied, retrying")
                 return render_and_combine_scene(project_config, scene_name, code_file, manim_executable, renders_cache, debugger, retry_count + 1, max_retries, regen_count, max_regens)
             else:
-                logger.quick_log("error", "AI debugger could not fix issue")
+                logger.quick_log("error", "AI debugger could not fix issue - SKIPPING")
+                return None
         
         # If AI debugging failed or we've reached max retries, try code regeneration ONCE
         if retry_count >= max_retries and regen_count < max_regens:
-            logger.quick_log("info", f"Max AI retries reached, attempting code regeneration ({regen_count + 1}/{max_regens})")
+            logger.quick_log("info", f"Trying code regeneration - LAST ATTEMPT")
             from src.generation.code_generator import regenerate_single_scene_code
             
             # Get the gemini client from the environment
@@ -141,19 +148,17 @@ def render_and_combine_scene(project_config: dict, scene_name: str, code_file: s
                     temp_dir = Path(code_file).parent
                     
                     if regenerate_single_scene_code(project_config, gemini_client, str(temp_dir), scene_name):
-                        logger.quick_log("success", "Code regenerated, final attempt")
+                        logger.quick_log("success", "Code regenerated - FINAL ATTEMPT")
                         new_code_file = project_config["scenes"][scene_name]["code_file"]
                         return render_and_combine_scene(project_config, scene_name, new_code_file, manim_executable, renders_cache, debugger, 0, max_retries, regen_count + 1, max_regens)
                     else:
-                        logger.quick_log("error", "Code regeneration failed")
+                        logger.quick_log("error", "Code regeneration failed - SKIPPING")
+                        return None
                 except Exception as regen_e:
-                    logger.error_with_context("Code regeneration error", str(regen_e))
-        
-        # If we've exhausted all retries AND regenerations, give up
-        if retry_count >= max_retries and regen_count >= max_regens:
-            logger.quick_log("error", f"All retry and regeneration attempts exhausted for {scene_name}")
+                    logger.error_with_context("Code regeneration error - SKIPPING", str(regen_e))
+                    return None
         
-        logger.end_operation(operation_id, f"Rendering {scene_name} failed")
+        logger.end_operation(operation_id, f"Rendering {scene_name} failed - SKIPPED")
         return None
     except Exception as e:
         logger.error_with_context(f"Unexpected rendering error for {scene_name}", str(e))
@@ -198,7 +203,7 @@ def render_scenes(project_config: dict, manim_executable: str, renders_cache: Pa
         try:
             video_path = render_and_combine_scene(
                 project_config, scene_name, scene_data.get("code_file"), 
-                manim_executable, renders_cache, debugger, 0, 2, 0, 1  # 2 AI retries, 1 code regeneration max
+                manim_executable, renders_cache, debugger, 0, 1, 0, 1  # VERY CONSERVATIVE: 1 AI retry, 1 code regen max
             )
             if video_path and Path(video_path).exists():
                 project_config["scenes"][scene_name]["final_video_path"] = str(video_path)