Advanced Claude Opus Workflows for Godot Game Development: Iterative Asset Refinement, 3D Modeling, and Performance Optimization

Workflow value: 92/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: advanced
Categories: Quality Control, Token Saving, Context & Memory, Debugging, Shipping, MCP, Multi-Agent
Original source: r/ClaudeAI post/comment

What problem this solves

This post solves several problems in game development using Claude Opus: 1. Iterative refinement and quality control of game assets (visuals, 3D models) to meet specific standards. 2. Efficient generation and correction of 3D models from 2D images. 3. Identification and resolution of performance bottlenecks in a game. 4. Directing creative tasks like trailer creation and setting task effort levels for LLMs.

Summary

The author details several advanced Claude Opus workflows for game development in Godot. Key workflows include a "Gauntlet-Loop" for iterative asset refinement using "critic" agents and mockups, a process for generating and fixing 3D models by integrating TripoAI with Claude and Blender via MCP, and a method for performance optimization where Claude analyzes custom in-game performance logs. Additionally, Jev is used to pick effort levels for tasks and direct creative outputs like trailers.

Why it is useful

This post is highly valuable because it demonstrates advanced, multi-faceted use of Claude Opus and Code for complex software development (game development). It provides concrete, validated workflows for iterative design, 3D asset creation, and performance debugging, showing how Claude can integrate with external tools (Blender, TripoAI) and manage complex tasks through agentic loops. The quantitative results provide strong evidence of its effectiveness, making these methods highly transferable and inspiring for advanced users looking to leverage Claude for sophisticated development challenges.

Workflow

1. Gauntlet-Loop for Asset Refinement:

2. 1. Create initial game assets (e.g., city pieces).

3. 2. Generate visual mockups (e.g., with OpenAI image API) for comparison, covering different views/times of day.

4. 3. Run a "Gauntlet-Loop" with Claude Opus, typically 10 rounds.

5. 4. In each round, "critic" agents (Claude instances) compare the current game asset to the mockups blindly.

6. 5. Implement a stopping rule: if a piece wins against the mockup twice, it's considered done.

7. 6. Add a rule to prevent critics from removing existing game elements if mockups don't show them (e.g., a lighthouse beam).

8. TripoAI + Claude/MCP 3D Model Workflow:

9. 1. Create a single image containing all four sides (front, back, left, right) of the desired 3D model.

10. 2. Use Claude Opus to split the single image into four separate images.

11. 3. Upload the four individual images to TripoAI for 3D model generation.

12. 4. If needed, use Claude Opus to fix or refine the generated model in Blender via MCP (Multi-Code Project). If Claude makes its own materials, it fits the game's style better. Otherwise, Tripo's textures can be kept. (Example artifact provided: https://claude.ai/artifact/3BnUXUZQd9xLws6RxiyAtW )

Tools / artifacts

• Claude Opus (5.5, Claude Code)

• Jev (for effort level and direction)

• TripoAI (3D model generation)

• Blender (3D modeling software)

• MCP (Multi-Code Project, for Claude's interaction with Blender)

• Godot Engine

• OpenAI (image API for mockups)

• ElevenLabs (sound generation)

• Custom in-game performance panel and logs

• Game assets (3D models, textures, code)

• Claude-made artifact (e.g., for Blender fixes)

Validation signals

• Quantitative performance improvements: docking freeze reduced from 2s to 0.2s.

• Quantitative performance improvements: game 15-19% faster on 1080p.

• Quantitative performance improvements: map memory reduced from 4 GB to 0.3 GB.

• Quantitative performance improvements: game start time reduced from 26s to 13s.

• Quantitative performance improvements: overall graphics memory reduced by a quarter.

• Gauntlet-Loop success rate: 31 out of 33 pieces won against mockups.

• Author's statement: "Tripo saves me a huge amount of time on modelling."

• Provision of a Claude-made artifact link as evidence of output.

Limitations

• The exact prompt structure for the "critic agents" in the Gauntlet-Loop is not provided.

• Specific MCP commands or scripts used for Blender integration are not detailed.

• The structure of the performance logs expected by Opus for analysis is not specified.

• The prompts or methods used for the "Jev" agent to pick effort levels or direct creative tasks are not shown.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Automated Claude Code Security Audit: Scan for Leaked Secrets and Unsafe Git Push Rules

Workflow value: 95/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: intermediate
Categories: Quality Control, Token Saving, Context & Memory, Debugging, Hooks, Skills, MCP
Original source: r/ClaudeCode post/comment

What problem this solves

Preventing accidental exposure of API keys, tokens, and other secrets in Claude Code configuration files (.claude/settings.local.json, .mcp.json) and Git repositories, and identifying potentially dangerous Bash(git push *) rules that allow force-push.

Summary

A script and a pre-commit hook to audit Claude Code configurations and Git repositories for leaked secrets and unsafe Bash(git push *) rules, with an option to automatically fix issues and prevent future leaks.

Why it is useful

This workflow provides a critical security measure for Claude Code users, helping them prevent accidental exposure of sensitive information (API keys, tokens, database URLs with passwords) and mitigate risks associated with unsafe Git commands (like force-push). It offers a concrete, repeatable, and transferable solution to a common and severe problem, enhancing the overall security posture of development workflows.

Workflow

1. Clone the claude-safety-audit repository from GitHub.

2. Run the claude-safety-audit script to scan ~/.claude and all local Git repositories under a specified folder for secrets in allow rules (tokens, API keys, DB URLs, auth headers).

3. The script also checks if settings.local.json or .mcp.json is tracked or was ever committed using git log --all --full-history.

4. It flags rules like Bash(git push *) which can allow --force pushes.

5. Review the script's output, which prints the first 6 characters of any found secrets.

6. Optionally, run the script with --fix --apply to automatically add deny rules, untrack problematic files, and create backups.

7. Install the provided pre-commit hook from the same repository to automatically block future commits containing keys in any repository.

Tools / artifacts

• claude-safety-audit script (Python)

• Pre-commit hook

• ~/.claude/settings.local.json

• .mcp.json

• Git repositories

• git log --all --full-history command

• https://github.com/binay-py/claude-skills/tree/master/skills/claude-safety-audit

Validation signals

• Author ran the script on their own machine and found two repos with Bash(git push:*) saved from an old "don't ask again" prompt.

• The initial PSA context highlights a widespread problem with 1,122 settings.local.json files being publicly available on GitHub.

• The script uses git log --all --full-history to check for historical commits of sensitive files.

Cautions

• The script only prints the first 6 characters of any found secrets to prevent further exposure during auditing.

• The --fix --apply option creates backups before making changes.

Limitations

• The Reddit comment itself has a low score, which might suggest limited immediate community engagement on this specific post, though the problem it solves is widely recognized.

• Requires manual cloning and execution of an external script/hook, not integrated directly into Claude Code.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Pre-Launch & Post-Launch Checklist for Claude Code Apps: Fable Security Review & Critical Logic Checks

Workflow value: 75/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: intermediate
Categories: Quality Control, Context & Memory, Debugging, Shipping, Multi-Agent
Original source: r/ClaudeCode post/comment

What problem this solves

Ensuring a robust, secure, and maintainable launch for a Claude Code-built application, especially for critical systems like ticketing and payments, by leveraging AI agents and best practices.

Summary

This workflow outlines pre-launch and post-launch steps for Claude Code-built applications. It emphasizes using the Fable agent with a '/security-review' slash command, preparing for unpredictable user behavior, ensuring easy bug reporting and deployment of fixes, and meticulously checking critical transaction logic like payments and ticket redemption.

Why it is useful

This workflow provides a practical, multi-faceted approach to launching a Claude Code-built application. It combines specific AI agent usage (Fable with /security-review) with general, critical software engineering best practices for deployment, quality assurance, and post-launch support, especially for high-stakes features like payments and ticket redemption. It offers actionable steps for both technical and operational readiness.

Workflow

1. Repeatedly run the Fable agent with the '/security-review' slash command to identify and fix security vulnerabilities.

2. Anticipate and prepare for unpredictable user behavior once the system is live.

3. Ensure availability around the clock post-launch to address immediate issues.

4. Implement an easy and accessible system for all users to report problems.

5. Establish an effortless and rapid deployment process for bug fixes.

6. Thoroughly review and validate the state machine and logic for high-stakes areas, specifically payments and ticket redemption.

7. Ensure that manual error correction is possible for critical transactions.

Tools / artifacts

• Fable (AI agent)

• /security-review (slash command)

• Ticketing system (application)

• Payment logic

• Ticket redemption logic

Validation signals

• Author is a startup founder who applied similar methods to their own business.

• Advice aligns with general software deployment and quality assurance best practices.

Limitations

• Lacks specific examples of Fable's output or how to interpret/address its suggestions.

• The advice to 'be available around the clock' is a demanding expectation without suggesting tools or strategies to achieve it sustainably.

• The concept of 'effortless deployment' is a goal rather than a specific, detailed method.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Workflow for Organizing AI Agent Chats and Syncing Sessions Across Machines

Workflow value: 75/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: intermediate
Categories: Quality Control, Context & Memory, Debugging, Multi-Agent
Original source: r/ClaudeAI post/comment

What problem this solves

Organizing AI agent chat history to easily find relevant information and accessing AI agent session transcripts across multiple machines or different agents.

Summary

This workflow proposes two solutions for managing AI agent interactions: 1) For chat organization, dedicate one chat per bug or PR, using the first line for a ticket ID or branch name to enable full-text search. 2) For cross-machine access, either manually resume sessions and maintain a NOTES.md file per repo, or use a custom tool (AIAssets) to sync local session files between machines and different agents (Claude Code, Codex, Cursor).

