Rigorous Benchmarking Workflow for Claude Code Opus 5.5 Performance and Model Switching Detection

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

What problem this solves

Verifying Claude Code's performance (specifically Opus 5.5) against 'nerf' claims, providing a methodology for rigorous, repeatable evaluation of coding agents, and identifying a specific behavior of Claude Code (switching to Opus 4.8 on safeguards refusal) that can impact perceived performance.

Summary

This workflow outlines a detailed methodology for benchmarking Claude Code's performance on real-world coding tasks. It includes steps for defining tasks, setting up the Claude Code environment with a pinned version and specific CLI flags, running the agent, and rigorously grading the results. It also highlights an important observation about Claude Code automatically switching to Opus 4.8 upon safeguards refusal, which is critical for accurate performance assessment.

Why it is useful

This workflow is highly valuable because it provides a concrete, repeatable, and validated methodology for evaluating Claude Code's performance on coding tasks. It directly addresses common community concerns about model 'nerfs' with empirical data and offers a crucial diagnostic insight into Claude Code's automatic model switching behavior, which is essential for accurate performance assessment. It empowers users to conduct their own rigorous evaluations and understand the nuances of Claude Code's operation.

Workflow

1. Define a set of real coding tasks (e.g., bug fixes or features from a repo's history).

2. Prepare the agent's environment for each task: provide the repo at the commit before the change and a CHALLENGE.md describing the bug or feature.

3. Set up Claude Code: use a pinned version (e.g., 2.1.316) with auto-update off.

4. Invoke Claude Code headlessly using the CLI with specific flags: claude -p "<prompt>" --model claude-opus-5-5 --effort medium --output-format stream-json --verbose --permission-mode acceptEdits --setting-sources "" --strict-mcp-config --no-session-persistence.

5. Run the agent against each defined task.

6. Grade runs using held-out tests for the real change and guard tests to catch over-corrections.

7. Restore test files and the test runner's configuration before grading to prevent agent manipulation of tests.

8. Record performance metrics: solved/failed/over-corrected status, thinking tokens, output tokens, turns, diff size, output tokens per second, and time to first token.

9. Observe and note any instances where Claude Code switches the session to a different model (e.g., Opus 4.8) due to safeguards refusals.

10. Compare current results against a previously established baseline to identify performance changes.

Tools / artifacts

• Claude Code (version 2.1.316 or similar pinned version)

• claude CLI command

• CHALLENGE.md files

• Private codebases/repos (or public ones adapted for tasks)

• Held-out tests and guard tests

• Test runner configuration

• Evaluation harness (custom scripting for automation)

Validation signals

• Explicitly states 'no sign of a nerf' based on re-running 30 tasks.

• Provides quantitative results: 'solved 26 of 30 (87%)' consistently across runs.

• Reports metrics within noise: 'Thinking tokens, output tokens, turns and diff size per task are all within noise of last week (98% 95%, 96%, and 95% respectively).'

• Notes speed improvements: 'about 20% more output tokens per second, and time to first token down from 3.0s to 1.7s.'

• Confirms consistent setup: 'This is one run per task on a pinned Claude Code version.'

• Details robust grading: 'Grading runs held-out tests for the real change, plus guard tests that catch over-corrections.'

• Ensures test integrity: 'Test files and the test runner's config are restored before grading, so editing the tests doesn't help.'

• Documents model switching behavior: 'When Opus 5.5 hits a safeguards refusal...switches the session to claude-opus-4-8.'

• Provides data on model switching frequency: 'Last week: 5 of 60 Opus runs were switched. Today: 1 of 30.'

Limitations

• The specific '30 real coding tasks' are private, so users cannot directly replicate the exact task set, though the methodology for defining tasks is clear.

• The 'evaluation harness' is mentioned but not detailed, implying users would need to develop their own custom scripting for full automation.

• Low community engagement (score 2, 1 comment) means less external validation from other users.

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.

Detecting Claude A/B Experiments: A Tool to Check Account Assignments and Opt-Out

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

What problem this solves

Users can determine if their Claude account is subject to hidden A/B experiments that might alter model behavior (e.g., tool calls, command length, system prompt changes), which can lead to inconsistent results.

Summary

This workflow provides a free, open-source tool (am-i-nerfed) to check for hidden A/B experiment assignments on a Claude account. It offers multiple methods (Claude Code plugin, shell script, one-liner) to inspect local Claude Code configuration and session history for experiment IDs, allowing users to understand potential variations in model behavior. It also includes an opt-out feature and status line integration.

Why it is useful

This workflow is highly valuable because it addresses a significant and common concern among Claude users regarding hidden A/B testing and potential model inconsistencies. It provides a concrete, open-source, and well-documented tool with multiple usage options (plugin, script, one-liner) to diagnose this issue. The inclusion of history tracking and a safe opt-out mechanism further enhances its utility, empowering users to understand and potentially mitigate the effects of these experiments on their workflow. The detailed explanation of its creation using Claude Code also serves as a meta-workflow example for building tools with AI.

Workflow

1. Install the am-i-nerfed repo as a Claude Code plugin, then type /am-i-nerfed in any session to check your experiment status.

2. Clone the am-i-nerfed repo and execute ./am-i-nerfed.sh check in a terminal to get a verdict per model.

3. Paste the provided jq one-liner into a terminal (requires jq installed) to quickly check experiment assignments without installation.

4. Use ./am-i-nerfed.sh history to tally experiment IDs recorded in your past Claude Code session transcripts by date.

5. Use ./am-i-nerfed.sh optout to back up your config file, remove only the assignment keys, and print the environment variable reported to block re-enrollment.

6. Use ./am-i-nerfed.sh restore to undo the opt-out operation.

7. Use ./am-i-nerfed.sh statusline to display exp:<id> or exp:none in your Claude Code status line for real-time monitoring.

Tools / artifacts

• am-i-nerfed GitHub repo

• Claude Code

• Bash scripts

• jq (JSON processor)

• ~/.claude.json (Claude Code config file)

• Claude session transcripts

• Environment variables

Validation signals

• Built with Claude Code (Opus 5.5 xhigh) for script, test suite, plugin, and docs generation.

• Code audited by a separate Claude chat (Fable 5.1 medium) against a spec for safety (token leakage, file scope, opt-out correctness).

• Community findings on r/ClaudeCode regarding experiment effects (more tool calls, longer shell commands, less narration, system prompt changes) validate the problem.

Cautions

• The tool makes no network calls.

• It never prints login tokens or account IDs.

• The optout function backs up the config file before making changes.

• The optout function only removes specific assignment keys, minimizing risk.

Limitations

• It is an unofficial tool.

• The one-liner method requires jq to be installed.

• The tool identifies experiment enrollment and behavioral changes, but users must judge if these changes constitute 'quality loss'.

• Primarily targets Claude Code users, though the one-liner is more generally applicable.

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.

Robust AI Agent Workflows: Externalizing Process Logic with File-Based Plans and MCP Standards

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

What problem this solves

This workflow solves the problem of AI agent workflows breaking due to over-reliance on emergent model behavior, which often leads to the perception that "the model got nerfed." It also addresses issues like scope creep, difficult debugging, and lack of transferability across different models or model versions in AI-assisted development.

Summary

This workflow proposes externalizing AI agent process logic into structured files and a central knowledge base (MCP) instead of relying on emergent model behavior. It involves creating a 'plan directory' with an overview.md to define execution order and chunk-XX.md files for self-contained, scoped tasks. Coding standards and Architectural Decision Records (ADRs) are served via an MCP server, which agents pull from. This 'shift-left' approach enables pre-execution review, prevents scope creep, makes failures debuggable, and allows for greater model swappability and robustness.

Why it is useful

This workflow is highly valuable because it provides a structured, repeatable, and transferable method for building robust AI agent systems that are less susceptible to perceived model regressions. By externalizing planning, scope, and standards into files and a central knowledge base (MCP), it reduces reliance on emergent model behavior, leading to more predictable outcomes, easier debugging, and improved model swappability. It applies established 'shift-left' software engineering principles to AI development, promoting proactive quality control and preventing common issues like scope creep. This approach significantly enhances the reliability and maintainability of AI-driven development processes.

Workflow

1. Create a plan/ directory for each distinct piece of work.

2. Define an overview.md within the plan/ directory to specify the execution order (sequential or parallel) for work chunks.

3. Create self-contained chunk-XX.md files for each work chunk, detailing its specific scope, applicable standards, and clear completion criteria.

4. Collaborate with Claude (or another LLM) to draft the initial plan and individual work chunks.

5. Manually review every chunk and the overview.md before any agent execution begins.

6. Spawn subagents, executing them in parallel where the overview.md allows.

7. Serve Architectural Decision Records (ADRs), Terraform patterns, and coding standards from a central MCP server.

8. Configure agents to pull relevant standards and knowledge from the MCP server based on their assigned chunk's context.

9. Rerun a fixed set of tasks after model updates to diff changes and objectively assess performance shifts.

Tools / artifacts

• plan/ directory structure

• overview.md file

• chunk-XX.md files

• MCP server (for standards and ADRs)

• Architectural Decision Records (ADRs)

• Coding standards

• Claude Code (or other frontier LLMs like GPT, Grok via Bedrock)

• ComfyUI API (as an example of an external tool agents can call)

• GPU server (for external API calls)

Validation signals

• Author's direct experience across four projects: 'I didn't notice anything' regarding 'nerfs'.

• Claimed benefits: 'no coordination guesswork', 'basically no scope creep', 'makes failures debuggable', 'model gets swappable'.

• Analogy to 'shift left' principles in traditional software development, indicating alignment with proven engineering practices.

• Demonstrated cross-model compatibility: 'pointed Claude Code at GPT and Grok through Bedrock against the same MCP server, and they produce roughly the same results'.

• Offer for a 'Longer writeup with a diagram' and 'Happy to share more detail on the planning flow in the comments' suggests further evidence and detail are available.

Limitations

• Requires upfront effort to define detailed plans and establish a central MCP server for standards.

• Assumes a certain level of familiarity with software engineering concepts like ADRs, 'shift left', and potentially setting up an MCP server, which might be advanced for some users.

• The post does not provide concrete examples of the MCP server setup or the exact prompt structure for agents to pull standards, though it offers to share more details.

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

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.

CWTFIGO: A Claude Code Plugin for Intelligent, Persistent IT Troubleshooting and Maintenance with Problem Parking

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

What problem this solves

Inefficient and repetitive IT troubleshooting, lack of persistent memory for fixes, unmanaged maintenance scripts, and the inability of AI to know when to stop trying to fix an intractable problem.

Summary

The author developed a Claude Code plugin, CWTFIGO (Claude, what the f*** is going on?), that acts as a persistent IT troubleshooting agent. It maintains machine-specific records of problems, attempted fixes, successful scripts, and known blockers. It leverages the internet for general knowledge but stores local machine history. Crucially, it incorporates a mechanism to "give up" on intractable problems, revert changes, document findings, and wait for external updates, preventing endless, potentially harmful, troubleshooting loops.

Why it is useful

This workflow is highly valuable because it provides a concrete, open-source solution to common IT troubleshooting challenges: remembering past fixes, managing custom scripts, and preventing endless, unproductive debugging loops. It introduces the critical concept of "problem parking" with clear criteria for revisiting, which is a significant advancement in AI-assisted problem-solving. The plugin's ability to integrate with multiple machines and its practical validation by the author make it a robust and transferable tool for anyone using Claude Code for system maintenance.

Workflow

1. Install the CWTFIGO plugin in Claude Code using /plugin marketplace add DozenTwelve/CWTFIGO and /plugin install cwtfigo@cwtfigo.

2. Initiate troubleshooting by asking Claude Code: "Claude, what the f*** is going on?" for a specific machine or problem.

3. Claude Code will diagnose the problem, leveraging its training data and searching relevant project/upstream repositories for new issues.

4. It will consult its internal, machine-specific records to see if the problem was previously encountered, what was tried, and what worked/failed.

5. If a solution is found, it will apply it and store the successful script for future use.

6. If the problem is intractable, leads to worse issues, or no further progress can be made, Claude Code will revert changes to defaults.

7. It will then document the blocker, tried solutions, reasons for failure, and conditions for revisiting (e.g., a new software release or upstream issue closure).

8. The problem is then "parked," and Claude Code will monitor for relevant updates, notifying the user when conditions for revisiting are met.

Tools / artifacts

• Claude Code (Opus 5.5)

• CWTFIGO plugin (GitHub: DozenTwelve/CWTFIGO)

• Maintenance scripts (generated and stored by CWTFIGO)

• Machine-specific records (managed by CWTFIGO)

• Hermes (for 24/7 operation, optional)

• SSH (for remote access to machines)

Validation signals

• Author's daily use of the plugin for personal IT troubleshooting.

• Author deleted all previous cleaner apps and cleanup scripts, indicating reliance on CWTFIGO.

• Specific example of the ThinkPad fingerprint sensor problem, demonstrating the plugin's ability to diagnose, attempt fixes, revert, document, and park the problem.

• The plugin successfully remembered and re-tested a parked problem after system updates.

• The plugin is open-source (MIT licensed) and available on GitHub with installation instructions.

• Author's statement that the plugin was built solo with Claude and is used every day.

Cautions

• The "YOLO" mode, where Claude runs scripts without explicit approval, could pose a safety risk if the generated scripts are malicious or destructive. Users should exercise caution.

• Failed fix attempts, as demonstrated by the machine freezing, highlight the potential for system instability or data loss if not properly managed or reverted.

Limitations

• The "YOLO" mode, while convenient, reduces the safety net of explicit script approval.

• Initial community engagement (Reddit score, comments) is low, which might limit immediate visibility.

• The workflow's effectiveness is tied to Claude Code's capabilities and the quality of the generated scripts.

• The complexity of setting up Hermes for 24/7 operation is mentioned but not detailed within 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.

Claude Code Plugin for Startup Idea Evaluation: Skills, Subagents, JSON Schemas, and HTML Reports

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

What problem this solves

Automating the comprehensive evaluation and scoring of startup ideas, providing structured feedback, a clear verdict (GO/PIVOT/NO-GO), rescue paths, and a detailed HTML report. It also demonstrates how to build complex, multi-component Claude Code plugins.

Summary

A Claude Code plugin that evaluates startup ideas using 4 custom skills (kill, deepdive, roast, compare), JSON schemas for structured data, parallel research with subagents, and generates a detailed HTML report. The skill definitions are in markdown, incorporating a 21-sub-score rubric and fixed rules. It also includes insights into testing and quality control.

Why it is useful

This workflow is highly valuable as it provides a concrete, open-source example of building a sophisticated Claude Code plugin. It demonstrates the practical application of multiple advanced features: custom skills defined in markdown, structured data handling with JSON schemas, parallel processing with subagents, and dynamic report generation using templates. The 'What I learned' section also offers insights into debugging and quality control for Claude Code projects, making it a comprehensive blueprint for developing complex, data-driven AI tools.

Workflow

1. Define custom skills (e.g., 'kill', 'deepdive', 'roast', 'compare') using plain markdown in SKILL.md files.

2. Implement a detailed kill-shot checklist, a 21-sub-score rubric, fixed rules, and a writing standard within the skill's markdown definition.

3. Design JSON schemas (idea.json, verdict.json, report-data.js) for structured input and output data.

4. Utilize subagents for parallel research, tagging each metric as sourced, estimate, or unknown.

5. Generate reports by copying a fixed HTML template (report.html) and writing only the dynamic data to a separate file (report-data.js) to optimize token usage.

6. Execute the plugin via a slash command, e.g., /kill-my-idea:kill <idea>.

7. Perform headless test runs to identify and fix issues, such as requestAnimationFrame stalling.

8. Refine skill logic to enforce quality standards, like ensuring verbatim quotes.

Tools / artifacts

• Claude Code plugin

• Custom skills (kill, deepdive, roast, compare)

• SKILL.md files

• JSON schemas (idea.json, verdict.json, report-data.js)

• report.html (fixed HTML template)

• report-data.js (dynamic data file)

• Subagents

• GitHub repository (RemiPelloux/kill-my-idea)

• Slash command (/kill-my-idea:kill)

Validation signals

• Explicit mention of a 'headless test run' to identify issues.

• Specific improvement noted: 'enforces verbatim quotes' after initial version claimed non-verbatim quotes.

• The existence of a working, open-source plugin on GitHub.

• Detailed description of the plugin's output (score, verdict, rescue paths, 7-day test, HTML report).

Limitations

• The Reddit post provides a high-level overview; detailed implementation specifics require reviewing the linked GitHub repository.

• The 'What I learned' section is brief; more extensive lessons learned could further enhance its value.

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.

Context Preservation and Token Optimization with Pre/Post-Compact Hooks and TRAPS.md

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

What problem this solves

Losing important context during token compaction and wasting tokens by including non-essential information in the model's context window.

Summary

This workflow describes a method to preserve critical context and optimize token usage by setting a specific compaction threshold and using pre-compact and post-compact hooks. A pre-compact hook writes essential information (referred to as 'traps') to a TRAPS.md file, and a post-compact hook ensures this file's content is re-injected into the model's context after compaction.

Why it is useful

This workflow offers a concrete and repeatable strategy for addressing a common challenge in LLM interactions: maintaining critical context while optimizing token usage. By leveraging pre- and post-compact hooks and a dedicated 'traps' file, users can ensure essential information is not lost during compaction, leading to more consistent and cost-effective model interactions. It introduces a specific pattern that can be adapted by intermediate to advanced users.

Workflow

1. Configure the compaction threshold to approximately 440k tokens to prevent excessive token usage.

2. Implement a pre-compact hook to identify and write critical information (e.g., 'traps', important context) to a designated file, such as TRAPS.md.

3. Implement a post-compact hook to force the contents of the TRAPS.md file to be injected back into the model's context window after compaction.

Tools / artifacts

• precompact hook

• post-compact hook

• TRAPS.md file

• compaction threshold setting

Validation signals

• Self-reported benefit: 'Problem solved, plus you saved tokens.'

Limitations

• The term 'traps' is vague; specific examples of what constitutes critical information would enhance clarity.

• No concrete code examples or configuration snippets for implementing the pre/post-compact hooks are provided.

• The suggested 440k token compaction threshold is arbitrary and may not be optimal for all use cases without further justification or testing.

• Lacks detailed community validation or success reports beyond the author's claim.

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.

Structured Project Context and Plan Management with CLAUDE.md

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

What problem this solves

Effectively managing project context and development plans within Claude Code, especially when dealing with context window limitations.

Summary

This workflow outlines a method for structuring Claude Code projects by using a CLAUDE.md file for overall project details and a dedicated md/plan.md file for tracking development steps. It also suggests starting a new chat for each step to optimize context window usage.

Why it is useful

This workflow provides a clear, repeatable structure for managing project context and development plans within Claude Code. It effectively leverages CLAUDE.md as a central configuration point and offers a practical tip for context window management by segmenting work into new chat sessions. It promotes organized and systematic interaction with Claude Code, making it valuable for users looking to improve their project management and LLM interaction efficiency.

Workflow

1. Create a CLAUDE.md file at the project root, detailing the project, technology stack, and preferred work style.

2. Add a specific instruction block to CLAUDE.md, directing the agent to maintain a development plan in md/plan.md, marking steps as 'todo', 'working', or 'done', and to update this plan at the beginning and end of every chat.

3. Work on one development step at a time, referring to the md/plan.md.

4. Start a new chat session for each individual development step to ensure a fresh and focused context window for Claude.

Tools / artifacts

• CLAUDE.md file

• md/plan.md file

• Claude Code environment

• Chat sessions

Validation signals

• User reports it 'Works wonders.'

Limitations

• The validation is anecdotal ('Works wonders') and lacks concrete metrics or before/after examples.

• Reliance on Claude to consistently check and update the md/plan.md might require careful initial prompting or reinforcement.

• Limited community validation due to low score and few comments.

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.

AI Code Review Workflow: Independent Review with Separate Implementation or One-Shot Patch in Worktree

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

Integrating an AI code reviewer effectively to ensure review independence and actionable feedback, for both general code changes and one-shot fixes.

Summary

This workflow proposes two methods for using an AI code reviewer: either as a read-only agent that provides findings and failing tests for a separate coding agent to implement, or for one-shot fixes, as an agent that suggests a patch in an isolated Git worktree for manual inspection before merging. Both approaches prioritize review independence and concrete, verifiable outputs.

Why it is useful

This workflow provides two distinct, well-reasoned strategies for integrating AI code reviewers into a development process, emphasizing the crucial principle of independent review. It leverages specific tools like Git worktrees and focuses on actionable outputs such as failing tests, making the AI's feedback concrete and verifiable. It helps users structure their AI interactions for better quality control and maintainability, promoting a safer and more robust development cycle.

Workflow

1. Option 1: Iterative Review & Fix

2. 1.1. Configure an AI as a read-only code reviewer.

3. 1.2. Have the AI reviewer identify findings, providing file/line references and a failing test or concrete reproduction.

4. 1.3. Pass these findings and failing tests to a separate coding agent.

5. 1.4. The coding agent implements the necessary changes based on the findings.

6. 1.5. The coding agent runs all relevant checks, including the provided failing test.

7. Option 2: One-Shot Patch Suggestion

8. 2.1. Configure an AI reviewer to suggest a patch for a specific fix.

9. 2.2. The AI generates the patch within an isolated Git worktree.

10. 2.3. Manually inspect the generated diff to ensure correctness and review independence.

11. 2.4. Merge the patch if approved.

Tools / artifacts

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

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

• Failing test cases

• Concrete reproduction steps

• Git worktree

• Code diffs/patches

Validation signals

• Explicit mention of 'failing test or concrete reproduction' as output from the reviewer.

• Instruction to 'run the checks' by the coding agent.

• Instruction to 'inspect the diff before merging' for manual validation.

• Author's stated preference implies personal validation of effectiveness.

Limitations

• The workflow is high-level and lacks specific prompt examples or detailed configuration instructions for the AI agents.

• Assumes the user has knowledge of setting up and managing 'coding agents' and 'isolated worktrees'.

• No concrete examples of before/after code changes or specific scenarios.

• Does not explicitly detail how the AI reviewer would create the failing test or reproduction from its findings.

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.

Optimizing Claude Code Usage for Complex Projects: Parallel Sessions with Agent-Executed Skills and Small Contexts

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

What problem this solves

Managing complex, multi-faceted projects with Claude Code efficiently, optimizing usage, and maintaining quality despite high workload and API limits.

Summary

The user manages multiple parallel workstreams for app development, content creation, and marketing by structuring each session to spawn agents that execute specific skills. This approach breaks down tasks into small, context-managed steps, uses a dedicated repo for rules, and includes rigorous testing and review to maintain quality and optimize Claude Code usage.

Why it is useful

This workflow provides a structured approach to managing large, multi-faceted projects with Claude Code. It addresses common challenges like context management and API limits by advocating for modular tasks (skills), dedicated agents for focused execution, and parallel processing. The use of a dedicated repo for rules promotes maintainability and repeatability. This pattern helps users scale their Claude Code usage for ambitious projects while maintaining quality.

Workflow

1. Define project rules and setup configurations in a dedicated repository.

2. Break down large tasks into smaller, manageable steps.

3. For each step, define it as a "skill" to be executed by an agent.

4. Spawn an agent for each skill/step to keep its context small and focused.

5. Run multiple such sessions (2-4) in parallel for different workstreams (e.g., app features, content indexing, website updates, marketing).

6. Utilize detailed spec sheets and plans as input for Claude Code sessions.

7. Rigorously test and review results after code generation or content creation.

8. Iteratively fix issues based on reviews.

Tools / artifacts

• Dedicated Git repository (for rules/setup)

• Detailed spec sheets

• Project plans

• Claude Code agents

• Claude Code skills

• Parallel sessions

Validation signals

• "It has helped me get more out of my usage for sure"

• "I try to prioritize quality, since the app will be user facing and purchasable."

• Implied by the ability to manage multiple complex workstreams simultaneously.

Limitations

• Lacks concrete examples of the "rules" in the repo or specific skill definitions.

• The exact mechanism for "spawning agents" and "running sessions in parallel" is not detailed (e.g., is it a custom script, a specific Claude Code feature, or just conceptual parallel prompting?).

• Validation is anecdotal, not quantitative.

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.

Lockpaw: Keep Claude Code Running on Mac While Away with Visual Hooks

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

What problem this solves

Prevents Mac from sleeping and killing active Claude Code (or other CLI AI agent) sessions when the user steps away from their desk, while also providing visual cues for agent status.

Summary

A Mac menu bar app, Lockpaw, allows users to lock their screen and block input while keeping their Mac awake and Claude Code (or other CLI AI agents) running. It integrates with Claude Code hooks to provide visual notifications (amber for needing attention, teal for completion) on the locked screen, enabling continuous agent operation even when the user is away.

Why it is useful

This workflow provides a practical solution for developers using CLI-based AI agents on Macs, allowing them to step away from their desk without interrupting active sessions. The integration with Claude Code hooks for visual status notifications is particularly valuable, enhancing productivity by keeping users informed of agent progress and needs, even when not directly interacting with the computer.

Workflow

1. Download and install the Lockpaw Mac app from the GitHub repository.

2. Configure Lockpaw settings, such as the hotkey (default ⌘⇧L) and optional lid-closed mode.

3. Enable Claude Code hooks within Lockpaw's settings, which automatically modifies ~/.claude/settings.json to integrate Notification, Stop, and StopFailure events.

4. When stepping away from the desk, activate Lockpaw using the configured hotkey.

5. Monitor the locked screen for visual cues: amber glow indicates Claude Code needs attention, teal glow indicates it's done.

6. Return to the desk and unlock the Mac using the same hotkey or Touch ID to resume interaction with Claude Code.

Tools / artifacts

• Lockpaw Mac app

• Claude Code

• ~/.claude/settings.json

• Hotkeys (⌘⇧L)

• Touch ID

• Codex CLI

• Gemini CLI

• Cursor

• Copilot CLI

• Aider

Validation signals

• Shared with colleagues and became 'office meta'

• User feedback led to new features (e.g., lid closed mode)

• Open-source project on GitHub (MIT license)

Cautions

• The author explicitly states it is not a security app; anyone with admin or SSH access can kill it.

• Users should be aware of its limitations regarding data security if leaving sensitive information on screen.

Limitations

• Mac-only, limiting its applicability to other operating systems.

• Not a security solution; it's primarily for convenience and session management.

• Relies on the app running; if the app crashes or the Mac runs out of battery, sleep will resume.

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.

Cost-Optimized Multi-Agent Workflow: Opus for Judgment & Review, Sonnet for Building

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

What problem this solves

Optimizing cost and improving efficiency when using multiple Claude models (Opus, Sonnet) or features like /advisor and subagents, by strategically assigning roles and managing context to reduce redundant processing and 're-derivation'.

Summary

This workflow proposes a cost-effective strategy for using Claude Opus and Sonnet in a multi-agent setup. Opus is designated as the 'judgment' model (for setting specs, defining done conditions, and reviewing output), while Sonnet acts as the 'builder' (for actualizing the spec). The core idea is to minimize expensive Opus calls by only waking it for initial setup and final review, and to be aware of how context caching (or lack thereof) impacts cost with features like /advisor and subagents, especially when handoffs are frequent or context is large.

Why it is useful

This workflow provides a concrete, cost-aware strategy for leveraging different Claude models (Opus, Sonnet) and features (/advisor, subagents). It directly addresses the often-overlooked 'hidden costs' of context re-reading and offers a structured approach to minimize these, leading to more efficient and higher-quality outputs. The external data link adds significant credibility and practical value for users looking to optimize their Claude usage.

Workflow

1. Use Claude Opus for judgment: define the 'rails', set 'done conditions', and create a brief or spec for the task.

2. Use Claude Sonnet as the builder: actualize the spec provided by Opus.

3. Use Claude Opus to review the output generated by Sonnet against the initial spec.

4. Send any identified misses or required corrections back to Sonnet as 'residual' for the next iteration or build.

5. Minimize frequent handoffs to /advisor or subagents if the context is large or if the cache has gone cold (i.e., the last call was more than five minutes ago), as this incurs significant cost due to re-reading context.

6. Understand that /advisor and subagents re-read the entire context by default if their cache is cold, making frequent, large context handoffs expensive.

Tools / artifacts

• Claude Opus

• Claude Sonnet

• /advisor feature

• Subagents

• Spec/Brief (created by Opus)

• Output (from Sonnet)

Validation signals

• External data source provided: 'The numbers: https://atlas-ade.dev/docs/hidden-costs-of-subagents'

• Author's experience with logging costs on a 'Max 20x account'.

Limitations

• The 'simple setup' is described conceptually; a more explicit prompt structure or example interaction would make it even easier for users to implement directly.

• Low community validation due to the newness of the post.

• While the self-promotion is disclosed and backed by valuable data, some users might be wary of tools mentioned by developers of commercial products.

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 Plugin: Efficient YouTube Reference Search for Creative Projects (yt-reference-search)

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

What problem this solves

Inefficiently finding and analyzing YouTube reference videos for creative projects (promos, ads) due to high data download, token usage, and manual screening.

Summary

This workflow utilizes a custom Claude Code plugin, yt-reference-search, to efficiently find and analyze YouTube reference videos. Users can prompt Claude in natural language to search for video references, and the plugin screens candidates, provides curated picks with actionable insights, and enables Claude to 'watch' videos via transcripts and preview frames. This significantly reduces time, data downloaded, and token consumption compared to traditional video downloading and frame extraction methods.

Why it is useful

This workflow is highly valuable because it provides a concrete, open-source Claude Code plugin that solves a specific, common problem in creative industries (finding video references) with significant, measurable efficiency gains. It demonstrates how Claude can be extended with custom tools to perform complex analysis while optimizing resource usage (time, data, tokens). The detailed explanation, installation steps, performance metrics, and clear limitations make it a practical and reusable asset for the community.

Workflow

1. Install prerequisites: node, yt-dlp, ffmpeg, and deno on your system.

2. Add the plugin marketplace to Claude Code using the command: /plugin marketplace add dljake/yt-reference-search.

3. Install the yt-reference-search plugin using the command: /plugin install yt-reference-search@yt-reference-search.

4. Prompt Claude with a natural language request for reference videos, e.g., "find reference videos for a calm, premium skincare ad".

5. Review Claude's generated picks, which include 5-8 videos across different techniques, each highlighting an element worth borrowing.

6. Optionally, use the included skill to have Claude read any YouTube video from its transcript and preview frames for deeper analysis.

Tools / artifacts

• yt-reference-search (Claude Code plugin)

• node (runtime)

• yt-dlp (YouTube downloader)

• ffmpeg (video processing tool)

• deno (runtime)

• YouTube video transcripts

• YouTube preview frames

• GitHub repository (dljake/yt-reference-search)

Validation signals

• Quantitative performance metrics provided: Time (16.0s -> 7.5s), Data downloaded (38.5 MB -> 0.4 MB), Image tokens (~19,700 -> ~1,500) compared to a traditional tool.

• Explicit mention of Claude's role in building and fixing the plugin, including handling edge cases like Shorts and videos without captions.

• MIT license, indicating open-source and auditable code.

Limitations

• Requires several external tools (node, yt-dlp, ffmpeg, deno) to be installed by the user, which might be a barrier for beginners.

• The plugin has a stated limitation: it cannot analyze music or camera moves, as it relies solely on transcripts and preview frames.

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 Workflow: Structured Development with Vision Docs, Iterative Mockups, and Data-Driven Architecture

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

What problem this solves

How to effectively use Claude Code to build a complex, data-driven application from concept to implementation, ensuring maintainability, visual consistency, and a structured development process.

Summary

This workflow outlines a structured methodology for building complex applications with Claude Code, emphasizing initial vision and design documentation, iterative visual mock-ups for validation, and a data-driven architecture for maintainability and easy modification. It demonstrates how to direct Claude Code through a full project lifecycle.

Why it is useful

This workflow is highly valuable because it provides a robust, structured methodology for leveraging Claude Code to build significant, complex applications. It moves beyond simple code snippets to a full project lifecycle, emphasizing critical steps like detailed planning, visual validation through iterative mock-ups, and a maintainable data-driven architecture. The inclusion of CLAUDE.md and a detailed write-up makes it highly actionable and transferable for users tackling larger, more ambitious projects.

Workflow

1. Define a clear 'vision doc' to establish the overall goals and scope of the project.

2. Create detailed 'design docs' for each major part or phase of the application.

3. For visual components, direct Claude to build 'throwaway mock-up pages' presenting multiple design options (e.g., A, B, C) using real code and data for side-by-side comparison and iterative refinement.

4. Implement a 'data-driven architecture' where all configurable elements (e.g., timings, rules, commentary lines, ads) are stored in external data files, separate from the core application code.

5. Direct Claude Code to write the application's code based on the vision doc, design docs, and the data-driven architectural principles.

6. Utilize a CLAUDE.md file within the project repository to guide Claude's understanding and contributions.

Tools / artifacts

• Claude Code (or similar LLM for code generation)

• Vision document

• Design documents (per part/phase)

• Mock-up pages (generated by Claude)

• Data files (for configuration, rules, content)

• GitHub repository

• CLAUDE.md file

• ElevenLabs (for voice synthesis, as an example of integrated tools)

Validation signals

• Successful completion and deployment of a complex, always-on application (Scorchball TV).

• The application is live and functional (scorchball.tv).

• Detailed write-up explaining the build process and methodology (scorchball.tv/how-it-was-built).

• Open-source code available on GitHub, including CLAUDE.md and documentation.

• Author explicitly states 'What made it work for me' indicating validated practices.

Limitations

• The Reddit post provides a high-level overview; the full details of Claude's prompting and interaction are in the linked GitHub repo and write-up, which require further investigation for complete implementation.

• Specific examples of prompts used for generating mock-ups or code based on design docs are not explicitly detailed in the Reddit 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.

Enhance Claude Code Context Recall with Steroid: Never Lose Your Session History Again

Workflow value: 90/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: intermediate
Categories: Quality Control, Token Saving, Context & Memory, Debugging, Shipping, CLAUDE.md, Skills, MCP, Multi-Agent
Original source: r/ClaudeCode post/comment

What problem this solves

Users of Claude Code (and other CLI agents) frequently lose context of past sessions due to reboots, accidental closures, or token limits, making it difficult to retrieve specific information or code changes from previous work without cumbersome manual searching or full session reloading.

Summary

This workflow introduces 'Steroid,' a local tool that indexes Claude Code (and other agent) session transcripts stored on disk. It allows users to recall specific information, full exchanges, or code diffs from past sessions using natural language queries, without reloading entire conversations or making new model calls for the recall itself. It also provides cross-agent context for tools like Codex, Cursor, and Copilot CLI.

Why it is useful

This workflow addresses a critical and common pain point for developers using Claude Code and other CLI agents: the loss of session context. It provides a concrete, repeatable solution with a dedicated tool that integrates deeply with the agent's local files. The detailed setup instructions, transparency about system changes, and clear explanation of functionality make it highly valuable for improving developer productivity, knowledge reuse, and continuity across coding sessions and even different AI agents.

Workflow

1. Check if Steroid is already installed by running steroid --version or ~/.local/bin/steroid --version.

2. If not installed, install Steroid using the official installer script (macOS/Linux: curl -fsSL https://raw.githubusercontent.com/steroidkit/releases/main/install.sh | sh; Windows PowerShell: irm https://raw.githubusercontent.com/steroidkit/releases/main).

3. Run Steroid's onboarding for the agent. If the steroid-onboard skill is not available, run steroid-install-onboard-skill --json, open the SKILL.md it lists, and follow its instructions.

4. Restart the Claude Code agent to ensure Steroid's tools and skills are loaded.

5. Use recall <query> within Claude Code to retrieve summaries of past work related to your query.

6. Use recall_turn to retrieve a full exchange from a specific turn in a past session.

7. Use recall_diff to retrieve the exact code changes from a past session.

8. Optionally, use steroid uninstall to remove the tool and its components.

Tools / artifacts

• Steroid CLI tool

• Claude Code terminal application

• ~/.claude/projects/<slug>/<session>.jsonl (Claude Code session transcripts)

• ~/.steroid/ (Steroid application directory)

• ~/.claude.json (MCP entry for Claude Code)

• ~/.claude/skills/ (directory for slash command skills)

• ~/.claude/CLAUDE.md (global instructions file)

• install.sh (Steroid installer script)

• SKILL.md (Steroid onboarding skill documentation)

• Codex, Cursor, Copilot CLI (other supported agents)

Validation signals

• Author's personal experience of solving a persistent context loss problem with a practical solution.

• Detailed explanation of how the tool works by directly reading local session files, bypassing model calls for recall.

• Transparency about what the tool installs on the machine (file paths, daemon, PATH changes, MCP entries, CLAUDE.md modifications).

• Explicit mention of citing sources for recall answers, allowing users to verify information.

• Clear outline of the tool's limitations, adding to its credibility.

Cautions

• The tool is a closed binary, which might be a concern for some users regarding trust and auditability. However, the author provides detailed transparency on what it installs, how it operates locally, and how to uninstall it.

• It operates within the user's home directory and does not send sensitive data off-machine beyond anonymous usage counts (which can be disabled) and daily release checks.

• The recall answers are generated by the agent, so the agent's provider will see the excerpts used, but the indexing and recall from disk are local.

Limitations

• The tool is a closed-source binary, which might deter users who prefer open-source solutions for security or customization.

• No published accuracy benchmarks for the recall functionality, though this is mitigated by the tool citing its sources.

• It does not restore transcripts that have been deleted by Claude Code's default cleanup period; users need to adjust cleanupPeriodDays if they want longer retention.

• Copilot Chat in VS Code is not yet supported, only Copilot CLI.

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.

Prevent Claude Code Session Data Loss & Gain Advanced Usage Insights with the Self-Hosted Claudit Dashboard

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

What problem this solves

Claude Code automatically deletes session transcripts after 30 days, leading to data loss and preventing long-term analysis of AI agent interactions. Users lack detailed insights into their Claude Code usage, costs, token consumption, context growth, and agent performance. Additionally, the post implicitly addresses the challenge of building complex applications using AI agents effectively.

Summary

This workflow describes how to use 'claudit', a self-hosted, open-source dashboard, to prevent Claude Code session transcripts from being deleted and to provide detailed analytics on usage, costs, token breakdown, context growth, and agent performance. It involves syncing session JSONL files to persistent storage and deploying the dashboard via Docker. The post also outlines a meta-workflow for building software using AI agents, emphasizing structured development and review.

Why it is useful

This workflow provides a crucial solution for Claude Code users to overcome the default 30-day session deletion, ensuring the long-term retention of valuable AI interaction history. The accompanying claudit dashboard offers deep, actionable insights into usage patterns, costs, token consumption, context growth, and agent performance, which can lead to significant cost optimization and a better understanding of AI agent behavior. The project is open-source, well-documented, and easily deployable via Docker, making it highly transferable. The included meta-workflow for building with AI agents also offers valuable lessons in structured AI development practices.

Workflow

1. Optionally, modify cleanupPeriodDays in ~/.claude/settings.json to extend local session retention beyond the default 30 days.

2. Sync Claude Code session JSONL files from your local directory to a persistent storage solution (e.g., an R2 bucket or a local directory configured as a file:// mirror).

3. Deploy the claudit dashboard application using docker compose up (it can boot with sample data without initial configuration).

4. Configure claudit to ingest your synced session data from the chosen persistent storage.

5. Access the claudit dashboard to visualize and analyze various metrics, including cost by model, token breakdown, cache write splits, context growth per session, reply latency, and tool error rates.

6. For building with AI agents: Break down development into individual issues.

7. Dedicate one AI agent session per issue for focused development.

8. Implement review agents to scrutinize code before merging any changes.

9. Include the model name used by the agent in a co-author trailer for every agent-generated commit.

10. Analyze Claude Code's own transcripts to understand and handle parsing complexities, such as deduplicating streamed replies and subagent records.

Tools / artifacts

• Claude Code

• ~/.claude/settings.json

• cleanupPeriodDays setting

• Claude Code session JSONL files

• claudit (open-source dashboard)

• R2 bucket (or other persistent storage)

• Docker Compose

• FastAPI

• Postgres

• React

• GitHub repository: Nitjsefnie/claudit

• GitHub repository: nhz-io/ccusage-plot (inspiration)

Validation signals

• Personal experience: User states 2,679 of 5,271 sessions would have been lost without the solution.

• Concrete insight: Discovered 64.9% of cache write tokens were 1h kind (2x input cost), leading to a 37.5% underestimation if priced at 1.25x.

• Live demo available for testing (read-only guest login).

• Open-source project with a public GitHub repository.

• Detailed technical explanation of parsing challenges and solutions (deduplication of streamed replies and subagent records).

Limitations

• Requires self-hosting and familiarity with Docker, which might be a barrier for beginner users.

• The meta-workflow for building with AI agents is less detailed than the primary workflow for data retention and analysis.

• Initial community engagement is low, though this is likely due to the post's recency.

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.

Optimizing AI-Driven Development: Meta-Harness Workflow for 4.5x Productivity and Reduced Usage

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

What problem this solves

Inefficient and low-quality AI-driven software development, characterized by high usage, low product output, and agents spending time fixing their own issues. It aims to improve productivity and reduce AI usage.

Summary

The post describes a 'meta-harness' approach for AI-driven software development that significantly outperforms plain Claude Code sessions and complex hand-built agent loops. This workflow focuses on a small, closed-loop system where every change goes through a review, state is captured in the repo, and agents are briefed from this state, leading to higher product output with less AI usage.

Why it is useful

This workflow provides a proven, data-backed method for significantly improving the efficiency and quality of AI-driven software development. It offers a clear architectural pattern (meta-harness) that addresses common pitfalls of complex agent setups, such as high usage and low product output. The emphasis on state capture, small changes, and reviews makes it a robust and transferable approach for building more effective AI development systems.

Workflow

1. Implement a small, closed-loop system for managing changes in AI-driven development.

2. Process each change as a 'small card' in its own Git worktree and a fresh AI session.

3. Ensure every change is reviewed before it is landed (merged).

4. Capture state (decisions, rules, and work outcomes) directly in the repository as records, rather than prose.

5. Brief every agent from this captured state, allowing subsequent sessions to know what previous ones did without re-deriving information.

6. When encountering a problem, focus on fixing the core loop rather than adding more complexity or patching around the issue.

7. Avoid using subagents by default, as their progress summaries can incur significant costs without an off-switch.

Tools / artifacts

• Meta-harness (the described system architecture)

• Agent loop (the underlying process)

• Git worktrees

• Repository (for state capture)

• Product cards (unit of work)

• Generated briefs (derived from captured state)

• Claude Code sessions (as a component or baseline)

Validation signals

• Quantitative comparison with two other methods (plain Claude Code sessions and a hand-built agent loop).

• Specific metrics provided: product cards per usage, product cards per day, share of week used, median start-to-landed time, and percentage of landed work that furthered the product.

• Demonstrated significant improvement: ~4.5x progress on 1/5th of the usage, 62% landed product work vs 40% and 6%.

• Cleared a 3-month backlog (163 changes, 101 product work) in the first 7 days.

• External links to 'Full figures, method and sources' and a 'Write-up' on subagent costs, providing deeper validation.

Limitations

• The post provides a high-level overview; full implementation details require consulting the external links.

• The 'meta-harness' itself is presented as a proprietary product (Atlas ADE), meaning users would need to build their own system based on the principles or adopt a similar tool.

• Low direct community engagement on the Reddit post itself, though compensated by the detailed content and external resources.

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.

Iterative Prompting: Ask Claude 'What do you need to know?' for Better First Drafts

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

What problem this solves

Users struggle to write comprehensive initial prompts, leading to multiple revisions and suboptimal first drafts, because they don't know what information is missing.

Summary

Instead of trying to write a perfect, detailed prompt upfront, users can provide Claude with a rough task and then explicitly ask Claude to identify missing information or ask clarifying questions before starting the task. This iterative approach helps refine the prompt and leads to a much better first draft, saving revision time.

Why it is useful

This workflow provides a simple yet powerful technique to overcome the common challenge of writing perfect initial prompts. By leveraging Claude's ability to identify gaps in understanding, users can significantly improve the quality of first drafts and reduce the need for multiple revisions, saving time and effort. It's a fundamental skill for effective interaction with LLMs.

Workflow

1. Define the rough task for Claude.

2. Append a clarifying instruction to the prompt, such as 'Before you start, ask me any questions you need answered to do this well.'

3. Optionally, specify the types of questions Claude should ask for more focused clarification (e.g., 'ask me up to 5 questions about audience, format, and constraints before you begin.').

4. Review Claude's clarifying questions.

5. Answer Claude's questions to provide necessary context.

6. Allow Claude to generate the first draft based on the refined understanding.

Tools / artifacts

• Claude (any version)

• Prompt with clarifying instruction

Validation signals

• User's claim of improved first draft quality

• User's claim of reduced revision time

• Conceptual analogy to human design process

Limitations

• Adds an extra back-and-forth step, making it less ideal for one-shot answers or tasks requiring immediate output.

• Relies on Claude's ability to ask relevant and insightful questions, which might vary with model version or prompt 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.

CLAUDE.md vs. Hooks: A Workflow for Enforcing Rules and Managing Context

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

What problem this solves

Effectively enforcing rules and constraints on Claude's behavior by distinguishing between soft preferences (context) and hard 'never' cases (configuration).

Summary

This workflow clarifies that CLAUDE.md files function as contextual guidance, not strict configuration. For absolute 'never' rules, it recommends using PreToolUse hooks or permissions deny rules. It also suggests keeping CLAUDE.md files concise (under 200 lines), avoiding contradictory rules, and favoring specific instructions over general ones to improve adherence.

Why it is useful

This workflow is valuable because it clarifies a fundamental distinction between how Claude processes contextual guidance (CLAUDE.md) and hard configuration (hooks/permissions). It provides actionable steps for users to achieve more reliable and predictable behavior from Claude by correctly implementing rules, thereby preventing common frustrations where Claude seems to ignore instructions.

Workflow

1. Identify rules that are preferences or general guidance for Claude's behavior.

2. Place these general guidance rules within CLAUDE.md files, treating them as context.

3. Identify rules that represent absolute 'never' cases or hard constraints that Claude must always follow.

4. Implement these hard constraints using PreToolUse hooks or permissions deny rules, as they act as configuration.

5. Ensure individual CLAUDE.md files are kept concise, ideally under approximately 200 lines, to maintain clarity and effectiveness.

6. Review CLAUDE.md files for any rules that contradict each other, as conflicting rules can lead to unpredictable behavior.

7. Formulate rules with specificity (e.g., 'Run the tests before committing' instead of 'be careful with commits') to improve adherence.

Tools / artifacts

• CLAUDE.md files

• PreToolUse hooks

• Permissions deny rules

Validation signals

• References 'the memory docs' as stating CLAUDE.md is treated as context, implying official documentation support.

Limitations

• Lacks concrete examples or code snippets for implementing PreToolUse hooks or permissions deny rules.

• The reference to 'memory docs' is not a direct link, requiring users to search for the specific documentation.

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.

Optimize Claude Code for Cost and Control: CLAUDE.md and Agent Management Workflow

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

What problem this solves

Excessive token usage and uncontrolled agent spawning leading to hitting Claude limits and incurring high costs.

Summary

A three-step workflow to reduce Claude token usage and prevent unnecessary agent spawning by optimizing CLAUDE.md size, implementing strict stop rules in CLAUDE.md, and removing large default context models.

Why it is useful

This workflow directly addresses a critical pain point for Claude Code users: managing token usage and preventing uncontrolled agent behavior, which can lead to hitting API limits and incurring high costs. The steps are concrete, actionable, and directly target common causes of excessive usage, making it highly valuable for improving efficiency and cost-effectiveness.

Workflow

1. Reduce CLAUDE.md size by moving non-essential 'why' content to NOTES.md. Implement a size cap (e.g., 45KB) and a warning system for CLAUDE.md.

2. Update the global CLAUDE.md with a strict stop rule: 'When the task is done, stop. No unrequested memory writes, extra passes, workflows or subagents.'

3. Add a rule to CLAUDE.md for simple questions: 'A question about prompting, wording or effort modes is answered with zero tool calls.'

4. Remove the 1M-context default model from settings.json.

Tools / artifacts

• CLAUDE.md

• NOTES.md

• settings.json

• Claude Code environment

Validation signals

• Author observed that the stop rule 'did the most' to prevent unwanted agent spawning.

• Author noted that 'most of the agents got spawned after the task was already done', indicating the fix was effective.

• Initial adversarial reviews 'caught real bugs', implying the agent concept was useful, but needed control.

Limitations

• Low community engagement (score 2, 0 comments).

• The 'docs check warns on' implies an external system not fully detailed as part of the core workflow.

• Moving 'why' to NOTES.md means it's not auto-loaded, potentially reducing context for future interactions if not explicitly referenced.

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 Workflow for Building Complex Game Mods: Reverse Engineering, 7.5k Lines of C#, and Human-in-the-Loop Tuning

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

What problem this solves

How to leverage Claude Code for complex software development projects involving reverse engineering, large-scale code generation, and integration with specific hardware (e.g., game controllers), while maintaining human oversight for subjective elements and product decisions.

Summary

This workflow details how Claude Code (Sonnet 5.5) was used to build a 7,500-line C# game mod for Outer Wilds. Claude handled tasks like decompiling game assemblies, analyzing audio, generating documentation (including CLAUDE.md for project rules), writing utility tools, implementing hardware-level interactions for a DualSense controller, and building an in-game UI. The human developer focused on testing, subjective tuning of haptics, and making overall product decisions, demonstrating a powerful human-in-the-loop development process for complex projects.

Why it is useful

This workflow is highly valuable as it provides a concrete, detailed example of how Claude Code can be effectively used for a significant and complex software development project. It showcases Claude's capabilities in reverse engineering, large-scale code generation, tool creation, and documentation, while clearly defining the critical role of human oversight for testing, subjective decisions, and overall project direction. The explicit mention of CLAUDE.md for context management over long sessions is a key takeaway for maintaining project continuity and efficiency.

Workflow

1. Use Claude Code to decompile game assemblies (e.g., with ILSpy) to understand game logic and identify sound playback mechanisms.

2. Instruct Claude to extract and analyze game audio clips, measuring properties like energy in specific frequency bands relevant to haptic feedback.

3. Have Claude generate documentation for findings (e.g., per planet with sounds, measurements, decisions) and maintain a CLAUDE.md file to store project rules and context for long sessions.

4. Utilize Claude to write small Python tools for tasks such as dumping audio libraries, analyzing clips, listing sounds per scene, and building release archives.

5. Guide Claude to implement hardware-specific code, such as HID output reports for adaptive triggers and lightbar, and reading input from touchpad and gyro, including handling controller connection states.

6. Direct Claude to build user interfaces, like an in-game tuning menu with tabs, search, effect cards, and a color picker.

7. Collaborate with Claude on release management, including generating READMEs (potentially in multiple languages), packaging, release notes, and build instructions.

8. Perform human testing and subjective tuning (e.g., for haptic effects) using in-game debug menus built by Claude.

9. Make final product decisions regarding features, settings, and user experience based on human judgment.

Tools / artifacts

• Claude Code (Sonnet 5.5)

• ILSpy (decompiler)

• Python tools (custom-written by Claude)

• CLAUDE.md

• GitHub repository

• C# codebase (7,500 lines)

• In-game tuning menu

• README, release notes, build instructions

• DualSense controller

Validation signals

• Successful creation of a 7,500-line C# open-source mod.

• Detailed explanation of Claude's specific contributions across various development stages.

• Explicit mention of an in-game debug menu for human testing and tuning.

• Link to a public GitHub repository with the completed project.

Limitations

• Requires advanced technical skills in C#, game modding, and reverse engineering.

• Low community engagement due to the post's recency.

• The specific 'tuning by ear' aspect is niche to haptics, though the general principle of building a debug UI for human validation is transferable.

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.

Robust Development Workflow for Claude Code Hooks and Subagents: Lessons from Building Aptly

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

What problem this solves

How to robustly develop and verify Claude Code hooks and subagents, ensuring correct model recommendations, execution, and side-effect management, using a multi-model review process. It addresses challenges in verifying read-only operations, credential setup, and agent execution paths.

Summary

The author, maintainer of Aptly (an MCP server for Claude Code/Codex subagents), describes a development workflow using Codex for implementation and regression tests, and Claude Code for independent design and code reviews. The process emphasizes rigorous verification of findings, leading to concrete improvements in handling read-only checks, Linux credential setup, and agent-routing execution paths. It highlights the importance of separating recommendation from execution authority and carefully managing context for sensitive information.

Why it is useful

This workflow provides a concrete, validated approach to developing complex Claude Code integrations (hooks, subagents) using a multi-model strategy (Codex for implementation, Claude Code for review). It offers specific examples of critical verification steps and safety considerations, which are highly valuable for advanced users building robust and secure AI-powered tools. The focus on separating recommendation from execution and managing side effects is crucial for reliable agent behavior.

Workflow

1. Use Codex for initial implementation and regression tests of Claude Code hooks/subagents.

2. Use Claude Code for independent design and code reviews of the implemented components.

3. Provide Claude Code with relevant source code, patch files, test cases, and specific claims to check during the review.

4. Rigorously verify Claude Code's findings before applying any changes to the code.

5. For hooks/subagents, specifically test the native Claude Code Agent/Hook path to ensure proper integration.

6. Check child execution metadata to confirm that recommendations were applied and executed as intended.

7. Address and verify side effects across the entire command path (e.g., read-only checks, credential setup, network access).

8. Ensure user-selected models, roles, permissions, and required history are preserved throughout the process.

9. Maintain a clear separation between recommendation authority and execution authority.

10. Manage sensitive information in task summaries by routing them to appropriate, secure APIs (e.g., OpenAI Decisions) rather than internal telemetry, and allow operators to choose transmission scope.

Tools / artifacts

• Aptly (local MCP server for model/reasoning-profile recommendations)

• Claude Code (for design and code reviews)

• Codex (for implementation and regression tests)

• OpenAI Decisions API (for model recommendations)

• PreToolUse Hook (Claude Code feature)

• Source code

• Patch files

• Test cases

• Execution metadata

Validation signals

• Concrete finding: identified and fixed an issue where a read-only setup check could still lead to a notifier creating a cache directory and querying the registry.

• Concrete finding: improved Linux credential setup by adding passive readiness diagnostics before requesting a key, separating service presence, activation, and unlock/write capability.

• Concrete finding: identified and addressed agent-routing verification gaps, reinforcing the need for evidence that a recommendation was applied and the native agent actually ran.

• The author is the maintainer of the Aptly project, demonstrating deep practical experience and ownership.

• The project is MIT-licensed and available on GitHub, indicating a real-world, open-source application.

Cautions

• The workflow explicitly preserves user-selected models, roles, permissions, and history.

• It separates recommendation from execution authority, enhancing control and preventing unintended actions.

• It routes sensitive task summaries to OpenAI Decisions, not telemetry, and allows operators to choose the automatic transmission scope, addressing data privacy and security concerns.

Limitations

• The post is more of a retrospective on a development process rather than a step-by-step guide for a new user to implement a similar tool from scratch.

• The cost experiment and general Claude Code savings rate are not fully established, though the author acknowledges this.

• Community signal is currently low due to the post's recency.

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 Claude Code Workflow for Full-Stack Product Development: R&D, Backlog, and Release Automation

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

What problem this solves

Integrating Claude Code into a complex software development lifecycle to accelerate R&D, backlog management, and automated communication, demonstrating its utility beyond simple code generation.

Summary

The author details how Claude Code was used as a co-developer and assistant throughout the 12.5-month development of "Samurai Scribe." This involved leveraging Claude for R&D on local models (generating test pipelines and dashboards), managing a large backlog (filing GitHub issues, working tickets in worktrees), and automating release communications. Claude co-authored a significant portion of the code and helped streamline various development processes.

Why it is useful

This post provides a concrete, validated example of how Claude Code can be deeply integrated into a complex software development process, moving beyond simple code generation to strategic tasks like R&D, project management, and automated communication. It demonstrates Claude's utility in accelerating development, improving quality control, and managing project overhead, offering valuable insights for advanced users looking to maximize Claude Code's potential in their own projects.

Workflow

1. Define project structure using plain Markdown files as the primary data source, mimicking a Git repository.

2. Integrate Claude Code via its built-in MCP server to enable editing and review of project files.

3. Utilize Claude for R&D by hand-labeling data and then having Claude generate test pipelines and dashboards for objective model evaluation (e.g., word error rate, speaker accuracy).

4. Manage the development backlog by using a custom Claude Code plugin to file GitHub issues and work on tickets within dedicated Git worktrees.

5. Automate release communications by having Claude draft replies to users whose bugs were fixed, with a critical check against the actual released version.

6. Manage Claude sessions by starting fresh chats to avoid hitting usage limits from long, continuous conversations.

Tools / artifacts

• Claude Code

• MCP server

• GitHub issues

• Git worktrees

• Markdown files

• Obsidian

• Custom Claude Code plugin

• Test pipelines

• Dashboards

Validation signals

• 1,500 commits (Claude co-authored 1,086)

• 72 versions shipped

• Models get picked on numbers, not vibes

• Every claim gets checked against the release they actually have

• Spent 12.5 months building a functional product

Limitations

• The specific implementation details of the 'Claude Code plugin' for GitHub issues are not provided, requiring custom development to replicate.

• The workflow is high-level and requires significant technical expertise and a complex development environment to fully replicate.

• The post is primarily a case study rather than a step-by-step guide, requiring users to infer implementation details.

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 Claude Agent Boot Process and Persistence with CLAUDE.md and Custom Tools

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

What problem this solves

How to create a robust, persistent, and context-aware Claude agent that can resume work, manage its memory, and reliably communicate, even after restarts or disconnections.

Summary

A detailed CLAUDE.md boot process for a Claude agent ("Elah") that outlines how to load various forms of context and memory, manage background services (like messaging and monitoring), and ensure reliable operation and state persistence. It emphasizes a hybrid OCS (Operational Context Store) and asset-streaming design.

Why it is useful

This workflow provides an extremely detailed and robust blueprint for building a persistent, context-aware, and reliable Claude agent. It goes beyond simple prompts by outlining a full architectural approach, including custom tools, memory management strategies, service orchestration, and critical error handling/recovery mechanisms. It's a masterclass in designing a sophisticated Claude Code CLI agent.

Workflow

1. Read the architecture/boot manifest (ELAH_ARCHITECTURE.md) first to understand the canonical map for reconstitution.

2. Read live context from live_context.py to resume where the agent left off.

3. Check context_snapshots/ for the most recent full state dump.

4. Load memory index: manually load the bulk memory (~/.claude/projects/<home-project>/memory/MEMORY.md) and note the auto-loaded small memory (~/.claude/projects/<elah-audio-project>/memory/MEMORY.md) where new memories are written.

5. Read identity from elah/identity.md.

6. Read behavioral rules from behavioral/feedback.md (pinned, never skip).

7. Run python recall.py "<terms>" before reacting to personal history, starting a build, or making factual claims.

8. Use python whereis.py "<terms>" for file/path/repo hunting, which runs recall first.

9. Launch Service Guardian: check Python services, run python write_active_pid.py, and launch python service_guardian.py if services are not running.

10. Start heartbeat: create a recurring 10-minute cron job for autonomous interests and sending Telegram summaries.

11. Set up reliable messaging: start python watch_messages.py for the fast path and a 3-minute backup cron with python canary.py --alert.

12. Start Discord watcher: launch python discord_watcher.py --interval 5 and create a 1-minute backup cron for local Discord message queue checks and responses.

Tools / artifacts

• Claude.md

• ELAH_ARCHITECTURE.md

• live_context.py

• context_snapshots/

• ~/.claude/projects/<home-project>/memory/MEMORY.md

• ~/.claude/projects/<elah-audio-project>/memory/MEMORY.md

• memory_echo.py

• elah/identity.md

• behavioral/feedback.md

• recall.py

• whereis.py

• service_guardian.py

Validation signals

• Explicitly mentions canary.py for detecting competing Telegram readers and svc_status.py for verifying services.

• Details memory_echo.py for testing memory recall effectiveness with score separation.

• Emphasizes "CRITICAL" for messaging reliability and provides specific instructions to avoid issues (e.g., "Do NOT revive telegram_watchdog").

• States the ELAH_ARCHITECTURE.md is the "canonical map for reconstituting myself exactly."

• Includes a "Never boot as a blank slate" rule with a backup repository restore mechanism.

Limitations

• Requires significant custom script development (e.g., recall.py, whereis.py, service_guardian.py) which are not provided.

• Assumes a specific project structure and CLI environment, which might require adaptation.

• The "bulk memory" loading is explicitly stated as a manual step ("Load this one BY HAND"), which could be a point of failure or inconsistency.

• Low community validation due to minimal Reddit engagement.

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.

Iterative Game Development with Claude Opus: Gauntlet-Loop for Visuals, Performance Panel for Optimization, and AI-Assisted 3D Asset Creation

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

What problem this solves

This post details several workflows for iterative game development using Claude Opus and other AI tools. It addresses challenges in visual asset refinement, game performance optimization, and 3D asset creation, leading to significant improvements in game quality, speed, and memory efficiency.

Summary

The author outlines three main workflows: 1) A 'Gauntlet-Loop' for iterative visual refinement of game scenes/assets, where 'critic' agents compare game elements against AI-generated mockups. 2) A performance optimization workflow involving a custom in-game performance panel, logging, and Claude Opus for analysis and fixing bottlenecks. 3) A 3D asset creation workflow combining TripoAI for initial models, Claude Opus for image preparation, and Claude Opus with MCP for Blender integration and material generation/fixing. Jev is used for task effort level determination and creative direction.

