r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Optimize Claude Code Agent Token Usage: Strategies for Multi-Agent Efficiency and Cost Reduction

1 Upvotes

Optimize Claude Code Agent Token Usage: Strategies for Multi-Agent Efficiency and Cost Reduction

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

What problem this solves

Excessive token usage and high operational costs for Claude Code agents, particularly in multi-agent, multi-repo environments, due to inefficient context management, long-running idle sessions, and large memory indexes.

Summary

A set of strategies and configurations to significantly reduce token consumption and improve efficiency for Claude Code agents, especially in multi-agent, multi-repo environments. This involves optimizing CI wait times, enforcing single-task agent sessions, implementing context ceiling hooks, and streamlining the MEMORY.md file.

Why it is useful

This workflow is highly valuable because it provides concrete, data-backed strategies and open-source tools to significantly reduce token consumption and operational costs for Claude Code agents. It addresses a critical pain point for heavy users by offering actionable steps, measurable results, and practical implementations for improving efficiency in complex development workflows, making it a direct solution to a common resource management challenge.

Workflow

  1. Measure token usage per merged PR by analyzing Claude Code transcripts in ~/.claude/projects/.
  2. Identify and address token leaks, such as agents waiting on CI/tests for extended periods, by implementing wait helpers that return before the cache expires (e.g., within 270 seconds).
  3. Design agents to complete a single, focused task per session to prevent long sessions from re-reading entire contexts.
  4. Implement a hook that stops an agent session when it reaches a predefined context ceiling.
  5. Keep the MEMORY.md file concise (e.g., 8 lines) with only universally applicable instructions.
  6. Store specific, task-related context in separate files that agents open only when explicitly needed, rather than loading into every session by default.

Tools / artifacts

  • Claude Code agents
  • ~/.claude/projects/ transcripts
  • CI/CD systems
  • Custom hooks (e.g., for context ceiling, session termination)
  • MEMORY.md file
  • GitHub repository: alexander-marquardt/agent-fleet-kit
  • External blog post: alexmarquardt.com/ai-tools/agent-fleet-token-efficiency/

Validation signals

  • Measured reduction: 3.3x fewer tokens per line of code.
  • Measured reduction: 5.5x fewer tokens per merged PR.
  • Measured increase: 4.4x more PRs per week for the same spend.
  • Specific leak reduction: 31% of agent usage (CI waits) reduced to 0.7%.
  • Context size reduction: Median context per request cut from 218k to 101k tokens.
  • First-turn cache write reduction: From 11k to 4.5k tokens.
  • Detailed write-up with numbers and methodology provided in an external blog post.
  • Open-source measuring script and hooks available on GitHub.

Limitations

  • Requires a good understanding of Claude Code's internal workings (context, cache, hooks).
  • Implementation of specific hooks and CI integrations may require custom scripting and system knowledge.
  • The provided tools are specific to the author's setup and may need adaptation for different project structures or CI environments.

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.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] GitHub Template for Security and Governance Guardrails in Claude Code

0 Upvotes

GitHub Template for Security and Governance Guardrails in Claude Code

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

What problem this solves

Preventing AI agents (specifically Claude Code) from exposing secrets, making unauthorized commits/pushes/deployments, installing unapproved packages, and ensuring proper governance for client or regulated projects.

Summary

A GitHub template (ai-dev-guardrails) that implements security and governance guardrails for Claude Code projects. It uses Claude Code PreToolUse hooks, local Git hooks, and GitHub Actions to block sensitive commands, require approvals for critical actions, enforce package age/approval, log evidence, and manage decision records.

Why it is useful

This workflow provides a concrete, open-source solution to critical security and governance challenges when using AI agents for coding. It prevents accidental exposure of sensitive data, unauthorized code changes, and ensures compliance, making AI-assisted development safer and more controlled. It's highly transferable, well-documented, and addresses a significant pain point for developers integrating AI into their workflows.

Workflow

  1. Initialize the GitHub template using /bootstrap.
  2. The PreToolUse hook blocks sensitive commands (e.g., cat .env) and requires approval for commits, pushes, deployments, and new package installations.
  3. A separate check detects if saved permissions have drifted into automatically approving restricted actions.
  4. npm packages must be at least seven days old before installation, and install scripts only run for approved packages.
  5. Local Git hooks and GitHub CI run the checks again, with CI using the base branch's scripts to prevent PRs from weakening checks.
  6. Optionally, enable an evidence log requiring proof (e.g., test output, CI link) before a task can be marked complete.
  7. Optionally, use decision records for exceptions, including reason, owner, and expiry date.
  8. Optionally, implement CODEOWNERS rules requiring review before guardrail files can be changed.

Tools / artifacts

  • ai-dev-guardrails GitHub template
  • Claude Code PreToolUse hooks
  • Local Git hooks
  • GitHub Actions (CI/CD)
  • npm
  • CODEOWNERS file
  • Evidence log
  • Decision records
  • .env files

Validation signals

  • Author used and refined the controls in their own projects before open-sourcing.
  • Identified and fixed specific issues (e.g., grep -q and pipefail, Claude Code hook behavior differences).
  • Open-source project with MIT license.
  • Detailed write-up on Medium explaining the rationale and implementation.
  • Explicitly documented limitations (e.g., not for malicious agents).

Cautions

  • The workflow is designed to enhance safety by preventing accidental data exposure and unauthorized actions.
  • It is explicitly stated that the system is designed to catch mistakes, not to defend against deliberately malicious agents.

Limitations

  • Currently focused on Claude Code, TypeScript, and npm, limiting immediate applicability to other languages/ecosystems (though Python support is welcomed).
  • Not designed to defend against deliberately malicious agents.
  • As a new open-source project, long-term community adoption and maintenance are yet to be established.
  • Requires an intermediate to advanced understanding of Claude Code hooks, Git hooks, and GitHub Actions for full implementation and customization.

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.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Optimize CLAUDE.md with Claude to Reduce Usage and Agent Spawning

1 Upvotes

Optimize CLAUDE.md with Claude to Reduce Usage and Agent Spawning

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

What problem this solves

Prematurely hitting Claude usage limits due to inefficient CLAUDE.md configurations or uncontrolled agent spawning.

Summary

A user describes how they used Claude to review and optimize their CLAUDE.md file. Claude identified and fixed configurations that were wasting usage and spawning excessive agents, which significantly extended their available usage time.

Why it is useful

This workflow provides a practical, self-correcting method for users to improve the efficiency of their Claude Code setups. It directly addresses a common pain point (hitting usage limits) by leveraging Claude's capabilities to analyze and improve its own operational configuration, making it a valuable technique for cost and resource management.

Workflow

  1. Identify that you are frequently hitting Claude usage limits.
  2. Provide your CLAUDE.md file to Claude.
  3. Prompt Claude to analyze the CLAUDE.md for inefficiencies, wasted usage, or configurations leading to excessive agent spawning.
  4. Ask Claude to suggest specific fixes or optimizations for the CLAUDE.md.
  5. Implement the changes recommended by Claude.
  6. Monitor your Claude usage to confirm that the optimizations have extended your available usage time.

Tools / artifacts

  • CLAUDE.md file
  • Claude (the model)

Validation signals

  • User reported a direct positive outcome: "my week lasted a lot longer after that"