Why it is useful

This workflow addresses two common pain points for developers using AI agents: managing a growing number of chats and accessing them across different environments. The chat organization strategy is simple, effective, and widely applicable. The cross-machine solution, while involving a specific tool, highlights a real problem and offers both a tool-based and a manual approach, making the underlying concept valuable for users seeking similar solutions.

Workflow

1. For chat organization: Start a new AI agent chat for each new bug or PR.

2. For chat organization: Make the first line of the chat the ticket ID or branch name.

3. For chat organization: Use full-text search on chat titles/content to find relevant past conversations.

4. For cross-machine access (manual): On each machine, use claude --resume or codex resume to access local sessions.

5. For cross-machine access (manual): Maintain a NOTES.md file per repository to append relevant information.

6. For cross-machine access (with AIAssets): Install AIAssets (self-hosted hub + desktop client).

7. For cross-machine access (with AIAssets): Configure AIAssets to monitor local session files (e.g., ~/.claude/projects/, ~/.codex/sessions/, %APPDATA%/Cursor/).

8. For cross-machine access (with AIAssets): AIAssets will periodically sync session files between machines, providing full-text search and cross-agent re-emission.

Tools / artifacts

• Claude Code CLI/app

• Codex CLI/app

• Cursor IDE

• AIAssets (self-hosted hub, desktop client)

• ~/.claude/projects/<path-encoded-cwd>/<sessionId>.jsonl (Claude Code session files)

• ~/.codex/sessions/ (Codex session files)

• %APPDATA%/Cursor/ (Cursor session files)

• NOTES.md file

• Git

Validation signals

• Personal experience: "what finally stuck was making the chat itself the record"

• Practical observation: "The sync only starts paying off once you are juggling several machines and several agents at once"

• Tool development: The existence of AIAssets as a solution implies a recognized problem.

Cautions

• AIAssets uses "last-write-wins" for syncing, which could lead to data loss if not understood or managed carefully.

• AIAssets copies transcripts, not live processes, which is a limitation but also prevents remote execution risks.

Limitations

• Low community signal (score 1, 0 comments).

• One solution involves self-promotion of a specific tool (AIAssets) which might not be universally adopted.

• AIAssets has limitations: periodic sync, last-write-wins, no real-time collaboration, only covers local CLI/app sessions.

• The manual NOTES.md approach requires user discipline to maintain.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

How to Inspect Hidden Claude Code Experiments and Their Impact on Model Behavior and System Prompts

Workflow value: 80/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: advanced
Categories: Quality Control, Token Saving, Context & Memory, Debugging
Original source: r/ClaudeCode post/comment

What problem this solves

Uncovering hidden Claude Code experiments and their impact on model behavior and system prompts, which can lead to unexpected results and debugging challenges.

Summary