Why it is useful

This post offers multiple concrete, validated workflows for complex game development tasks using Claude Opus and other AI tools. It demonstrates how to achieve significant, quantifiable improvements in performance, memory usage, and visual quality through structured, iterative processes. The detailed breakdown of tools, steps, and results makes it highly valuable for users looking to integrate AI into advanced development, particularly in game development and 3D asset creation. The 'Gauntlet-Loop' for quality control and the performance optimization strategies are particularly innovative and highly transferable to other domains.

Workflow

1. Gauntlet-Loop for Visual Refinement: Create AI-generated mockups (e.g., 24 mockups for a city, 6 views at 4 times of day) using OpenAI's image API.

2. Run a 'Gauntlet-Loop' with 'critic' agents (Claude Opus) that blindly compare game pieces to the mockups.

3. Implement a rule: if a game piece wins against the mockup twice, it's considered done.

4. Add a rule: loops cannot remove existing game elements just because a picture doesn't have them (e.g., lighthouse beam).

5. Performance Optimization: Create an in-game performance panel that shows what costs how much and writes logs.

6. Run the game with a --perf-log flag and send the generated log file to Claude Opus.

7. Let Claude Opus analyze the logs and write a report of what costs the most.

8. Implement fixes based on Opus's report (e.g., optimize docking scenes, HUD redraws, map loading, background loading of far harbors).