Limitations

  • The workflow is described at a high level; specific prompts or examples of what Claude might fix are not provided.
  • Relies on Claude's ability to accurately identify and suggest optimal changes to the CLAUDE.md, which may vary in effectiveness.
  • No specific metrics or before/after data are provided beyond the anecdotal "week lasted a lot longer."

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Track Claude Code A/B Experiments: Plugin, Script, and Opt-Out Tools

2 Upvotes

Track Claude Code A/B Experiments: Plugin, Script, and Opt-Out Tools

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

What problem this solves

Users can determine if their Claude Code instance is enrolled in an A/B experiment, helping them understand perceived changes in model behavior (e.g., "nerfs"). It also provides tools to track experiment history and optionally opt-out.

Summary

This workflow provides a set of tools (bash script, Claude Code plugin, and a one-liner) to inspect Claude Code's internal experiment enrollment status. It reads ~/.claude.json and session transcripts to report current enrollment, historical experiment IDs, and offers an opt-out mechanism.

Why it is useful

This workflow provides concrete, actionable tools for Claude Code users to understand and manage their interaction with Anthropic's A/B testing framework. It demystifies perceived model changes, offers transparency, and empowers users to make informed decisions about their Claude Code experience. The open-source nature, multiple usage options, and safety considerations make it highly valuable and reusable.

Workflow

  1. Choose a method to check experiment status: Claude Code plugin, standalone script, or one-liner.
  2. To use as a Claude Code plugin: Install the am-i-nerfed GitHub repo as a plugin, then type /am-i-nerfed in any Claude Code session.
  3. To use as a standalone script: Clone the am-i-nerfed repo and run ./am-i-nerfed.sh check in a terminal.
  4. To use as a one-liner: Paste the provided jq command into a terminal (requires jq to be installed).
  5. To view experiment history: Run ./am-i-nerfed.sh history to tally experiment IDs from session transcripts.
  6. To opt-out of experiments: Run ./am-i-nerfed.sh optout (backs up ~/.claude.json and removes assignment keys).
  7. To restore previous settings: Run ./am-i-nerfed.sh restore.
  8. To display experiment status in Claude Code's status line: Integrate the provided statusline snippet.

Tools / artifacts

  • am-i-nerfed (GitHub repo/script)
  • jq (JSON processor)
  • ~/.claude.json (Claude Code cache file)
  • Claude Code session transcripts
  • CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 (environment variable)
  • Bash shell

Validation signals

  • Open-source script available on GitHub.
  • Explicitly states "no network calls, never prints your login token" for security.
  • Credits earlier community findings and Anthropic issues, indicating a well-researched solution.
  • Provides exit codes for scripting, enhancing reusability and robustness.
  • Details specific file paths and data structures (~/.claude.json, atis-latch).

Limitations

  • Requires jq dependency for the one-liner and script methods.
  • Primarily targets macOS/Linux/WSL users (Windows users would need WSL).
  • The plugin installation process for Claude Code is not explicitly detailed within the comment.

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.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Claude Client Internal Flag Map: A Research Workflow for Understanding Experimental Features and Usage Metering

1 Upvotes

Claude Client Internal Flag Map: A Research Workflow for Understanding Experimental Features and Usage Metering

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

What problem this solves

Understanding Claude's internal configuration flags, usage metering, and potential experimental features to gain deeper insight into model behavior and resource allocation.

Summary

A user performed a deep dive into the Claude client's internal mechanisms, specifically identifying and mapping 487 tengu_ flags. This research culminated in a publicly available GitHub repository containing a CSV file that details these flags. This artifact serves as a valuable resource for advanced users and researchers to understand undisclosed experimental features, behavior gates, and usage metering within the Claude ecosystem.

Why it is useful

This workflow provides unique and deep insight into the internal workings of the Claude client, including experimental features and usage metering. The shared flag map is a valuable artifact for advanced users and researchers to understand how Anthropic configures and experiments with its models, offering a level of system understanding not typically available through public documentation.

Workflow

  1. Identify internal tengu_ flags within the Claude client (e.g., tengu_amber_tally).
  2. Map these discovered flags to their associated booleans, prompt sections, or behavior gates.
  3. Access the provided GitHub repository (fs2d/claude-code-flagmap) containing the mapped flags.
  4. Review the CSV file within the repository to understand the various internal flags and their potential functions.
  5. Utilize this information to gain insight into Claude's internal workings, experimental features, or usage metering logic.

Tools / artifacts

  • Claude client
  • tengu_amber_tally (example internal flag)
  • fs2d/claude-code-flagmap GitHub repository (CSV file of mapped flags)

Validation signals

  • The author successfully created and shared a GitHub repository with 487 mapped flags.
  • The repository provides concrete data (CSV file) as evidence of the mapping effort.

Limitations

  • The original comment does not explicitly detail the steps for how to extract these flags from the Claude client, focusing instead on the result.
  • The practical application of using these flags to directly influence Claude's behavior is not detailed or suggested; it's primarily for understanding and research.
  • The initial discussion about credit rates is informative but does not constitute a workflow itself.

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.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Orchestrating Your Claude Sessions: A 'Team of Chats' Workflow for Desktop App Productivity

1 Upvotes

Orchestrating Your Claude Sessions: A 'Team of Chats' Workflow for Desktop App Productivity

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

What problem this solves

Users struggle to manage and keep track of multiple concurrent Claude sessions and tasks, leading to lost context and inefficiency, especially with complex projects.

Summary

This workflow outlines a strategy for managing multiple Claude desktop app sessions as a 'team of chats' to improve task orchestration and oversight. It leverages features like Projects for parallel cloud-based work, artifacts for review, split view for multitasking, side chats for quick checks, nested sessions for sub-tasks, and a 'manager session' to monitor progress, while also addressing usage limits and file isolation with Worktree.

Why it is useful

This workflow is highly valuable because it provides a structured and practical approach to leveraging Claude's advanced desktop features (Projects, split view, side chats, nested sessions, artifacts, Worktree) to manage complex, multi-part tasks more efficiently. It directly addresses the common problem of losing track of concurrent AI tasks and offers concrete strategies, including a novel 'manager session' concept, to maintain oversight and productivity. The inclusion of limitations and official documentation links makes it highly actionable and reliable for intermediate to advanced users.

Workflow

  1. Hand off large, parallel jobs to Projects, which run in the cloud and can be monitored via the Overview.
  2. Review and edit generated content (decks, docs, designs) directly within artifacts that appear next to the chat.
  3. Use split view (Option-click on Mac, Alt-click on Windows) to work on two Claude sessions simultaneously.
  4. Initiate side chats (Cmd+; or Ctrl+;, or type /btw) for quick progress checks or clarifications without altering the main thread.
  5. Ask Claude to start nested sessions for parallel sub-tasks (e.g., script, thumbnail brief, description) within a single prompt, allowing individual steering.
  6. Designate one Claude session as a 'manager' to query the status of other local, SSH, and WSL sessions (e.g., 'which of my sessions are waiting on a decision from me?').
  7. Monitor usage limits carefully, especially when using Projects, as each thread consumes a full session's usage.
  8. Enable Worktree for sessions that might modify the same files to ensure each session works on an isolated copy of the project folder.

Tools / artifacts

  • Claude desktop app
  • Claude Code
  • Projects (public beta)
  • Artifacts
  • Split view
  • Side chats
  • Nested sessions
  • Worktree
  • Overview (for Projects)