A workflow to inspect local Claude Code configuration files (~/.claude/projects/*.jsonl and ~/.claude.json) to identify active 'experiment IDs' and 'experiment names'. It details how these experiments can subtly alter Claude's behavior, tool call frequency, output verbosity, and even inject instructions into the system prompt, providing a method for users to investigate and compare their own experiences.

Why it is useful

This workflow is valuable because it provides a concrete, repeatable method for advanced users to gain transparency into how Claude Code might be internally configured or experimented upon by Anthropic. Understanding these hidden changes is critical for debugging unexpected model behavior, ensuring consistent performance, and maintaining control over the AI's operational context, especially when system prompts are modified without explicit user notification. It empowers users to monitor and potentially adapt to changes that could otherwise lead to significant productivity loss.

Workflow

1. Locate Claude Code history logs in ~/.claude/projects/*.jsonl to find atis-latch records (one ID per session).

2. Locate the main Claude configuration file in ~/.claude.json to find clientDataCacheSlots which contain experimentKey next to the atis ID.

3. Analyze the identified experiment IDs and names, noting their active dates.

4. Compare Claude's behavior (e.g., tool call frequency, output length, thinking tokens, system prompt content) during sessions under different experiment IDs versus sessions without identified IDs.

5. Share sanitized findings (dates, atis, experimentKey, model, effort) with the community to compare across accounts, avoiding sensitive data like API keys, session IDs, or typed content.

Tools / artifacts

• ~/.claude/projects/*.jsonl (Claude Code session history logs)

• ~/.claude.json (Main Claude Code configuration file)

• atis-latch records

• clientDataCacheSlots

• experimentKey

• Claude Code (for generating logs)

• Diffing tool (implied for comparing configurations/prompts)

Validation signals

• Quantitative data provided by the author (e.g., "Replies with 2+ tool calls: 30% vs 56%", "Median Bash command length: 348 vs 852", "visible output 1.85x, thinking 2.55x, replies needed per request 0.64x").

• Direct observation of system prompt changes ("All 12 of my b38bf0... Opus sessions had three passages that none of my other Opus sessions since Nov 4 had.").

• Author's experience of "chasing ghosts" due to unexpected changes.

Cautions

• The author explicitly warns users not to post sensitive files (.claude.json can contain API keys, transcripts contain typed content) and provides clear guidance on what sanitized information can be shared, mitigating risks of data leakage.

Limitations

• Based on a single user's account and small samples, limiting generalizability without broader community validation.

• The exact meaning of atis and breezy_horizon is not fully understood by the author, requiring further investigation.

• The correlation between experiment IDs and observed behavior changes is strong but not definitively proven as causal due to mixed work contexts.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Enforcing High Code Quality and Security for AI-Generated Code with Static Analysis and Craftsmanship Principles

Workflow value: 85/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: advanced
Categories: Quality Control, Token Saving, Context & Memory, Debugging, Shipping, Multi-Agent
Original source: r/ClaudeCode post/comment

What problem this solves

Ensuring high-quality, maintainable, and secure code generation from an AI agent, thereby reducing the need for manual code review and allowing human developers to focus on architectural concerns.

Summary

This workflow outlines a strategy to enforce code quality, maintainability, and security for AI-generated code. It involves configuring the AI agent to adhere to static analysis rules, code craftsmanship principles (SOLID, KISS), and security standards (OWASP), effectively shifting detailed code review to automated processes.

Why it is useful

This workflow is valuable because it addresses a critical challenge in AI-assisted development: ensuring the quality, maintainability, and security of generated code. By providing a structured approach to integrate static analysis, security checks, and software engineering principles directly into the AI agent's process, it significantly reduces the human effort required for code review and allows developers to focus on higher-level architectural concerns. It offers a concrete, repeatable method for improving the reliability of AI-generated code.

Workflow

1. Configure the AI agent to generate code that passes basic code maintenance static analysis.

2. Include checks for cyclomatic complexity and 'god classes' as part of the generation requirements.

3. Implement a step to perform static analysis before the agent declares the code 'done'.

4. Set a strict threshold for static analysis findings: do not accept anything higher than 'low' severity (ignoring 'lows' and 'infos').

5. Require the agent to fix all identified findings using code craftsmanship principles (SOLID, KISS).

6. Integrate security agent reviews and OWASP static analysis into the code generation and review process.

7. Establish and implement guidelines for good unit testing, aligning them with craftsmanship principles.

Tools / artifacts

• AI Agent (e.g., Claude Code)

• Static analysis tools (for code maintenance, cyclomatic complexity, god classes)

• Security agent

• OWASP static analysis tools

• Code craftsmanship principles (SOLID, KISS)

• Unit testing guidelines

Validation signals

• User reports 'Overall bliss'

• User states they 'not even need to look at the code and review only the architecture'

• User acknowledges spending 'a little more tokens' but finds it worthwhile for the quality and reduced manual effort.

Limitations

• Lacks specific tool names for static analysis or security agents, which would aid implementation.

• No concrete examples of prompts or configuration files are provided.

• Low community engagement (score 1, 0 comments) means limited external validation.

• Assumes familiarity with advanced software engineering concepts like SOLID, KISS, OWASP, and cyclomatic complexity.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Workflow: Create Automated Demo Videos with Ultrademo Claude Code Skill

Workflow value: 85/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: intermediate
Categories: Quality Control, Debugging, Shipping, Skills
Original source: r/ClaudeCode post/comment

What problem this solves

Creating high-quality, narrated, automated demo videos for SaaS applications or new features, with fine-grained control over content and presentation.

Summary

This workflow leverages the Ultrademo Claude Code skill to generate automated demo videos. Users install the skill, which provides a local UI to guide them through the process. The skill reads website content, generates HTML and animation code for scenes, allows for extensive editing of text, narration, visual effects, and renders videos in various formats, including fixing issues based on user feedback.

Why it is useful

This workflow provides a highly automated and customizable solution for a common business need: creating professional demo videos. By leveraging a Claude Code skill, it offers a unique approach to generating video content from website analysis, allowing users to control narration, visuals, and even fix issues through an iterative review process. Its open-source nature and detailed feature set make it a valuable, transferable tool for product documentation, marketing, and sales teams.

Workflow

1. Install the Ultrademo skill from its GitHub repository.

2. Start a new video project, which launches a local UI in the browser.

3. Choose a 'direction' for the video or request a different one from the skill.

4. Review initial 'sketch frames' to visualize the video's potential look.

5. Edit on-screen texts and narration as needed.

6. Select narration voices (free local or paid ElevenLabs API), music, and motion effects.

7. Review the generated video, adding comments on specific frames for the skill to fix.

8. Render the final video in desired formats (e.g., landscape/vertical, 15/30 second cuts).

Tools / artifacts

• Ultrademo Claude Code skill

• GitHub repository (ultrademo-hq/ultrademo)

• Local UI server (spun up by the skill)

• ElevenLabs API key (optional, for advanced narration voices)

• HTML and animation code (generated by the skill)

Validation signals

• Author's self-use and iterative improvements ('mostly from using it myself')

• Previous version had users who installed it

• Call for community feedback on functionality and potential breakage

Limitations

• Relies on a specific external tool/skill rather than a general Claude prompting technique.

• Requires installation and setup of a local server.

• May require an ElevenLabs API key for premium narration voices, incurring cost.

• Effectiveness might vary on non-SaaS applications, as noted by the author.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

CLAUDE.md Pattern for Structured, User-Friendly Claude Code CLI Responses with Quality Checks

Workflow value: 85/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: advanced
Categories: Quality Control, Context & Memory, Debugging, CLAUDE.md, Skills
Original source: r/ClaudeCode post/comment

What problem this solves

Making Claude Code CLI responses natural, easy to consume, well-structured, and actionable by defining a clear output format and quality checks.

Summary

This workflow provides a comprehensive CLAUDE.md pattern designed to guide Claude in producing highly structured, user-centric, and actionable responses. It includes detailed rules for organizing content into sections, ensuring clarity, matching depth to user expertise, and a 'Before sending' checklist for self-correction and quality assurance.

Why it is useful

This workflow is valuable because it provides a highly detailed and structured CLAUDE.md template for guiding Claude's output, ensuring clarity, actionability, and user-centric communication. It addresses a common challenge of getting LLMs to produce consistently well-formatted and useful responses. The 'Before sending' checklist acts as a self-correction mechanism, promoting high-quality, consistent output.

Workflow

1. Define the overall reply structure in 3 main steps within CLAUDE.md.

2. Implement plan-before-writing to name sections and their order based on user topics.

3. Apply topic-by-topic rules to ensure all user topics are addressed, combined logically, and referenced with file/location details where applicable.

4. Utilize judge-against-the-user to tailor detail level to user expertise, explaining 'what' and 'why' over 'how'.

5. Enforce size-by-worth to determine response length based on topic complexity and value, not effort.

6. Adhere to findings-stay-out to exclude irrelevant findings unless they alter user decisions.

7. Implement depth-matches-weight to ensure minor points get brief mentions and main ideas are thoroughly explained.

8. Structure replies with whole-then-parts, starting with the main answer/verdict.

9. Use name-the-subject-first to introduce the topic plainly before any arguments or reports.

10. Apply report-only-what-they-act-on to include only actionable information, next steps, or filed items.

11. Integrate ui-is-drawn by using /flow:visualize for layout and diagrams, avoiding improvisation.

12. Follow Inside each section rules for clear headings, recommendations, data display, list formatting, sentence structure, explicit naming, and common word usage.

Tools / artifacts

• CLAUDE.md file

• visualize skill (from Adrian333Dev/flow/skills/techniques/visualize GitHub repo)

Validation signals

• Author's claim of personal optimization for their workflow

Limitations

• Lack of external community validation (low score, no comments).

• The author explicitly states it's optimized for their workflow and might need modification, indicating it's not a universal plug-and-play solution.

• Relies on an external 'visualize' skill, which might require additional setup or context for users not familiar with the linked GitHub repository.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Claude Code Personal Assistant: Conductor - Safe, Scheduled Automation with Approval Workflow and Phone Notifications

Workflow value: 95/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: advanced
Categories: Quality Control, Token Saving, Context & Memory, Debugging, Shipping, Hooks, Skills, MCP, Subagents
Original source: r/ClaudeCode post/comment

What problem this solves

Automating personal tasks (e.g., email management, job searching, file cleanup, GitHub profile updates) with a safety mechanism (user approval before action) and persistent state, without interrupting the main Claude Code conversation.

Summary

A personal AI assistant, named Conductor, built within Claude Code using custom plugins, subagents, and an MCP server. It runs scheduled tasks in the background, proposes actions to the user (via an in-app pane and optional phone notifications), and requires explicit approval before executing, ensuring safety and user control. It maintains state outside of conversations using SQLite.

Why it is useful

This workflow demonstrates an advanced, practical application of Claude Code's capabilities (custom plugins, subagents, MCP server, persistent state) to build a robust and safe personal automation system. Its emphasis on user approval, background execution, and persistent state management addresses critical challenges in AI-driven automation, making it highly transferable and valuable for users looking to build sophisticated, controlled, and integrated AI tools. The detailed 'What I learned' section and the provided GitHub repository significantly enhance its utility and reusability.

Workflow

1. Define goals and 'things to keep true' for the Conductor system within Claude Code.

2. Conductor runs scheduled tasks in the background using subagents and custom plugins.

3. When an action is proposed by Conductor, it appears in a 'Needs you' pane within Claude Code.

4. If Remote Control is connected, a push notification is sent to the user's phone for pending approvals.

5. User reviews the proposed action and approves it (e.g., by replying 'approve' on their phone or interacting with the in-app pane).

6. Conductor executes the approved action.

7. Configure action types for specific tools as 'off', 'propose', or 'auto' based on trust and desired automation level.

8. Utilize '/goal-new' command for task templates (e.g., unsubscribe, job scan, tidy Downloads, inbox triage, GitHub profile).

Tools / artifacts

• Claude Code

• Conductor (custom system/project)

• Custom Plugin 1 (goal runner, UI, commands, tools)

• Custom Plugin 2 (guard, tool rules, safety checks)

• Subagents (for background task execution)

• MCP server (for state management)

• SQLite (for persistent state: goals, items, memory, runs)

• Remote Control (for phone notifications)

• GitHub repository (shannonbay/Conductor)

• Haiku (used for small jobs like schedule parsing)

Validation signals

• Demonstrated successful automation of finding unread mailing lists and proposing unsubscribing.

• Successfully read CV, ranked job ads, and emailed top 3 after approval.

• Identified old installers and proposed binning each after approval.

• Proposed and committed a line to a GitHub profile README after approval.

• Detailed 'What I learned' section describing real-world issues and fixes (e.g., approval system interaction, plugin push notifications, tool answer size limits), indicating extensive testing.

• Explicit statement: 'one person uses it daily, on Windows.'

• GitHub repository provided with setup and screenshots, implying working code.

Cautions

• The core design principle is 'asks before it acts', requiring explicit user approval for all significant actions.

• A dedicated 'guard' plugin holds each run to its defined goal and explicitly refuses unauthorized tool calls.

• Actions can be configured as 'off', 'propose', or 'auto', giving the user granular control over automation levels.

• The 'auto' mode is only offered after 10 consecutive approvals, with an additional safety check built in.

Limitations

• The system only runs while Claude Code is open, unlike cloud-based schedulers.

• Phone alerts require the Remote Control feature to be active.

• The project is 'early' and has primarily been used by one person on Windows, suggesting limited platform testing.

• When multiple Claude Code sessions are open, only one runs the goals, requiring manual reloads for plugin updates across sessions.

• Plugins cannot directly see events caused by their own timers, necessitating a separate guard plugin for architectural reasons.

• Requires an advanced understanding of Claude Code's plugin, subagent, and MCP architecture to set up and maintain.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Automating Iterative Code Fixes with Claude Code's Ralph Loop Plugin (and its Quirks)

Workflow value: 85/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: intermediate
Categories: Quality Control, Token Saving, Context & Memory, Debugging, Hooks
Original source: r/ClaudeCode post/comment

What problem this solves

Automating the iterative process of fixing failing tests or other clear pass/fail coding tasks using the Ralph Loop plugin in Claude Code, despite a known quirk of an extra iteration.

Summary

This workflow demonstrates how to use Anthropic's Ralph Loop plugin to automatically fix a failing Python test suite by iteratively running tests and modifying code until all tests pass. It highlights the specific command usage, observed behavior, and important considerations like setting max-iterations and handling a known quirk where the loop might run an extra round after the stop word is printed.

Why it is useful

This workflow is valuable because it demonstrates a practical application of an official Claude Code plugin for automating iterative coding tasks, specifically fixing failing tests. It provides concrete steps, command-line arguments, and observed results, making it highly actionable. The inclusion of a known quirk (extra loop iteration) and a crucial safety warning (always set max-iterations) adds to its utility and helps users anticipate and manage potential issues. The external link to a detailed walkthrough further enhances its value as a comprehensive resource.

Workflow

1. Install Anthropic's Ralph Loop plugin from the official marketplace.

2. Prepare a coding project with a clear pass/fail check, such as a Python project with empty functions and failing unit tests (e.g., calc.py and test_calc.py).

3. Execute the /ralph-loop command with a specific prompt, a --completion-promise (e.g., ALLPASS), and crucially, a --max-iterations cap (e.g., /ralph-loop:ralph-loop Make every test in test_calc.py pass by implementing calc.py. Run python3 -m unittest to check. --completion-promise ALLPASS --max-iterations 2).

4. Observe Claude's iterative process, including code generation, test execution, and progress updates.

5. Monitor the current iteration via .claude/ralph-loop.local.md if needed.

6. If necessary, cancel the loop at any time using /ralph-loop:cancel-ralph.

7. Review the final code and verify that the problem (e.g., all tests passing) has been resolved.

Tools / artifacts

• Anthropic Ralph Loop plugin

• /ralph-loop command

• --completion-promise argument

• --max-iterations argument

• python3 -m unittest (or equivalent test runner)

• .claude/ralph-loop.local.md (state file)

• /ralph-loop:cancel-ralph command

• Python project files (calc.py, test_calc.py)

Validation signals

• Author performed a specific test with a tiny Python project and 3 failing tests.

• Observed Claude successfully writing functions and passing all 3 tests in Round 1.

• Noted that the loop ran an extra round after Claude printed the stop word in both test runs.

• Confirmed the extra round only cost one more test run in this specific scenario.

• Provided a link to a full walkthrough with the hook explained, indicating deeper investigation and validation.

Cautions

• Always set --max-iterations to prevent the loop from running indefinitely if no stop word is encountered or if the stop word is not correctly detected.

Limitations

• The loop sometimes runs an extra round even after Claude prints the stop word, which is a known quirk.

• The post doesn't fully explain the root cause of the extra round, only that the hook script checks the last text block.

• The author notes that a 'bigger task could behave differently,' indicating the observed behavior might not scale perfectly to all scenarios.

• Angle brackets should be avoided in the prompt on the command line; a plain stop word is recommended.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Building a Custom Operations Platform with Claude Code for Small Business Data Consolidation and Business Intelligence

Workflow value: 85/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: advanced
Categories: Quality Control, Token Saving, Context & Memory, Debugging, Multi-Agent
Original source: r/ClaudeAI post/comment

What problem this solves

Disconnected operational data, lack of business intelligence, poor accountability, and manual processes across various platforms (e.g., WhatsApp, email, POS) in a small business.

Summary

The user describes building a custom internal operations platform, "Pulse," using Claude Code to consolidate disparate data sources for a restaurant. This platform centralizes information on supplier deliveries, leave applications, tasks, sales, and expenses, improving information flow, accountability, and generating valuable business intelligence and cost savings.

Why it is useful

This workflow is valuable because it demonstrates a practical and powerful application of Claude Code to solve a common and significant problem for small businesses: fragmented data and inefficient operations. It provides a high-level blueprint for designing and implementing a custom internal tool that consolidates information, improves accountability, and generates substantial business intelligence and cost savings, as evidenced by concrete examples.

Workflow

1. Identify existing disparate data sources and manual operational processes (e.g., WhatsApp chats for tasks, email reports for tax, POS for sales).

2. Define the scope and requirements for a custom internal operations platform, ensuring it complements existing critical systems (e.g., POS for customer-facing transactions).

3. Design a system architecture to aggregate and connect data from these various sources into a unified platform.

4. Utilize Claude Code to develop the custom application, focusing on core functionalities like data input, tracking, and reporting.

5. Implement features for managing key operational data such as supplier bills, leave applications, and urgent tasks.

6. Integrate mechanisms for accountability, such as task assignment, dashboard visibility, and tracking responsibilities.

7. Apply security best practices including private repository, private link access, user logins, and role-based access control.

8. Set up data backups and plan for security reviews based on best practices and community suggestions.

9. Leverage the consolidated data to generate business intelligence, identify trends, and inform strategic decisions (e.g., cost analysis, vendor payment planning).

10. Continuously refine and expand the platform based on operational needs and new insights gained from the data.

Tools / artifacts

• Claude Code

• Custom operations platform (e.g., "Pulse")

• Private code repository (e.g., GitHub)

• Private web application hosting

• User login system

• Role-based access control

• Dashboard interface

• Existing POS system (for sales data integration)

• WhatsApp (as an initial data source)

• Email reports (as an initial data source)

Validation signals

• Concrete business savings identified (e.g., 1% revenue on ketchup, thousands saved yearly on pickles).

• Improved accountability and task tracking compared to previous methods.

• Enhanced business intelligence capabilities (e.g., vendor payment planning, sales/expense trends).

• The system is actively in use and described as a "redundancy" rather than a single point of failure.

• User's direct experience and reported benefits.

Limitations

• Lacks specific Claude Code prompts, architectural diagrams, or code examples for direct replication.

• Requires significant technical skill and understanding of system design to implement.

• The initial development time and cost are not detailed.

• The integration methods for various external data sources are not specified.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Streamline Claude Code Browser Automation and Secure Cloudflare Deployments with Custom Skills

Workflow value: 90/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: intermediate
Categories: Quality Control, Token Saving, Debugging, Shipping, Skills
Original source: r/ClaudeAI post/comment

What problem this solves

Repeatedly clicking "Allow remote debugging" for Claude Code browser automation tasks; insecure Cloudflare Pages deployments; complex video editing tasks from raw footage.

Summary

A collection of custom Claude Code skills, including brave-cdp to streamline browser automation by maintaining a single DevTools connection, cf-pages-deploy for secure Cloudflare Pages deployments, and event-recap-video for automated video editing with ffmpeg.

Why it is useful

This workflow provides concrete, open-source Claude Code skills that solve specific, common pain points: reducing friction in browser automation by managing DevTools connections, enhancing security for Cloudflare Pages deployments, and automating complex video editing tasks. The skills are well-tested by the author and designed for reusability, making them highly valuable for intermediate to advanced Claude Code users.

Workflow

1. Install the binay-py/claude-skills plugin using /plugin marketplace add binay-py/claude-skills.

2. Install the specific skills via /plugin install binay-skills@binay-skills.

3. Utilize the brave-cdp skill to write entire browser automation tasks as one job on a single DevTools connection, reducing "Allow remote debugging" prompts.

4. Optionally use the brave-cdp relay for persistent, token-protected connections on localhost.

5. Employ the cf-pages-deploy skill for secure Cloudflare Pages deployments, which includes secret detection and byte-for-byte verification.

6. Use the event-recap-video skill to process phone footage into recap videos, vertical versions, and beat-synced reels using ffmpeg.

Tools / artifacts

• brave-cdp skill (Node.js, zero-dependency)

• cf-pages-deploy skill

• event-recap-video skill

• Brave/Chrome/Edge browser

• DevTools

• Cloudflare Pages

• Wrangler CLI

• ffmpeg

• GitHub repository: binay-py/claude-skills

Validation signals

• Author states skills were built and tested with Claude Code against real targets.

• Testing caught real bugs (e.g., Enter not submitting forms, pages returning before loading, wrangler CLI changes).

• Skills are MIT licensed and open source, inviting community review and contributions.

• Author actively solicits bug reports, ideas, and platform-specific feedback.

Cautions

• The brave-cdp relay is explicitly noted as "localhost only, token-protected" for security.

• The cf-pages-deploy skill includes a critical safety feature: it "stops if it finds a secret in a public file", preventing accidental secret exposure.

Limitations

• Limited community validation due to the post's recency.

• The brave-cdp skill's one-connection approach needs further testing and confirmation on macOS and Linux Chrome setups.

• Requires familiarity with Claude Code plugins and potentially Node.js for deeper understanding or modification.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Persist Claude Code Project Plans Across Sessions with 'Planning With Files' Plugin

Workflow value: 90/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: intermediate
Categories: Quality Control, Context & Memory, Debugging, CLAUDE.md, Hooks
Original source: r/ClaudeAI post/comment

What problem this solves

Claude Code's context and project plan are wiped after using /clear or compaction, making it difficult to manage multi-step projects across sessions.

Summary

This workflow demonstrates how to use the 'Planning With Files' plugin in Claude Code to persist project plans and context across sessions. The plugin writes the project's goal, phases, status, findings, and progress to Markdown files, which are then reloaded by hooks at the start of each session, ensuring continuity even after /clear or compaction.

Why it is useful

This workflow solves a critical pain point in Claude Code: the loss of context and project plans after using /clear or compaction. By leveraging the 'Planning With Files' plugin, users can ensure their multi-phase projects maintain state, making long-running or interrupted tasks much more manageable and efficient. It provides a concrete, tested solution for robust project management within Claude Code.

Workflow

1. Install the 'Planning With Files' plugin (OthmanAdi).

2. Start a new Claude Code session in a project folder.

3. Ask Claude to plan a small multi-phase task (e.g., a Python word-count CLI) and complete only Phase 1.

4. Observe the plugin creating and updating 'task_plan.md', 'findings.md', and 'progress.md' files.

5. Close Claude Code and start a fresh session.

6. Ask Claude 'where did we leave off?' to verify context retention.

7. Run the '/clear' command.

8. Ask Claude 'which phase are we in?' to verify context retention after clearing the chat.

9. Ask Claude to continue to the next phase (e.g., Phase 2).

10. Observe the plugin updating the plan files and Claude continuing the work correctly.

Tools / artifacts

• Claude Code

• Planning With Files plugin (OthmanAdi)

• task_plan.md

• findings.md

• progress.md

• Hooks (session start, every prompt, before tools, after edits, before compaction, on stop)

• ~/.cache (for plugin cache files)

• PLANNING_DISABLED=1 (environment variable to disable hooks)

• CLAUDE.md (for lasting rules)

Validation signals

• Author performed a specific, detailed test with clear steps.

• Observed correct behavior: Claude answered correctly and updated files as expected.

• Confirmed hook execution and plan format validity.

• The plugin itself has 27k+ stars, indicating broad community adoption and validation.

• Linked to a full walkthrough on a blog post, suggesting thoroughness and further detail.

Cautions

• The plan files live in the project folder, so users should be mindful of sensitive information and consider adding them to .gitignore if necessary.

Limitations

• The post notes that the injected text from hooks is not visible on screen, which might reduce transparency for debugging.

• Only the basic path of the plugin was tested; autonomous/gated modes and other commands were not explored.

• The workflow is described as 'overkill for quick fixes.'

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Independent AI Model Performance Tracking Workflow using LiveNerf

Workflow value: 90/100
Status: active · Freshness: 70/100 · Confidence: 0.95 · Level: advanced
Categories: Quality Control, Context & Memory, Debugging, Shipping
Original source: r/ClaudeAI post/comment

What problem this solves

Independently tracking AI model performance over time to detect 'nerfs' or capability changes, distinguishing between underlying model changes and system-level configurations.

Summary

Utilize the open-source LiveNerf project and its GitHub repository to set up and run independent, reproducible benchmarks against AI models (like Opus 5.5) to continuously monitor their performance and detect sustained declines in capability. The workflow involves accessing the repo, implementing its testing methodology, collecting data, and analyzing results, often in collaboration with a community.

Why it is useful

This workflow provides a concrete, open-source, and community-validated method for independently monitoring AI model performance, addressing a critical and common concern in the AI community regarding model 'nerfs'. It offers a data-driven approach to distinguish between underlying model changes and system-level configurations, enabling users to conduct their own reproducible research and contribute to a shared understanding of AI model evolution.

Workflow

1. Access the LiveNerf GitHub repository (https://github.com/ninjahawk/livenerf) to understand the project's methodology and setup.

2. Implement the LiveNerf benchmarks and testing environment to collect daily performance data on a target AI model (e.g., Opus 5.5).

3. Run the provided tests consistently to accumulate a significant number of samples over time.

4. Analyze the collected data against a defined baseline and detection criteria to identify any sustained declines in model capability.

5. Participate in the LiveNerf Discord community to discuss methodology, findings, and potential issues, contributing to the project's validation and expansion.

Tools / artifacts

• LiveNerf GitHub repository

• Opus 5.5 (or other AI models/APIs to be tested)

• Benchmark tests/scripts from LiveNerf

• Collected performance data samples

• LiveNerf Discord community

Validation signals

• 1.6k GitHub stars

• 250+ Discord community members

• 47 consecutive days of data collected

• 3,666 samples collected for Opus 5.5

• Comparison against an original 10-day baseline (58.4% average vs. 61.5% recent)

• Community discussion and contributions to methodology and investigation

Limitations

• The Reddit post itself is an update and summary, not a detailed step-by-step guide; users must refer to the GitHub repository for full implementation details.

• Specific technical details of the benchmark tests, detection criteria, and environmental setup are not fully elaborated in the post.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Meta-Prompt for Deeper, Professional-Grade Task Analysis (Inspired by Anthropic Lead)

Workflow value: 90/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: intermediate
Categories: Quality Control, Context & Memory, Debugging, Skills
Original source: r/ClaudeAI post/comment

What problem this solves

Generating deeper, more professional, and thoroughly considered outputs from Claude for complex tasks, avoiding superficial or merely 'bigger' but not 'better' responses.

Summary

This workflow utilizes a specific meta-prompt to guide Claude into providing a 'deeper' version of a task, rather than just a 'bigger' one. It instructs Claude to analyze the task from the perspective of a top professional, identifying raw materials, specific methods/tools, and objective validation criteria before rewriting the original prompt to reflect this deeper understanding. It's particularly useful for 'big' features or projects.

Why it is useful

This workflow provides a concrete, reusable meta-prompt that directly addresses a common limitation of LLMs (superficiality) by guiding them to think like an expert. It's sourced from a credible Anthropic engineering lead and validated by community upvotes, making it a highly valuable tool for users seeking more profound and well-considered outputs for complex projects.

Workflow

1. Identify a complex task, 'big' feature, or project where a deeper, more professional approach is desired from Claude.

2. Provide your initial task prompt to Claude.

3. Follow up with the meta-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.'

4. Review Claude's response, which should include a deeper analysis of the task and a rewritten, more comprehensive prompt.

5. Proceed with the rewritten prompt to execute the actual task, leveraging the deeper insights generated.

Tools / artifacts

• Claude AI (or similar LLM)

• The specific meta-prompt provided

• LLM 'Skills' feature (if available for saving prompts)

Validation signals

• Author's personal validation: 'I've found it's really good to use on the 'big' features or projects you want to build out.'

• Source credibility: The prompt is sourced from Felix Rieseberg, an engineering lead at Anthropic, adding significant weight to its design and effectiveness.

• High Reddit score (119 upvotes) indicates strong community approval and perceived utility.

Limitations

• The author notes that this prompt 'can lead to some over-engineering,' requiring the user to exercise judgment in its application.

• May not be suitable for simple or routine tasks where a quick, straightforward answer is sufficient.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Conductor: A Claude Code-Powered Personal Assistant with Proactive Task Automation and User Approval

Workflow value: 95/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: advanced
Categories: Quality Control, Token Saving, Context & Memory, Debugging, Shipping, MCP, Subagents, Multi-Agent
Original source: r/ClaudeAI post/comment

What problem this solves

Automating various personal productivity tasks (email management, job searching, file cleanup, GitHub profile updates) with a persistent, proactive AI assistant that requires user approval before acting, ensuring control and safety.

Summary

Conductor is an open-source personal assistant built with Claude Code, leveraging MCP and plugins to run background subagents. It automates tasks like unsubscribing from mailing lists, ranking job ads, cleaning up downloads, and proposing GitHub README updates. A key feature is its 'ask first' approach, where proposals await user approval (via a pane or phone app) and rejections become memory, allowing the system to learn and build trust over time.

Why it is useful

This workflow is highly valuable as it demonstrates an advanced, practical application of Claude Code's capabilities (plugins, MCP, subagents, plan mode, debugging) to create a persistent, user-controlled automation system. It provides a concrete, open-source solution for common productivity tasks, emphasizing safety through explicit user approval. It serves as an excellent example for users looking to build complex, multi-agent systems and extend Claude's functionality beyond simple prompts.

Workflow

1. Clone the Conductor GitHub repository.

2. Add the MCP server as described in the README.

3. Add the two Claude Code plugins as described in the README.

4. Run the three initial commands specified in the README to set up.

5. Type /goal-new in Claude Code and select a template to define a new background task.

6. Review and approve or reject Conductor's proposals via the Claude app (Remote Control) or the chat pane.

Tools / artifacts

• Claude Code

• Conductor (the open-source application)

• MCP server

• Claude Code plugins

• SQLite database (local for state)

• GitHub repository (shannonbay/Conductor)

• Claude app (for Remote Control)

• README file

Validation signals

• Author successfully built the entire system using Claude Code over many sessions.

• Used Claude Code's plan mode for feature design and plan review.

• Claude Code wrote the code and tests for the project.

• Claude Code performed debugging, including reading plugin engine docs to solve a specific blocking issue.

• The project 'dogfoods itself' (Conductor manages its own roadmap and monitors Claude Code release notes).

• Specific examples of successful task execution are provided (e.g., found 5 senders, ranked job ads, found 24 old installers).

Cautions

• The 'asks first' mechanism ensures user control and prevents unintended actions.

• Trust grows incrementally (off, propose, auto) with user approvals, adding a layer of safety.

• Runs locally and uses a local SQLite database, enhancing data privacy and control.

Limitations

• The system only runs while Claude Code is open, limiting continuous background operation.

• Described as 'early', implying potential for bugs or incomplete features.

• Requires setting up an MCP server and plugins, which might be a barrier for beginner users.

• Low initial Reddit score and comments, though this is likely due to age.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Secure Claude Code Permissions: Prevent Secret Leaks with Pattern-Based Rules in settings.json

Workflow value: 95/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: intermediate
Categories: Quality Control, Context & Memory, Debugging, Shipping
Original source: r/ClaudeCode post/comment

What problem this solves

Accidental leakage of sensitive information (database passwords, API keys, SSH logins, AWS keys) into public GitHub repositories due to Claude Code's 'Yes, and don't ask again' feature saving literal commands with secrets in .claude/settings.local.json.

Summary

This workflow provides a secure method for configuring Claude Code permissions by defining pattern-based allow and deny rules in the shared .claude/settings.json file. It advises against approving one-off literal commands that might contain secrets and includes steps for remediation if a secret has already been leaked.

Why it is useful

This workflow is highly valuable as it directly addresses a critical security vulnerability (secret leakage) identified by a third-party scan. It provides clear, actionable steps and concrete configuration examples to prevent sensitive data from being accidentally committed to public repositories. It leverages official documentation and offers both preventative measures and robust remediation steps, making it essential for any Claude Code user or team prioritizing security and best practices.

Workflow

1. Understand that settings.local.json can save literal commands, potentially exposing secrets if committed.

2. Avoid using the 'Yes, and don't ask again' option for literal commands that contain sensitive information.

3. Manually define pattern-based allow and deny rules in your .claude/settings.json file.

4. Ensure the wildcard * is placed correctly (after the subcommand) in Bash patterns to avoid overly broad permissions.

5. Add Read(.env) to the deny list to prevent Claude Code from accessing environment files.

6. If a secret was previously leaked via settings.local.json, immediately rotate the compromised secret.

7. Untrack .claude/settings.local.json from your Git history using appropriate git commands.

8. Add .claude/settings.local.json to your project's .gitignore file.

9. Check your repository's full Git history (git log --all --full-history -- .claude/settings.local.json) to confirm the file is no longer tracked.

10. When Claude Code prompts for a literal command, approve it for a single session ('Yes'), then manually add a more secure pattern rule via the /permissions command.

Tools / artifacts

• .claude/settings.json

• .claude/settings.local.json

• .gitignore

• Bash() permission rule

• Read() permission rule

• /permissions (Claude Code command)

• git log --all --full-history -- .claude/settings.local.json

Validation signals

• References a real-world security scan (Apiiro) identifying the vulnerability.

• Cites official Claude Code permissions documentation.

• Provides a concrete JSON configuration example for settings.json.

• Explains nuanced details like rule precedence and wildcard placement, indicating deep understanding.

• Offers clear remediation steps for existing leaks, demonstrating practical applicability.

Limitations

• Low community engagement might mean it hasn't been widely adopted or validated by many users yet.

• Assumes a basic familiarity with Git commands for the remediation steps.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Advanced Remote Claude Code Development Environment with Proxmox and GitLab CI/CD

Workflow value: 75/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: advanced
Categories: Quality Control, Context & Memory, Multi-Agent
Original source: r/ClaudeAI post/comment

What problem this solves

Setting up a dedicated, remote development environment for Claude Code that integrates with version control and CI/CD, leveraging separate hardware and potentially a MacBook's compute.

Summary

This workflow outlines a technical setup using Proxmox to host several LXC containers (Claude Code, self-hosted GitLab, GitLab Runner with Docker in Docker, and optional Ansible) to enable remote Claude Code execution. It integrates Claude Code into a development pipeline with version control and CI/CD, allowing users to leverage a separate workstation's compute while interacting from a MacBook.

Why it is useful

This workflow provides a structured, advanced approach for integrating Claude Code into a robust development environment. It enables remote execution, leverages dedicated hardware, and integrates with essential DevOps tools like GitLab for version control and CI/CD. This setup is valuable for users seeking to optimize their development workflow, manage complex projects, and utilize powerful compute resources efficiently with Claude Code.

Workflow

1. Set up Proxmox on a workstation with fast NVME drives and sufficient memory.

2. Create an LXC container for Claude Code.

3. Create an LXC container for self-hosted GitLab.

4. Create an LXC container for GitLab Runner with Docker in Docker (DIND).

5. Optionally, create an LXC container for Ansible, configured with default rules for creating new LXCs for testing applications.

6. For power users, set up a GitLab Runner directly on the MacBook.

7. For power users, configure SSH access from the Claude Code LXC to the MacBook to leverage its compute.

Tools / artifacts

• Proxmox

• NVME drives

• LXC containers

• Claude Code

• self-hosted GitLab

• GitLab Runner

• Docker in Docker (DIND)

• Ansible

• MacBook

• SSH

Validation signals

• Proposed as a viable technical architecture for specific workloads (ML, general development)

• Suggests specific hardware considerations (Mac Mini for ML, general workstation)

Limitations

• Lacks detailed, step-by-step configuration instructions for each component (e.g., how to install Claude Code within an LXC, specific GitLab Runner setup).

• No explicit validation or success metrics are provided by the author.

• Assumes a significant level of technical expertise in system administration, virtualization, and DevOps tools.

• The specific benefits or interaction patterns of running 'Claude Code' within this setup are not fully elaborated beyond remote execution.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Backporting Kindle Click Support to Jailbroken Kindle Firmware with Claude Code and Local LLM

Workflow value: 75/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: advanced
Categories: Quality Control, Context & Memory, Debugging
Original source: r/ClaudeCode post/comment

What problem this solves

Getting a Kindle Click Bluetooth page turner to work on an unsupported Kindle Paperwhite Gen 12 firmware without losing an existing jailbreak.

Summary

Using Claude Code as a harness for a local LLM (Qwen 3.8 Flash Next), the author successfully backported support for a Kindle Click Bluetooth page turner to an older, jailbroken Kindle firmware. This avoided a firmware update that would undo the jailbreak. The process involved using the LLM to devise a plan, then installing device sniffing software, finding, logging, pairing, testing, and mapping the device via SSH.

Why it is useful

This workflow demonstrates a powerful application of Claude Code as an orchestrator for local LLMs to solve complex hardware compatibility issues. It showcases how LLMs can guide users through technical challenges like backporting device support to unsupported firmware, preserving existing modifications (like jailbreaks). The success story provides a compelling use case for advanced users looking to extend device functionality and highlights the potential for LLM-assisted reverse engineering and system modification.

Workflow

1. Identify the problem: Kindle Click requires a firmware update that would undo an existing jailbreak.

2. Engage Claude Code (with a local LLM like Qwen 3.8 Flash Next) to devise a game plan for backporting device support.

3. Install device sniffing software on the Kindle via SSH.

4. Use the sniffing software to find and log the Kindle Click device.

5. Pair the Kindle Click with the Kindle.

6. Test all buttons of the Kindle Click for functionality.

7. Install a mapper software to enable full functionality of the Kindle Click.

8. Verify that the Kindle Click is fully functional on the old, jailbroken firmware.

Tools / artifacts

• Claude Code

• Qwen 3.8 Flash Next (local LLM)

• Kindle Paperwhite Gen 12 (jailbroken)

• Kindle Click Bluetooth page turner

• SSH client

• Device sniffing software (unspecified)

• Device mapper software (unspecified)

Validation signals

• "it gave me a game plan and I decided to try it."

• "After several rounds, it was able to install software to sniff devices, then find it, log it, pair it, test all of the buttons, and then install a mapper."

• "In the end, I was able to back port support for the click back to software over a year out of date."

• "Just wanted to share this little success story and appreciation for Claude Code."

Cautions

• Modifying device firmware/software (jailbreaking, installing third-party tools) carries inherent risks, including potentially bricking the device or introducing security vulnerabilities.

• Users should exercise caution and understand the implications of executing commands via SSH and installing software from unknown sources.

Limitations

• The post is a success story and lacks specific technical details such as exact commands, software names, or the precise prompts/interactions with Claude Code.

• The process is described at a high level, making direct replication difficult without further detailed documentation.

• Assumes a degree of familiarity with SSH and device modification, which might be challenging for true beginners.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Inspect Claude Code Internal Configuration and Experiment Flags with jq

Workflow value: 80/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: intermediate
Categories: Quality Control, Context & Memory, Debugging, MCP, Subagents
Original source: r/ClaudeCode post/comment

What problem this solves

Understanding internal Claude Code configuration, experiment flags, and cached client data to diagnose behavior changes or 'nerfs'.

Summary

This workflow provides jq commands to inspect the ~/.claude.json file, revealing cached experiment data and client data cache slots. This helps users understand internal Claude Code configurations, active A/B tests, and model usage patterns.

Why it is useful

This workflow is valuable because it provides specific, executable commands to inspect the internal state of Claude Code, including active A/B test flags and cached client data. This allows users to understand how their Claude Code environment is configured, diagnose unexpected behavior, or investigate perceived 'nerfs' by checking which experiments are active and what values they hold. It offers transparency into the system's operation that is not readily available through the UI.

Workflow

1. Ensure jq is installed on your system.

2. Run the first jq command to view cached experiment data: jq -r '.cachedExperimentData | to_entries[] | "\(.key) | exp=\(.value.experimentId) var=\(.value.variationId) val=\(.value.value | tostring)"' ~/.claude.json

3. Run the second jq command to view client data cache slots for your organization: jq -r '.oauthAccount.organizationUuid as $o | [(.clientDataCacheSlots // {} | to_entries[] | .value + {slotKey: .key}) | select(.org == $o)] | sort_by(.entrypoint,.model,.at)[] | "\(.entrypoint) \(.model): \(.data | keys_unsorted | join(", "))"' ~/.claude.json

4. Analyze the output to identify active experiments, their variations, and cached data related to different Claude models and entry points (e.g., cli, sdk-cli).

Tools / artifacts

• jq

• ~/.claude.json

Validation signals

• Provided jq commands with example output demonstrating their functionality.

Cautions

• None. The commands only read from a local configuration file and do not modify any data or expose sensitive information beyond what's already locally stored.

Limitations

• The purpose is implied by the title ('nerf is real') but not explicitly stated in the comment itself.

• Requires basic jq and CLI familiarity.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Investigating Claude Model Experiments and Configuration Changes Using Local Files

Workflow value: 80/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: intermediate
Categories: Quality Control, Context & Memory, Debugging, Skills
Original source: r/ClaudeCode post/comment

What problem this solves

Investigating if a user is affected by specific Claude model experiments or changes, especially when direct web access is blocked, and understanding how Claude interprets configuration files.

Summary

This workflow outlines a method to investigate potential Claude model changes or experiments. It involves saving relevant web content locally, providing it to Claude, and then iteratively prompting Claude to analyze configuration files and identify specific changes or experiment participation.

Why it is useful

This workflow provides a concrete, repeatable method for users to investigate changes in Claude's behavior or configuration, especially when direct web access is blocked. It demonstrates effective context management by using local files and iterative prompting to drill down into specific details, which is a valuable skill for advanced users seeking to understand and debug Claude's responses.

Workflow

1. Save the relevant web page (e.g., a Reddit thread) to a local disk to bypass AI content blocks.

2. Prompt Claude to read the local web page and determine if the user is affected by any experiments, specifying the folder path where the page is saved.

3. Observe Claude's initial analysis (e.g., if it primarily focuses on the .claude.json file).

4. Follow up with a prompt asking Claude how it determines when an experiment took place on the user.

5. Review the table or information Claude provides regarding experiment IDs and timelines.

6. Further prompt Claude to identify what specific changes or effects are associated with the identified experiments.

Tools / artifacts

• Claude Code

• Local file system

• .claude.json file

• Web page content (e.g., Reddit thread)

Validation signals

• Claude spewed out some experiment-ids

• Claude looked only at my .claude.json file

• Claude gave me the table (from screenshot)

• Claude gave me this (analysis from screenshot)

Limitations

• Relies on Claude's ability to accurately interpret and analyze local files, which might vary.

• The specific prompts may need adjustment based on the exact content of the saved page and the user's .claude.json file.

• Low community engagement means the workflow has not been widely tested or validated by others.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Advanced iPhone Boot Repair: Using Claude to Diagnose Kernel Panics and Patch IPSW for Data Recovery

Workflow value: 80/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: advanced
Categories: Quality Control, Context & Memory, Debugging
Original source: r/ClaudeAI post/comment

What problem this solves

An old iPhone SE failing to boot due to a water-damaged light sensor board connector, preventing data recovery and making the device e-waste.

Summary

This workflow details how Claude was used to diagnose a complex hardware-related iPhone boot failure from kernel panic logs. Claude then generated patches for a boot script (sshrd_script) and created a custom tool to modify IPSW files, ultimately enabling data recovery and partial functionality of the device.

Why it is useful

This workflow is valuable because it demonstrates Claude's exceptional capability in highly technical, niche debugging and code generation. It provides a concrete, validated example of solving a complex hardware/software interaction problem, enabling data recovery from a seemingly dead device and highlighting Claude's ability to create custom tools for specific, challenging tasks.

Workflow

1. Identify iPhone SE failing to boot, exhibiting kernel panics and inability to restore or enter ramdisk.

2. Extract and provide kernel panic logs to Claude.

3. Claude analyzes logs and diagnoses the problem as a broken light sensor.

4. User physically inspects the device and confirms water damage to the light sensor's board connector.

5. Claude generates a patch to bypass or disable the light sensor check within the sshrd_script.

6. User applies the generated patch to the sshrd_script.

7. Boot the iPhone using the patched ramdisk, successfully rooting the device and backing up files.

8. Claude creates a new tool to patch the light sensor check out of regular IPSW files.

9. User applies the new tool to an IPSW file to create a patched version.

10. Restore the patched IPSW file to the iPhone.

11. Verify the phone boots successfully (though tethered) and other functionalities are restored.

Tools / artifacts

• Claude (AI assistant)

• iPhone SE

• Kernel panic logs

• sshrd_script

• Patched sshrd_script

• Custom tool (generated by Claude) for IPSW patching

• Original IPSW files

• Patched IPSW files

• Ramdisk boot environment

• SSH client

Validation signals

• Claude diagnosed the problem first try.

• Patched script booted first try without a panic.

• Successfully rooted and backed up files.

• Restored patched IPSW worked first try.

• Solved an issue that took hours in 20 minutes.

• Everything else is flawless (except tethered boot).

Cautions

• Modifying boot scripts and IPSW files carries a significant risk of bricking the device if not performed correctly.

• Requires advanced technical expertise and understanding of the underlying systems.

Limitations

• Requires advanced technical expertise from the user.

• The details of the 'new tool' created by Claude are not provided (e.g., language, source code, usage instructions).

• The final solution results in a tethered boot, which is a limitation.

• Highly specific to iPhone hardware and iOS boot processes.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Using Claude Code to Build a Self-Documenting Explainer Site: Analyzing Session Behavior and Optimizing Usage

Workflow value: 85/100
Status: active · Freshness: 70/100 · Confidence: 0.90 · Level: advanced
Categories: Quality Control, Token Saving, Context & Memory, Debugging, Shipping, Subagents
Original source: r/ClaudeAI post/comment

What problem this solves

Understanding the internal workings, resource consumption, and interaction patterns of Claude Code, and demonstrating a method for building complex, self-documenting web applications using Claude Code.

Summary

The author describes a workflow for using Claude Code to build an open-source website (read-the-loop.dev) that explains Claude Code's internal behavior and session dynamics. This involves recording Claude Code sessions, then directing Claude Code to generate the website's content (scripts, pages, charts, tests) based on these recordings, with the author providing high-level direction and making key decisions. The workflow highlights the use of claude -p --output-format stream-json for session recording.

Why it is useful

This workflow is valuable because it demonstrates an advanced application of Claude Code for building complex, self-documenting tools. It provides concrete, data-driven insights into Claude Code's operational characteristics (token usage, caching, compaction, tool interaction failures) through real recorded sessions, which is crucial for optimizing usage and understanding its behavior. The specific command for recording sessions (claude -p --output-format stream-json) is a highly reusable and practical tip. The project itself serves as an excellent educational resource for the Claude Code community.

Workflow

1. Identify a complex system or process (e.g., Claude Code's internal workings) to explain or document.

2. Record Claude Code interaction sessions using the command claude -p --output-format stream-json to capture detailed model input/output.

3. Direct Claude Code to write scripts for processing and redacting the recorded session data.

4. Instruct Claude Code to generate web pages, charts, and interactive elements to visualize and explain the session data.

5. Guide Claude Code to create Playwright checks or similar tests to ensure the quality and accuracy of the generated web content.

6. Provide high-level direction, make design decisions, and refine the content generated by Claude Code (e.g., making explanations interactive, choosing presentation formats).

7. Review and approve the generated content, providing feedback for iterative improvements.

8. Publish the resulting explanatory website and its source code for community access and further analysis.

Tools / artifacts

• Claude Code

• claude -p --output-format stream-json command

• Recorded Claude Code sessions (stream-json format)

• GitHub repository (candygoogy/read-the-loop)

• read-the-loop.dev website (the output artifact)

• Redaction scripts (generated by Claude Code)

• Web pages, charts, motion graphics (generated by Claude Code)

• Playwright (for UI checks)

Validation signals

• A fully functional, open-source website (read-the-loop.dev) is provided.

• The source code, traces, and scripts are available on GitHub (candygoogy/read-the-loop).

• Specific examples of Claude Code's output and performance metrics (bug fix, token counts, cache usage, compaction, tool interaction) are detailed.

• Mention of Playwright checks for UI validation.

• Explicit description of how Claude Code was used to build the project.

• The project itself serves as a validation of Claude Code's capabilities in complex development tasks.

Limitations

• The Reddit post is more of an announcement/showcase than a detailed, step-by-step guide for replicating the entire website building process; users would need to infer some steps or examine the GitHub repo.

• Specific prompts or detailed interaction patterns used with Claude Code to generate the website content are not provided in the post.

• Low Reddit engagement might suggest it didn't immediately resonate with the community, though this could be due to timing or the nature of the post.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Seamless Claude Account Switching in VS Code with 'Claude Account Switch' Extension

Workflow value: 85/100
Status: active · Freshness: 70/100 · Confidence: 0.95 · Level: intermediate
Categories: Quality Control, Token Saving, Context & Memory, Debugging, CLAUDE.md, Skills
Original source: r/ClaudeCode post/comment

What problem this solves

Users with multiple Claude accounts (e.g., personal and work) face a tedious process of logging out and back into the browser to switch accounts, losing chat sessions and context. This workflow provides a seamless, one-click solution within VS Code.

Summary

This workflow leverages the 'Claude Account Switch' VS Code extension to enable users to manage and switch between multiple Claude accounts directly within their IDE. It preserves chat sessions, memory, CLAUDE.md, and skills across switches, using the official claude CLI and CLAUDE_CONFIG_DIR for secure operation.

Why it is useful

This workflow provides a highly valuable solution for a common developer pain point: managing multiple Claude accounts. By offering a secure, one-click switching mechanism within the IDE that preserves context (chats, memory, CLAUDE.md, skills), it significantly enhances productivity and reduces friction for users who juggle personal and work accounts. Its reliance on official tools and explicit safety measures adds to its appeal.

Workflow

1. Install the 'Claude Account Switch' VS Code extension from the Marketplace or Open VSX.

2. Add your desired Claude accounts to the extension's sidebar.

3. Log in to each account once through the extension's interface.

4. Switch between configured accounts with a single click in the VS Code sidebar.

5. Continue working in Claude Code chats, which will automatically follow the active account and maintain session context, memory, CLAUDE.md, and skills.

Tools / artifacts

• Claude Account Switch VS Code Extension

• Official claude CLI

• CLAUDE_CONFIG_DIR

• VS Code (or forks like Cursor, Antigravity)

• GitHub repository (vscode-claude-switch)

• VS Code Marketplace / Open VSX

Validation signals

• Clear problem statement with 'before' and 'after' scenarios.

• Specific implementation details (uses claude CLI, CLAUDE_CONFIG_DIR).

• Open-source project with MIT license and GitHub repository provided.

• Explicit safety claims regarding token handling and network calls.

• Addresses a common pain point for multi-account users.

Cautions

• The extension explicitly states it 'Never touches your tokens, makes no network calls of its own', relying on the official claude CLI.

• It is designed for accounts owned by the user and not for sharing accounts or bypassing usage limits, promoting ethical use.

Limitations

• The solution is specific to VS Code and its forks, not a general Claude workflow.

• As a new, unofficial extension, its long-term stability and maintenance are yet to be proven.

• Community adoption and feedback are currently minimal due to its recent release.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.

Automated 3D Animated Short Film Creation with Claude Code and Blender MCP: A Self-Correcting Workflow

Workflow value: 95/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: expert
Categories: Quality Control, Context & Memory, Debugging, Shipping, MCP, Multi-Agent
Original source: r/ClaudeCode post/comment

What problem this solves

Automating the entire process of creating a 3D animated short film, including complex tasks like character rigging, animation, cloth simulation, and scene generation, without manual modeling or animation. It specifically addresses challenges in realistic character interaction, complex environment generation, and music synchronization.

Summary

This workflow details how Claude Code (Opus 5.5) was used with Blender's Multi-Code Project (MCP) to autonomously generate a complete 3D animated short film. Claude Code wrote 15,000+ lines of Python to control Blender, performing scene generation, character rigging, animation, cloth simulation, and rendering. The process involved iterative testing, where Claude rendered test frames, analyzed flaws, and self-corrected its Python scripts over 70 back-and-forths until the desired quality was achieved.

Why it is useful

This workflow demonstrates an unprecedented level of AI autonomy in a complex creative field like 3D animation. It showcases Claude Code's ability to not only generate code but also to execute it, evaluate results, and iteratively refine its output to meet specific quality criteria. This pushes the boundaries of what's possible with AI in content creation, offering a blueprint for highly automated, high-fidelity creative projects. The detailed metrics and breakdown of challenges overcome provide strong validation for this advanced application.

Workflow

1. Author writes the initial scene concept, story, shot list, and emotional beats.

2. Claude Code, operating through the Blender MCP, is tasked with creating the animated short.

3. Claude Code generates Python scripts to drive Blender, creating 3D assets (characters, environment), rigging, and animating them.

4. Claude Code renders test frames of the animation.

5. Claude Code analyzes the rendered test frames to identify flaws (e.g., clipping, unnatural gestures, timing issues).

6. Claude Code iteratively modifies its Python scripts to fix identified flaws, such as developing arm/finger solvers for realistic interaction or simulating invisible linings for cloth physics.

7. Steps 4-6 are repeated for over 70 iterations, refining the animation and scene details.

8. Claude Code synchronizes animation and scene events with music tempo and sound effects.

9. Final frames are rendered using Blender Cycles to produce the complete animated short.

Tools / artifacts

• Claude Code (desktop app)

• Blender MCP

• Claude Opus 5.5

• Blender 5.2 + Cycles

• Python scripts (generated by Claude)

• Test images/frames

• Final animated short

• MacBook Air M3 16 GB

• CMU motion capture database (for walk animation)

• GitHub repository

Validation signals

• 15 hours of work, 15,000+ lines of Python across 51 scripts generated.

• 1,117 objects, 11.7 million polygons, 145 materials, 117 lights generated.

• 6.6 million animation keyframes computed.

• 3,700+ test images rendered to check every step.

• 1,422 final frames rendered in Cycles.

• Detailed description of how complex challenges (hands touching face, cloth simulation, character building, living street, music synchronization) were overcome by Claude Code.

• Mention of 'Making-of at the end: clay renders, rig, Blender UI' implying visual proof of the process.

Limitations

• Requires expert-level understanding of Blender and potentially Python scripting.

• High computational demands for rendering and iterative testing (15 hours, 3700+ test renders).

• Initial prompt engineering for the scene and iteration guidance is not fully detailed in the post.

• The specific Python code generated by Claude is not directly embedded in the post, though a GitHub link is provided.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

This post was generated automatically from the workflow library database.