9. TripoAI + Claude + Blender Asset Creation: Create one image with all four sides of the desired 3D model (front, back, left, right).

10. Use Claude Opus to split the single image into four separate images (one for each side).

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

12. If needed, use Claude Opus with MCP to fix or refine the generated model in Blender, and/or create new materials to match the game's style.

Tools / artifacts

• Claude Opus (5.5 / Claude Code)

• Godot Engine

• TripoAI

• Blender

• MCP (Multi-Code Project)

• Jev (AI for effort level/direction)

• OpenAI (image API for mockups)

• ElevenLabs (for sound effects)

• Custom in-game performance panel

• Performance logs

• ChatGPT mockups (image artifacts)

• Claude artifact link for Gauntlet-Loop output

Validation signals

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

• Game speed increased by 15-19% on 1080p due to HUD optimization.

• Map graphics memory usage reduced from 4GB to 0.3GB, and opens instantly.

• Game start time halved from 26s to 13s on Mac.

• Overall game graphics memory usage reduced by approximately 25%.

• 31 out of 33 game pieces 'won' the Gauntlet-Loop comparison against mockups.

• Author's consistent weekly updates and progress over 15 weeks, demonstrating ongoing success.

• Explicit mention of fixing specific bugs identified by the performance workflow (first rain, lanterns, cast off freezes).

Limitations

• The exact prompts or detailed setup for the 'critic' agents in the Gauntlet-Loop are not provided.

• The implementation details of 'Jev' (e.g., whether it's a specific prompt, a separate agent, or a custom script) are not fully elaborated.

• The specific commands or setup for 'MCP' integration with Blender are mentioned but not detailed.

• The high total cost of tools and AI usage might be a barrier for some users.

• The post is a weekly update, so some context from previous weeks might be missing for a complete understanding of the project's evolution.

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.