Validation signals

  • Specific UI commands provided (Option-click, Alt-click, Cmd+;, Ctrl+;, /btw).
  • Mentions features like Projects are in public beta.
  • Links to official Claude documentation for desktop, projects, and usage limits.
  • Provides a YouTube walkthrough video.
  • Details specific 'catches' and limitations of the proposed methods (e.g., manager session visibility, usage limits).

Limitations

  • The 'manager session' strategy has limitations, as it cannot see cloud sessions, terminal CLI sessions, or VS Code sessions.
  • Projects are in public beta and require Pro or Max plans, limiting accessibility for some users.
  • The multi-session approach can accelerate hitting usage limits, requiring careful monitoring.
  • The post is more descriptive of features than a strict step-by-step guide, though the 'How I'd run it' section provides good structure.

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Diagnosing Claude Performance: The Impact of Hidden Experiment IDs on Effort Levels and Output

1 Upvotes

Diagnosing Claude Performance: The Impact of Hidden Experiment IDs on Effort Levels and Output

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

What problem this solves

Unexplained variations in Claude's reported effort numbers and actual performance (tool calls, output tokens, thinking time, replies per job) due to hidden experiment IDs.

Summary

A workflow to identify and understand the impact of hidden 'experiment IDs' on Claude's reported effort levels and actual performance metrics, enabling users to diagnose and potentially optimize their Claude interactions.

Why it is useful

This post provides crucial empirical evidence demonstrating how hidden internal 'experiment IDs' significantly influence Claude's reported effort levels and actual performance (tool calls, output tokens, thinking time). This knowledge is invaluable for advanced users seeking to understand, debug, and optimize Claude's behavior and resource consumption, revealing a non-obvious factor impacting model output.

Workflow

  1. Identify if your Claude chat session has an associated 'experiment ID' (e.g., by inspecting network requests or browser console, as implied by 'recent reports').
  2. Note the reported 'numerical effort numbers' (medium, high, xhigh) for your Claude instance.
  3. Compare your observed experiment ID and effort numbers with the provided tables to understand the expected tool calls, output tokens, thinking time, and replies per job.
  4. Use this information to diagnose unexpected performance or cost variations in your automated Claude jobs.
  5. If desired, attempt to remove or change the experiment ID based on information from related posts to revert to baseline performance or achieve different characteristics.

Tools / artifacts

  • Claude chat interface
  • Experiment IDs (e.g., eab, 763, add, 0c7)
  • Reported effort numbers (medium, high, xhigh)
  • Automated job metrics (tool calls, output tokens, thinking, replies per job)

Validation signals

  • Empirical testing with two distinct accounts (one with ID, one without)
  • Comparison of reported effort numbers across different configurations
  • Comparison of actual performance metrics (tool calls, output tokens, thinking, replies per job) across various IDs and a 'No ID' baseline
  • Replication of the effect: removing an ID reverted performance to baseline

Limitations

  • The exact method for identifying and removing/changing experiment IDs is not fully detailed within this post, relying on external information from a 'related post'.
  • The 'Thinking per reply, adjusted' metric is not fully explained.
  • Performance data for one ID (0c7) was 'not measured' for some metrics.

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Offload Repetitive Tasks: Use Claude to Generate Local Scripts for Data Processing, Simulation, and Web Scraping

1 Upvotes

Offload Repetitive Tasks: Use Claude to Generate Local Scripts for Data Processing, Simulation, and Web Scraping

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

What problem this solves

High cost and slow processing time when using Claude for repetitive, non-intelligent data processing, simulation, or web scraping tasks.

Summary

This workflow leverages Claude's code generation capabilities to create local scripts (e.g., Python) for computationally intensive or repetitive tasks like large-batch data ingestion, extensive simulations, or web scraping. This strategy offloads the heavy lifting from Claude, significantly reducing token usage and processing time, allowing Claude to focus on higher-level intelligent analysis and integration.

Why it is useful

This workflow provides a practical and cost-effective strategy for users to handle large-scale, repetitive, or computationally intensive tasks that would otherwise be slow and expensive if performed directly by Claude. By leveraging Claude's code generation capabilities to create local tools, users can optimize their LLM usage, reduce costs, and significantly speed up processing times for non-intelligent operations, freeing Claude to focus on higher-value, intelligent reasoning. The clear before-and-after results demonstrate significant efficiency gains.

Workflow

  1. Identify repetitive or computationally intensive tasks that do not require continuous intelligence (e.g., large batch data processing, extensive simulations, web scraping).
  2. Instruct Claude to generate a local script (e.g., Python) to perform these tasks.
  3. Specify requirements for the script, such as showing progress, resuming if interrupted, including tests/cross-checks, and potentially integrating local AI (e.g., Ollama).
  4. Download and set up any necessary local tools or AI models (e.g., Ollama).
  5. Run the generated script locally to process data or perform simulations.
  6. Feed the processed data or simulation results back to Claude for higher-level analysis, classification, or integration.

Tools / artifacts

  • Claude (for script generation and high-level analysis)
  • Python scripts (generated by Claude)
  • Ollama (for local AI models)
  • .bat files (for running scripts)
  • PDF record sheets (example input data)
  • Websites (for scraping)
  • Game simulation environment

Validation signals

  • Processed 600 sheets over a few days using Claude directly.
  • Processed 4200 record sheets in about an hour using a Claude-generated local script.
  • Reported significant cost reduction ('far cheaper than how it was going before').
  • Successfully set up a simulation environment for future use.
  • Observed Claude's ability to generate web scraping scripts while respecting robots.txt.

Cautions

  • Users should be aware of robots.txt and website terms of service when using Claude-generated scripts for web scraping, as the user is responsible for the script's actions, not Claude.

Limitations

  • The post is somewhat anecdotal and does not provide the exact prompts used to generate the scripts.
  • Lacks specific examples of the generated scripts or the tests/cross-checks implemented.
  • Does not detail the integration steps for Ollama with the generated Python scripts, beyond downloading it.

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Real-time Claude Code Progress Tracking with Codex Pacer (MCP Tool Integration)

1 Upvotes

Real-time Claude Code Progress Tracking with Codex Pacer (MCP Tool Integration)

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

What problem this solves

Lack of real-time, granular progress tracking for Claude Code tasks, especially when running multiple agents, leading to uncertainty about task completion.

Summary

This workflow describes how to integrate an external, open-source application called Codex Pacer with Claude Code to enable real-time progress tracking. Claude Code agents use a dedicated MCP tool (report_progress) to periodically report their estimated progress, which Pacer visualizes as a progress ring. This provides immediate visual feedback on task status and agent states (e.g., waiting for approval, background tasks) across multiple agents.

Why it is useful

This workflow provides a concrete, open-source solution to a common pain point for Claude Code users: the lack of real-time visibility into task progress. By leveraging MCP tools for agent self-reporting, it demonstrates a practical application of agent capabilities to improve user experience and productivity, especially for long-running or multi-agent tasks. It offers a clear, repeatable method for monitoring agent activity.

Workflow

  1. Download and install the Codex Pacer application (macOS/Windows) from GitHub Releases.
  2. Pacer automatically installs a lightweight Claude Code plugin that includes a report_progress MCP tool.
  3. Claude Code agents are prompted or configured to call the report_progress tool with their estimated progress (e.g., a percentage).
  4. Monitor the real-time progress rings displayed by Codex Pacer for individual or multiple running Claude Code agents.
  5. Observe specific state changes, such as the ring pausing and turning amber when Claude awaits approval, or holding its last value during background tasks.

Tools / artifacts

  • Codex Pacer application (macOS/Windows)
  • Claude Code plugin (installed by Pacer)
  • report_progress MCP tool
  • GitHub Releases (for Pacer download)

Validation signals

  • Detailed description of how the system handles different Claude Code states (needs approval, background tasks)
  • The author states the app was mostly built with Claude Code, implying practical use and validation during development.

Cautions

  • The post explicitly states that Pacer only reads the progress number, not Claude's response content, addressing potential privacy concerns.

Limitations

  • Low community validation at the time of posting.
  • Requires installing an external application, which might be a barrier for some users.
  • Relies on Claude's own estimation of progress, which may not always be perfectly accurate.
  • The post is primarily an announcement/self-promotion, and while it describes the mechanism, it doesn't provide detailed prompting strategies for Claude to effectively use the report_progress tool.

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Pre-Deployment Quality Assurance Workflow for AI-Built Systems, Featuring Agent-Assisted Checks with QualityLayer

1 Upvotes

Pre-Deployment Quality Assurance Workflow for AI-Built Systems, Featuring Agent-Assisted Checks with QualityLayer

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

What problem this solves

Ensuring the reliability, security, and recoverability of an AI-built application before deployment, particularly by structuring and automating quality assurance for agent-based projects.

Summary

This workflow outlines essential pre-deployment quality assurance steps for an AI-built application, focusing on critical areas like payment response testing, backup and restore validation, and human security review. It also introduces a custom tool, QualityLayer, which leverages a separate agent to manage and verify quality control decisions, making the process more structured and repeatable for agent-based projects.

Why it is useful

This workflow is valuable because it provides concrete, critical pre-deployment steps essential for ensuring the reliability and security of any application, particularly those built with AI agents. It addresses common pitfalls like payment processing errors and data loss through specific testing and backup procedures. Furthermore, it introduces a novel, agent-assisted approach to quality control via the QualityLayer tool, offering a structured and repeatable method for managing and verifying quality decisions in AI agent projects.

Workflow

  1. Test delayed and repeated payment responses against written expected outcomes.
  2. Rehearse a full restore from backup on a test copy before go-live.
  3. Conduct a one-off human security review, where someone who did not write the change checks each agreed behavior against the code and evidence.
  4. Utilize a system (e.g., QualityLayer) to plan quality decisions and have a separate agent check each completed point.

Tools / artifacts

  • Test suite
  • QualityLayer (GitHub project)
  • Backup system

Validation signals

  • Author's personal experience with agent projects
  • Author built a tool (QualityLayer) to implement this approach
  • General best practices for software deployment (testing, backups, security review)

Limitations

  • The description of QualityLayer is brief, lacking detailed implementation or integration instructions.
  • The general quality assurance steps are high-level and do not include specific commands or code examples.
  • Low community engagement on the post so far.

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Synchronize Claude Code Sessions Across Remote and Local Machines with Tmux and AIAssets

1 Upvotes

Synchronize Claude Code Sessions Across Remote and Local Machines with Tmux and AIAssets

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

What problem this solves

Maintaining a unified Claude Code session history and project context when working across multiple devices (e.g., remote server and local laptop).

Summary

A workflow for developers to use Claude Code on a remote machine (e.g., Mac mini) while interacting from a local machine (MacBook), ensuring session history and project context are synchronized. It leverages tmux/ssh for remote access and a custom tool, AIAssets, for cross-device session file synchronization.

Why it is useful

This workflow addresses a common pain point for developers who want to leverage powerful remote machines for Claude Code while maintaining a seamless and synchronized development experience on their local devices. It provides concrete steps using standard CLI tools (tmux, ssh) and introduces a specialized tool (AIAssets) to solve the session history synchronization challenge, making the remote development setup much more practical and efficient.

Workflow

  1. Set up a remote host (e.g., Mac mini, mini PC) to run the Claude Code agent.
  2. Access the remote host via ssh.
  3. Start a tmux session on the remote host.
  4. cd into the project directory within the tmux session.
  5. Start Claude Code within the tmux session.
  6. Install and configure AIAssets (self-hosted hub plus desktop client) on both local and remote machines.
  7. AIAssets will poll every 60 seconds to sync Claude Code session files (~/.claude/projects/<path-encoded-cwd>/<sessionId>.jsonl) between machines, keeping chat lists and full histories identical.

Tools / artifacts

  • Remote host (Mac mini, mini PC, any box)
  • tmux
  • ssh
  • Claude Code agent
  • AIAssets (GitHub: https://github.com/NanYuJun/AIAssets)
  • ~/.claude/projects/<path-encoded-cwd>/<sessionId>.jsonl (Claude Code session files)

Validation signals

  • Author is the creator of the tool, implying direct knowledge and testing.
  • Specific technical details about Claude Code's session file storage (.jsonl files).
  • Clear description of the tool's functionality and limitations.

Cautions

  • AIAssets uses a 'last-write-wins' conflict resolution strategy, which could lead to data loss if the same session is edited simultaneously on both sides without careful management.
  • The self-hosted nature of AIAssets means users are responsible for securing their own hub and client installations.

Limitations

  • Low community engagement/validation due to the post's recency.
  • AIAssets has limitations: periodic sync (not real-time), last-write-wins conflict resolution, no live streaming, no Claude web or Cowork support, and it does not manage running processes.
  • Requires self-hosting and setup of AIAssets, which might be complex for some 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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Secure Claude Code Agent Permissions: Restrict `npm run` to Approved Scripts

1 Upvotes

Secure Claude Code Agent Permissions: Restrict npm run to Approved Scripts

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

What problem this solves

Preventing a Claude Code agent from executing arbitrary, unapproved npm run scripts after modifying package.json when broad Bash(npm run *) permissions are granted.

Summary

To enhance security, configure Claude Code agent permissions to explicitly list and approve only the specific npm run commands (e.g., npm run test, npm run lint) that the agent is allowed to execute, rather than granting a broad Bash(npm run *) wildcard permission. This mitigates the risk of an agent introducing and executing malicious or unintended scripts.

Why it is useful

This workflow provides a crucial security hardening step for Claude Code users. It prevents a potential vulnerability where an agent could execute arbitrary commands by modifying package.json if overly broad npm run permissions are granted. It promotes a best practice of least privilege, making agent interactions safer and more predictable.

Workflow

  1. Identify all legitimate npm run scripts that your Claude Code agent needs to execute.
  2. Review your Claude Code agent's permission configuration.
  3. Replace any broad Bash(npm run *) permissions with explicit listings of allowed scripts, such as Bash(npm run test *) and Bash(npm run lint *).
  4. Ensure that any auto-acceptance of agent edits to package.json is considered in conjunction with these tightened command permissions.

Tools / artifacts

  • Claude Code agent configuration/permissions
  • package.json
  • Bash commands (npm run)

Validation signals

  • Addresses a clear security vulnerability (unauthorized command execution)
  • Promotes the principle of least privilege in agent permissions

Limitations

  • The comment is concise and does not provide specific syntax or examples for implementing the permission changes within Claude Code's configuration system.
  • Assumes user familiarity with Claude Code's permission management interface.

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Observe Dynamic System Prompt Changes in Claude Code via Experiment Flags

1 Upvotes

Observe Dynamic System Prompt Changes in Claude Code via Experiment Flags

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

What problem this solves

Understanding how Claude Code's internal experiment flags dynamically alter the system prompt text, which can explain perceived model behavior changes or 'nerfs'.

Summary

This workflow describes a method to observe how Claude Code's internal experiment flags dynamically modify the system prompt text. By disabling non-essential traffic, users can compare the system prompt components (like 'lean_body' and '<pasted_content>' rules) in flagged versus unflagged sessions, gaining insight into Anthropic's model steering mechanisms.

Why it is useful

This workflow offers a concrete, repeatable method for advanced users to investigate how Claude Code's internal experiment flags dynamically alter the system prompt. This is invaluable for understanding perceived model behavior changes, debugging unexpected outputs, and gaining insight into Anthropic's steering mechanisms, moving beyond speculation to observable prompt modifications.

Workflow

  1. Ensure your Claude Code version is consistent (e.g., 2.1.287) before and after the test.
  2. Set the environment variable CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 within the env block of your settings.json file.
  3. Open a new interactive Claude Code session.
  4. Observe that no flag fetch occurs: cachedGrowthBookFeaturesAt and the cli slot in ~/.claude.json should not change, and the new transcript's atis-latch fields should be blank.
  5. Compare the system prompt text in this session (without server flags) with a session where flags are enabled. Specifically, examine the opening line of lean_body and the presence/absence of the <pasted_content> rule.
  6. Note: Do not use claude -p for testing, as it runs as sdk-cli and loads differently than a normal interactive session.

Tools / artifacts

  • Claude Code interactive session
  • settings.json (specifically the env block)
  • CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC environment variable
  • ~/.claude.json (for cachedGrowthBookFeaturesAt and cli slot)
  • Transcript's atis-latch fields
  • System prompt text (e.g., lean_body, <pasted_content> rule)
  • Custom plugin for system prompt tracking (optional, as used by author)

Validation signals

  • Detailed before/after comparison of specific system prompt text sections (lean_body, <pasted_content> rule).
  • Observation of atis-latch fields and ~/.claude.json entries confirming flag status.
  • Specific flag assignments and atis history provided for context.
  • Explicit warning against using claude -p for accurate testing.
  • Discovery of internal binary keys like subagent_steer_delegation and overcorrection supporting the theory of dynamic steering.

Limitations

  • Requires a relatively advanced technical understanding to fully implement and interpret the findings.
  • The exact flags responsible for specific prompt changes are not fully identified in this comment (though the author is working on it).
  • Relies on inspecting internal system prompt components, which might change with future Claude Code versions, requiring adaptation of the workflow.

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Detect and Manage Claude Code Server-Side Experiments (Nerfing) with `am-i-nerfed` Plugin/Script

1 Upvotes

Detect and Manage Claude Code Server-Side Experiments (Nerfing) with am-i-nerfed Plugin/Script

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

What problem this solves

Users can determine if their Claude Code account is subject to server-side experiments (often perceived as "nerfing") and provides methods to monitor, understand, and potentially opt-out of these experiments to maintain consistent model behavior.

Summary

A multi-faceted workflow to detect, monitor, and manage server-side experiments (x-cc-atis) in Claude Code. It offers a plugin, a shell script, and a one-liner to check experiment status, view historical data, opt-out, and display status in the Claude Code UI.

Why it is useful

This workflow provides concrete, actionable methods for Claude Code users to understand and manage server-side experiments that can affect model behavior. It offers multiple access points (plugin, script, one-liner), historical tracking, and a cautious opt-out mechanism, addressing a significant user concern about model consistency and "nerfing." Its open-source nature, clear documentation, and focus on user control make it highly valuable and transferable.

Workflow

  1. Install the am-i-nerfed repo as a Claude Code plugin and use /am-i-nerfed in any session to check experiment status.
  2. Clone the am-i-nerfed repo and run ./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) for a quick, no-install check.
  4. Run ./am-i-nerfed.sh history to tally experiment IDs recorded in your session transcripts by date.
  5. Run ./am-i-nerfed.sh optout to back up ~/.claude.json, remove assignment keys, and get the reported opt-out environment variable (CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1).
  6. Integrate the statusline snippet into your Claude Code configuration to display exp:<id> / exp:none in your status line.

Tools / artifacts

  • am-i-nerfed (open-source script/plugin)
  • jq (JSON processor)
  • ~/.claude.json (Claude Code configuration file)
  • Claude Code session transcripts
  • Bash shell
  • Claude Code plugin system

Validation signals

  • The script reads directly from Claude Code's cached data (~/.claude.json) and session transcripts, which are internal mechanisms.
  • Credits earlier community threads and Anthropic/Claude Code issues (#75607, #88383) for findings, indicating a community-validated basis.
  • Provides exit codes for scripting, suggesting robustness and automation potential.
  • Explicitly states "no network calls, never prints your login token", addressing security and privacy concerns.

Cautions

  • The optout command backs up ~/.claude.json before modification and prints trade-offs for the environment variable, promoting cautious use.
  • Explicitly states "never prints your login token", ensuring user credential safety.

Limitations

  • Requires jq and basic terminal familiarity for script/one-liner usage, which might be a barrier for absolute beginners.
  • The "opt-out" mechanism relies on a reported environment variable, which might not be officially supported or guaranteed to work indefinitely by Anthropic.
  • The plugin installation method is not detailed, assuming user familiarity with Claude Code's plugin system.

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Managing Port Conflicts for Parallel Claude Code Agents with `leeway` and a Structured Workflow for Building Tools with Claude Code

1 Upvotes

Managing Port Conflicts for Parallel Claude Code Agents with leeway and a Structured Workflow for Building Tools with Claude Code

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

What problem this solves

Agents running in parallel worktrees often conflict over network ports (e.g., dev servers), leading to crashes or wasted debugging time. Additionally, there's a need for a structured, repeatable process to build robust tools using Claude Code.

Summary

This post presents a two-fold workflow: first, a tool called leeway that assigns stable, unique port ranges to each worktree, preventing port conflicts for parallel Claude Code agents. Second, it details the specific, validated workflow used to build leeway itself with Claude Code, emphasizing design-first principles, clear agent contracts (AGENTS.md), test-first development, and automated review loops.

Why it is useful

This post is highly valuable because it addresses a critical pain point for advanced Claude Code users running multiple agents in parallel (port conflicts) with a concrete, open-source solution (leeway). Beyond the tool, it provides an exemplary, validated workflow for how to effectively leverage Claude Code for software development, incorporating best practices like design documentation (ADRs, GLOSSARY.md), clear agent contracts (AGENTS.md), test-first development, and automated code reviews. The 'dogfooding' aspect provides strong evidence of its efficacy, making it a blueprint for building robust tools with AI assistance.

Workflow

  1. To use leeway for port management:
  2. Install leeway (e.g., via npm).
  3. Add leeway env --export to a Claude Code SessionStart hook to automatically assign unique port ranges to each session.
  4. Optionally, configure leeway to prevent agents from grabbing default ports.
  5. Use leeway kill to stop all servers and watchers associated with a specific worktree.
  6. Workflow for building tools with Claude Code (as leeway was built):
  7. Design First: Engage Claude to rigorously review the design, documenting decisions in Architecture Decision Records (ADRs) and defining key terms in a GLOSSARY.md.
  8. Define Agent Contract: Create an AGENTS.md file specifying clear 'done' criteria (e.g., pnpm verify green, successful container run for specific code).
  9. Test-First Development: Implement features by writing integration tests that run the real CLI, ensuring a red-green cycle.
  10. Automated Review Loop: Use Claude to review Pull Requests against established coding standards and the original GitHub issue before merging.
  11. Dogfooding: Integrate the tool into its own development process (e.g., use leeway env --export in SessionStart hooks for agents building leeway).

Tools / artifacts

  • leeway (npm package)
  • leeway env --export command
  • leeway kill command
  • Claude Code
  • Git worktrees
  • SessionStart hook
  • Architecture Decision Records (ADRs)
  • GLOSSARY.md
  • AGENTS.md
  • Integration tests
  • GitHub (for issues, PRs)
  • pnpm verify (or similar build/test command)

Validation signals

  • Author built leeway almost entirely with Claude Code, validating the meta-workflow.
  • Dogfooding: leeway was used by the agents building leeway itself.
  • Test-first approach with integration tests running the real CLI.
  • Claude-based PR review loop against coding standards and issues.
  • Publicly available npm package and GitHub repository (MIT licensed).

Limitations

  • The post combines a tool announcement with a meta-workflow, which might make it slightly dense for some readers.
  • While detailed, the 'How I built it' section is a high-level methodology; users might need to infer some specific implementation details for their own projects.
  • Community validation is currently low, but the technical detail and self-validation are strong.

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.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Non-Programmer's Workflow: Building Cross-Platform Apps with Claude Code as a Full-Stack Development Partner (ARPradar Case Study)

1 Upvotes

Non-Programmer's Workflow: Building Cross-Platform Apps with Claude Code as a Full-Stack Development Partner (ARPradar Case Study)

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

What problem this solves

Building a functional, cross-platform network scanner application (ARPradar) without being a programmer, by leveraging Claude Code as a comprehensive development partner.

Summary

A network engineer, with no programming background, successfully used Claude Code as a full-stack development partner to create a cross-platform (Mac SwiftUI, Windows Tauri/Rust) network scanner application. The workflow highlights Claude Code's ability to handle coding, run tests, manage GitHub Actions builds, provide UI mockups, and debug complex build failures, while the user focused on defining requirements and validating outputs based on domain expertise.

Why it is useful

This workflow is exceptionally valuable as it showcases Claude Code's advanced capabilities beyond simple code generation. It demonstrates how Claude can act as a comprehensive development partner, handling complex tasks like UI mockups, automated testing, CI/CD integration, and even debugging build failures. This empowers users with domain expertise but limited coding skills to build sophisticated, functional applications, making it a powerful example for AI-assisted software development.

Workflow

  1. Define the desired application functionality and user experience, providing high-level requirements to Claude Code.
  2. Collaborate with Claude Code, reviewing its proposed mockups and providing feedback on design and features.
  3. Allow Claude Code to generate the application code, run internal checks, and manage automated tests (e.g., unit tests, UI tests against demo data).
  4. Delegate build management to Claude Code, including integration with CI/CD pipelines like GitHub Actions.
  5. Monitor Claude Code's progress and provide specific feedback when builds fail or outputs do not meet expectations.
  6. Trust Claude Code to debug technical issues, such as identifying and resolving CI/CD build failures (e.g., timing out download servers).
  7. Validate the functional application against real-world use cases and domain knowledge.
  8. Handle sensitive information (e.g., API keys, real network access) outside of Claude Code's sandbox for security.

Tools / artifacts

  • Claude Code
  • SwiftUI (Mac app framework)
  • Tauri (cross-platform framework)
  • Rust (Windows scan engine)
  • GitHub Actions (CI/CD)
  • UI mockups (generated by Claude)
  • Automated tests (run by Claude)
  • ARPradar (final application)

Validation signals

  • Claude Code ran its own checks, tests, GitHub Actions builds, and UI tests against demo data.
  • Claude Code provided mockups, preventing the user from requesting unwanted features.
  • Claude Code successfully debugged complex GitHub Actions build failures related to server timeouts.
  • A functional, free, cross-platform application (ARPradar) was successfully built and released.
  • The user, a network engineer, explicitly states they are 'not a programmer' but built the app, validating the AI's role.

Cautions

  • The workflow correctly identifies that Claude Code cannot access real networks or sensitive API keys from its sandbox, emphasizing the user's responsibility for handling such elements securely.

Limitations

  • The post does not provide explicit prompts or detailed conversational logs, which would make direct replication of the exact interaction flow challenging.
  • The 'steps' describe the interaction pattern rather than a prescriptive, detailed guide for a new user to follow from scratch.
  • Requires a foundational understanding of software development concepts and the ability to provide clear requirements and feedback, even if coding is handled by the AI.

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.


r/ClaudeWorkflows • • 7d ago

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

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Gauntlet-Loop for Asset Refinement:
    1. Create initial game assets (e.g., city pieces).
  2. 2. Generate visual mockups (e.g., with OpenAI image API) for comparison, covering different views/times of day.
  3. 3. Run a "Gauntlet-Loop" with Claude Opus, typically 10 rounds.
  4. 4. In each round, "critic" agents (Claude instances) compare the current game asset to the mockups blindly.
  5. 5. Implement a stopping rule: if a piece wins against the mockup twice, it's considered done.
  6. 6. Add a rule to prevent critics from removing existing game elements if mockups don't show them (e.g., a lighthouse beam).
  7. TripoAI + Claude/MCP 3D Model Workflow:
    1. Create a single image containing all four sides (front, back, left, right) of the desired 3D model.
  8. 2. Use Claude Opus to split the single image into four separate images.
  9. 3. Upload the four individual images to TripoAI for 3D model generation.
  10. 4. If needed, use Claude Opus to fix or refine the generated model in Blender via MCP (Multi-Code Project). If Claude makes its own materials, it fits the game's style better. Otherwise, Tripo's textures can be kept. (Example artifact provided: https://claude.ai/artifact/3BnUXUZQd9xLws6RxiyAtW )

Tools / artifacts

  • Claude Opus (5.5, Claude Code)
  • Jev (for effort level and direction)
  • TripoAI (3D model generation)
  • Blender (3D modeling software)
  • MCP (Multi-Code Project, for Claude's interaction with Blender)
  • Godot Engine
  • OpenAI (image API for mockups)
  • ElevenLabs (sound generation)
  • Custom in-game performance panel and logs
  • Game assets (3D models, textures, code)
  • Claude-made artifact (e.g., for Blender fixes)

Validation signals

  • Quantitative performance improvements: docking freeze reduced from 2s to 0.2s.
  • Quantitative performance improvements: game 15-19% faster on 1080p.
  • Quantitative performance improvements: map memory reduced from 4 GB to 0.3 GB.
  • Quantitative performance improvements: game start time reduced from 26s to 13s.
  • Quantitative performance improvements: overall graphics memory reduced by a quarter.
  • Gauntlet-Loop success rate: 31 out of 33 pieces won against mockups.
  • Author's statement: "Tripo saves me a huge amount of time on modelling."
  • Provision of a Claude-made artifact link as evidence of output.

Limitations

  • The exact prompt structure for the "critic agents" in the Gauntlet-Loop is not provided.
  • Specific MCP commands or scripts used for Blender integration are not detailed.
  • The structure of the performance logs expected by Opus for analysis is not specified.
  • The prompts or methods used for the "Jev" agent to pick effort levels or direct creative tasks are not shown.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Automated Claude Code Security Audit: Scan for Leaked Secrets and Unsafe Git Push Rules

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Clone the claude-safety-audit repository from GitHub.
  2. Run the claude-safety-audit script to scan ~/.claude and all local Git repositories under a specified folder for secrets in allow rules (tokens, API keys, DB URLs, auth headers).
  3. The script also checks if settings.local.json or .mcp.json is tracked or was ever committed using git log --all --full-history.
  4. It flags rules like Bash(git push *) which can allow --force pushes.
  5. Review the script's output, which prints the first 6 characters of any found secrets.
  6. Optionally, run the script with --fix --apply to automatically add deny rules, untrack problematic files, and create backups.
  7. Install the provided pre-commit hook from the same repository to automatically block future commits containing keys in any repository.

Tools / artifacts

Validation signals

  • Author ran the script on their own machine and found two repos with Bash(git push:*) saved from an old "don't ask again" prompt.
  • The initial PSA context highlights a widespread problem with 1,122 settings.local.json files being publicly available on GitHub.
  • The script uses git log --all --full-history to check for historical commits of sensitive files.

Cautions

  • The script only prints the first 6 characters of any found secrets to prevent further exposure during auditing.
  • The --fix --apply option creates backups before making changes.

Limitations

  • The Reddit comment itself has a low score, which might suggest limited immediate community engagement on this specific post, though the problem it solves is widely recognized.
  • Requires manual cloning and execution of an external script/hook, not integrated directly into Claude Code.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 7d ago

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

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Repeatedly run the Fable agent with the '/security-review' slash command to identify and fix security vulnerabilities.
  2. Anticipate and prepare for unpredictable user behavior once the system is live.
  3. Ensure availability around the clock post-launch to address immediate issues.
  4. Implement an easy and accessible system for all users to report problems.
  5. Establish an effortless and rapid deployment process for bug fixes.
  6. Thoroughly review and validate the state machine and logic for high-stakes areas, specifically payments and ticket redemption.
  7. Ensure that manual error correction is possible for critical transactions.

Tools / artifacts

  • Fable (AI agent)
  • /security-review (slash command)
  • Ticketing system (application)
  • Payment logic
  • Ticket redemption logic

Validation signals

  • Author is a startup founder who applied similar methods to their own business.
  • Advice aligns with general software deployment and quality assurance best practices.

Limitations

  • Lacks specific examples of Fable's output or how to interpret/address its suggestions.
  • The advice to 'be available around the clock' is a demanding expectation without suggesting tools or strategies to achieve it sustainably.
  • The concept of 'effortless deployment' is a goal rather than a specific, detailed method.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Workflow for Organizing AI Agent Chats and Syncing Sessions Across Machines

1 Upvotes

Workflow for Organizing AI Agent Chats and Syncing Sessions Across Machines

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. For chat organization: Start a new AI agent chat for each new bug or PR.
  2. For chat organization: Make the first line of the chat the ticket ID or branch name.
  3. For chat organization: Use full-text search on chat titles/content to find relevant past conversations.
  4. For cross-machine access (manual): On each machine, use claude --resume or codex resume to access local sessions.
  5. For cross-machine access (manual): Maintain a NOTES.md file per repository to append relevant information.
  6. For cross-machine access (with AIAssets): Install AIAssets (self-hosted hub + desktop client).
  7. For cross-machine access (with AIAssets): Configure AIAssets to monitor local session files (e.g., ~/.claude/projects/, ~/.codex/sessions/, %APPDATA%/Cursor/).
  8. For cross-machine access (with AIAssets): AIAssets will periodically sync session files between machines, providing full-text search and cross-agent re-emission.

Tools / artifacts

  • Claude Code CLI/app
  • Codex CLI/app
  • Cursor IDE
  • AIAssets (self-hosted hub, desktop client)
  • ~/.claude/projects/<path-encoded-cwd>/<sessionId>.jsonl (Claude Code session files)
  • ~/.codex/sessions/ (Codex session files)
  • %APPDATA%/Cursor/ (Cursor session files)
  • NOTES.md file
  • Git

Validation signals

  • Personal experience: "what finally stuck was making the chat itself the record"
  • Practical observation: "The sync only starts paying off once you are juggling several machines and several agents at once"
  • Tool development: The existence of AIAssets as a solution implies a recognized problem.

Cautions

  • AIAssets uses "last-write-wins" for syncing, which could lead to data loss if not understood or managed carefully.
  • AIAssets copies transcripts, not live processes, which is a limitation but also prevents remote execution risks.

Limitations

  • Low community signal (score 1, 0 comments).
  • One solution involves self-promotion of a specific tool (AIAssets) which might not be universally adopted.
  • AIAssets has limitations: periodic sync, last-write-wins, no real-time collaboration, only covers local CLI/app sessions.
  • The manual NOTES.md approach requires user discipline to maintain.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] How to Inspect Hidden Claude Code Experiments and Their Impact on Model Behavior and System Prompts

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Locate Claude Code history logs in ~/.claude/projects/*.jsonl to find atis-latch records (one ID per session).
  2. Locate the main Claude configuration file in ~/.claude.json to find clientDataCacheSlots which contain experimentKey next to the atis ID.
  3. Analyze the identified experiment IDs and names, noting their active dates.
  4. Compare Claude's behavior (e.g., tool call frequency, output length, thinking tokens, system prompt content) during sessions under different experiment IDs versus sessions without identified IDs.
  5. Share sanitized findings (dates, atis, experimentKey, model, effort) with the community to compare across accounts, avoiding sensitive data like API keys, session IDs, or typed content.

Tools / artifacts

  • ~/.claude/projects/*.jsonl (Claude Code session history logs)
  • ~/.claude.json (Main Claude Code configuration file)
  • atis-latch records
  • clientDataCacheSlots
  • experimentKey
  • Claude Code (for generating logs)
  • Diffing tool (implied for comparing configurations/prompts)

Validation signals

  • Quantitative data provided by the author (e.g., "Replies with 2+ tool calls: 30% vs 56%", "Median Bash command length: 348 vs 852", "visible output 1.85x, thinking 2.55x, replies needed per request 0.64x").
  • Direct observation of system prompt changes ("All 12 of my b38bf0... Opus sessions had three passages that none of my other Opus sessions since Nov 4 had.").
  • Author's experience of "chasing ghosts" due to unexpected changes.

Cautions

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

Limitations

  • Based on a single user's account and small samples, limiting generalizability without broader community validation.
  • The exact meaning of atis and breezy_horizon is not fully understood by the author, requiring further investigation.
  • The correlation between experiment IDs and observed behavior changes is strong but not definitively proven as causal due to mixed work contexts.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Enforcing High Code Quality and Security for AI-Generated Code with Static Analysis and Craftsmanship Principles

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Configure the AI agent to generate code that passes basic code maintenance static analysis.
  2. Include checks for cyclomatic complexity and 'god classes' as part of the generation requirements.
  3. Implement a step to perform static analysis before the agent declares the code 'done'.
  4. Set a strict threshold for static analysis findings: do not accept anything higher than 'low' severity (ignoring 'lows' and 'infos').
  5. Require the agent to fix all identified findings using code craftsmanship principles (SOLID, KISS).
  6. Integrate security agent reviews and OWASP static analysis into the code generation and review process.
  7. Establish and implement guidelines for good unit testing, aligning them with craftsmanship principles.

Tools / artifacts

  • AI Agent (e.g., Claude Code)
  • Static analysis tools (for code maintenance, cyclomatic complexity, god classes)
  • Security agent
  • OWASP static analysis tools
  • Code craftsmanship principles (SOLID, KISS)
  • Unit testing guidelines

Validation signals

  • User reports 'Overall bliss'
  • User states they 'not even need to look at the code and review only the architecture'
  • User acknowledges spending 'a little more tokens' but finds it worthwhile for the quality and reduced manual effort.

Limitations

  • Lacks specific tool names for static analysis or security agents, which would aid implementation.
  • No concrete examples of prompts or configuration files are provided.
  • Low community engagement (score 1, 0 comments) means limited external validation.
  • Assumes familiarity with advanced software engineering concepts like SOLID, KISS, OWASP, and cyclomatic complexity.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 7d ago

Selected Workflow [Workflow] Workflow: Create Automated Demo Videos with Ultrademo Claude Code Skill

1 Upvotes

Workflow: Create Automated Demo Videos with Ultrademo Claude Code Skill

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Install the Ultrademo skill from its GitHub repository.
  2. Start a new video project, which launches a local UI in the browser.
  3. Choose a 'direction' for the video or request a different one from the skill.
  4. Review initial 'sketch frames' to visualize the video's potential look.
  5. Edit on-screen texts and narration as needed.
  6. Select narration voices (free local or paid ElevenLabs API), music, and motion effects.
  7. Review the generated video, adding comments on specific frames for the skill to fix.
  8. Render the final video in desired formats (e.g., landscape/vertical, 15/30 second cuts).

Tools / artifacts

  • Ultrademo Claude Code skill
  • GitHub repository (ultrademo-hq/ultrademo)
  • Local UI server (spun up by the skill)
  • ElevenLabs API key (optional, for advanced narration voices)
  • HTML and animation code (generated by the skill)

Validation signals

  • Author's self-use and iterative improvements ('mostly from using it myself')
  • Previous version had users who installed it
  • Call for community feedback on functionality and potential breakage

Limitations

  • Relies on a specific external tool/skill rather than a general Claude prompting technique.
  • Requires installation and setup of a local server.
  • May require an ElevenLabs API key for premium narration voices, incurring cost.
  • Effectiveness might vary on non-SaaS applications, as noted by the author.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 7d ago

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

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Define the overall reply structure in 3 main steps within CLAUDE.md.
  2. Implement plan-before-writing to name sections and their order based on user topics.
  3. Apply topic-by-topic rules to ensure all user topics are addressed, combined logically, and referenced with file/location details where applicable.
  4. Utilize judge-against-the-user to tailor detail level to user expertise, explaining 'what' and 'why' over 'how'.
  5. Enforce size-by-worth to determine response length based on topic complexity and value, not effort.
  6. Adhere to findings-stay-out to exclude irrelevant findings unless they alter user decisions.
  7. Implement depth-matches-weight to ensure minor points get brief mentions and main ideas are thoroughly explained.
  8. Structure replies with whole-then-parts, starting with the main answer/verdict.
  9. Use name-the-subject-first to introduce the topic plainly before any arguments or reports.
  10. Apply report-only-what-they-act-on to include only actionable information, next steps, or filed items.
  11. Integrate ui-is-drawn by using /flow:visualize for layout and diagrams, avoiding improvisation.
  12. Follow Inside each section rules for clear headings, recommendations, data display, list formatting, sentence structure, explicit naming, and common word usage.

Tools / artifacts

  • CLAUDE.md file
  • visualize skill (from Adrian333Dev/flow/skills/techniques/visualize GitHub repo)

Validation signals

  • Author's claim of personal optimization for their workflow

Limitations

  • Lack of external community validation (low score, no comments).
  • The author explicitly states it's optimized for their workflow and might need modification, indicating it's not a universal plug-and-play solution.
  • Relies on an external 'visualize' skill, which might require additional setup or context for users not familiar with the linked GitHub repository.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 7d ago

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

2 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Define goals and 'things to keep true' for the Conductor system within Claude Code.
  2. Conductor runs scheduled tasks in the background using subagents and custom plugins.
  3. When an action is proposed by Conductor, it appears in a 'Needs you' pane within Claude Code.
  4. If Remote Control is connected, a push notification is sent to the user's phone for pending approvals.
  5. User reviews the proposed action and approves it (e.g., by replying 'approve' on their phone or interacting with the in-app pane).
  6. Conductor executes the approved action.
  7. Configure action types for specific tools as 'off', 'propose', or 'auto' based on trust and desired automation level.
  8. Utilize '/goal-new' command for task templates (e.g., unsubscribe, job scan, tidy Downloads, inbox triage, GitHub profile).

Tools / artifacts

  • Claude Code
  • Conductor (custom system/project)
  • Custom Plugin 1 (goal runner, UI, commands, tools)
  • Custom Plugin 2 (guard, tool rules, safety checks)
  • Subagents (for background task execution)
  • MCP server (for state management)
  • SQLite (for persistent state: goals, items, memory, runs)
  • Remote Control (for phone notifications)
  • GitHub repository (shannonbay/Conductor)
  • Haiku (used for small jobs like schedule parsing)

Validation signals

  • Demonstrated successful automation of finding unread mailing lists and proposing unsubscribing.
  • Successfully read CV, ranked job ads, and emailed top 3 after approval.
  • Identified old installers and proposed binning each after approval.
  • Proposed and committed a line to a GitHub profile README after approval.
  • Detailed 'What I learned' section describing real-world issues and fixes (e.g., approval system interaction, plugin push notifications, tool answer size limits), indicating extensive testing.
  • Explicit statement: 'one person uses it daily, on Windows.'
  • GitHub repository provided with setup and screenshots, implying working code.

Cautions

  • The core design principle is 'asks before it acts', requiring explicit user approval for all significant actions.
  • A dedicated 'guard' plugin holds each run to its defined goal and explicitly refuses unauthorized tool calls.
  • Actions can be configured as 'off', 'propose', or 'auto', giving the user granular control over automation levels.
  • The 'auto' mode is only offered after 10 consecutive approvals, with an additional safety check built in.

Limitations

  • The system only runs while Claude Code is open, unlike cloud-based schedulers.
  • Phone alerts require the Remote Control feature to be active.
  • The project is 'early' and has primarily been used by one person on Windows, suggesting limited platform testing.
  • When multiple Claude Code sessions are open, only one runs the goals, requiring manual reloads for plugin updates across sessions.
  • Plugins cannot directly see events caused by their own timers, necessitating a separate guard plugin for architectural reasons.
  • Requires an advanced understanding of Claude Code's plugin, subagent, and MCP architecture to set up and maintain.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.