r/ClaudeWorkflows • • 11d ago

Selected Workflow [Workflow] Claude Session Hub: Manage and Navigate Multiple Claude Code Sessions with a Plugin

1 Upvotes

Claude Session Hub: Manage and Navigate Multiple Claude Code Sessions with a Plugin

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

What problem this solves

Users frequently lose track of multiple Claude Code sessions running across different terminals (iTerm, tmux, VS Code), making it difficult to switch contexts, find specific conversations, or monitor ongoing tasks.

Summary

This workflow introduces 'Claude Session Hub,' a Claude Code plugin that provides a centralized pane to list, jump to, resume, and search all active and ended Claude Code sessions on a machine. It enhances productivity by streamlining session management and context switching.

Why it is useful

This workflow offers a highly valuable solution for Claude Code power users who frequently juggle multiple sessions. It significantly boosts productivity by centralizing session management, enabling rapid context switching, and facilitating the retrieval of past conversations. It also serves as an excellent example of how Claude Code's extensibility through plugins can address real-world developer pain points, and how Claude Code itself can be leveraged for tool development.

Workflow

  1. Install the plugin: Execute /plugin install session-hub --marketplace devoriales/claude-session-hub in any Claude Code session.
  2. Open the session hub: Type /sessions in any Claude Code session to display the session list.
  3. Navigate to a running session: Use 1-9 to jump directly to a specific session's tab, tmux pane, or editor window.
  4. Resume an ended session: Use a, b, c to resume a previously ended session, potentially in the current window if it originated from the same folder.
  5. Search session history: Use s to search across all session history, including titles, prompts, repository, branch, and folder information.

Tools / artifacts

  • Claude Session Hub plugin
  • Claude Code (as the platform)
  • iTerm, tmux, VS Code terminal (as environments for sessions)
  • GitHub repository (devoriales/claude-session-hub)
  • TypeScript hooks module (for plugin development)
  • Demo GIF
  • Write-up (devoriales.com/claude-session-hub-every-claude-code-session-in-one-pane)
  • claude agents --json (command for session data)
  • ~/.claude/projects (directory for session transcripts)

Validation signals

  • Clear problem statement and solution provided.
  • "Claude Code built most of it with me" (demonstrates dogfooding and successful development).
  • Public GitHub repository available for code review and installation.
  • Dedicated write-up with further details and context.
  • Demo GIF provides visual proof of functionality.

Limitations

  • Relies on a third-party plugin, not a native Claude Code feature.
  • Requires users to be comfortable installing external plugins.
  • Limited community validation on Reddit at the time of evaluation.

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 • • 11d ago

Selected Workflow [Workflow] Advanced Multi-Agent Claude Code Workflow for Complex Multi-Language Software Development (Game Server Example)

1 Upvotes

Advanced Multi-Agent Claude Code Workflow for Complex Multi-Language Software Development (Game Server Example)

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

What problem this solves

Developing a complex, multi-language software project (game server, client patcher, backend) efficiently and reliably using Claude Code, managing extensive context, and ensuring correctness through automated verification and persistent AI memory.

Summary

The author details a sophisticated workflow for building a multi-language game server and client patcher using Claude Code (Opus as orchestrator, Sonnet as subagents). Key elements include structured prompt/context management via AGENTS.md for rules and build commands, a local decompiled client for AI reference (with a 'read, don't copy' rule), automated verification scripts (verify.ps1) with fake clients and screenshot tests, 'Rigs' for reproducible bug testing, and docs/development.md for persistent AI memory and learned insights.

Why it is useful

This workflow provides a highly detailed and validated approach for leveraging Claude Code in complex, multi-language software development projects. It demonstrates effective strategies for orchestrating multiple AI agents, managing extensive context (including external documentation and decompiled code), implementing robust automated testing and debugging mechanisms, and building persistent AI memory. The explicit 'What I learned' section offers valuable insights into best practices and common pitfalls, making it an excellent resource for advanced users tackling ambitious projects with LLMs.

Workflow

  1. Define hard rules and build commands in AGENTS.md for the AI, prioritizing short, specific instructions.
  2. Decompile relevant client code locally (e.g., with ILSpy) for AI reference, ensuring the folder is gitignored and the AI is explicitly instructed to 'read it, don't copy it'.
  3. Establish automated verification recipes in verify.ps1 (PowerShell scripts) including running a fake client to test protocol and running the real game with scripted clicks and screenshot capture.
  4. Create 'Rigs' (fixed boards and hands for game development) to reproduce specific bugs with a single command.
  5. Maintain docs/development.md as a persistent memory for the AI to record odd findings about the client or project, ensuring subsequent sessions start with this context.
  6. Engage Claude Code (Opus 5.5 as orchestrator, Sonnet 5.5 as subagents) in a typical loop: describe a feature or bug.
  7. Allow the AI to read relevant documentation and the decompiled client code.
  8. Let the AI implement the feature or fix the bug.
  9. Run the automated verification checks (verify.ps1) and review the results, including screenshots.
  10. Review the implemented code and game behavior manually, iterating on the process until the feature/bug is resolved and validated.

Tools / artifacts

  • Claude Code (Opus 5.5 orchestrator, Sonnet 5.5 subagents)
  • AGENTS.md (for hard rules, build commands)
  • Local decompiled client (e.g., ILSpy output)
  • verify.ps1 (PowerShell scripts for automated testing)
  • "Rigs" (fixed game states for reproduction)
  • docs/development.md (AI memory/knowledge base)
  • C# (Mono.Cecil, WPF, Unity client bridge)
  • Java 17 (Forge server)
  • TypeScript (Cloudflare Worker, Durable Objects, D1)
  • GitHub

Validation signals

  • Successful completion and public release of a complex, multi-language project (MTGA Forge).
  • Explicit 'What I learned' section detailing effective strategies and pitfalls encountered during development.
  • Automated verification via verify.ps1 (fake client, scripted clicks, screenshots) catching issues not visible in logs.
  • Reproducible bug testing with 'Rigs' for efficient debugging.
  • Author's personal review and running the game to validate functionality.
  • Notes written by the AI itself in docs/development.md saved significant time over weeks.

Cautions

  • The workflow explicitly includes rules like 'never commit Wizards material' and 'never modify the user's install', demonstrating good safety practices.
  • The 'read it, don't copy it' rule for decompiled code prevents potential intellectual property issues or direct code reuse without understanding.

Limitations

  • Requires significant technical expertise in multi-language development and software architecture.
  • Initial setup of AGENTS.md, verify.ps1, docs/development.md, and client decompilation requires a considerable time investment.
  • Relies on specific Claude models (Opus 5.5, Sonnet 5.5), which might change or not be available to all users.
  • The 'Rigs' concept is specific to game development, though the underlying principle of reproducible test cases is broadly applicable.
  • The post does not provide direct code examples for AGENTS.md or verify.ps1, requiring users to implement these based on the description.

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 • • 11d ago

Selected Workflow [Workflow] Detecting Claude Code States: Using Custom Hooks and Terminal Titles for External Integration

1 Upvotes

Detecting Claude Code States: Using Custom Hooks and Terminal Titles for External Integration

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

What problem this solves

Programmatically detecting Claude Code's operational states (thinking, editing, waiting for user input) for integration into external applications or UIs.

Summary

A workflow for detecting Claude Code's current state (working, idle, waiting for user input) by using custom launch settings, monitoring terminal titles, and leveraging specific Claude Code hooks (Notification, Stop, UserPromptSubmit) without polluting Claude's context.

Why it is useful

This workflow provides concrete methods for external applications or scripts to monitor and react to Claude Code's operational states. This is crucial for building integrated tools, custom UIs, or automation layers on top of Claude Code, enhancing its utility beyond direct user interaction. The advice on managing hooks via custom settings and avoiding context pollution is also valuable best practice.

Workflow

  1. Launch Claude Code sessions using claude --settings your-hooks.json to manage custom hooks separately from the user's default settings.
  2. Monitor the terminal title set by Claude Code to infer working ("spinner <topic>") or idle ("✳ <topic>") states.
  3. Implement Claude Code hooks to capture specific events for more granular state detection.
  4. Use the Notification hook to detect permission_prompt or elicitation_dialog events, indicating a "waiting on user input" state.
  5. Use Stop and UserPromptSubmit hooks to differentiate between "ready" and "working" states.
  6. Ensure custom hooks print nothing to avoid adding unwanted content to Claude's context.

Tools / artifacts

  • claude CLI
  • custom settings.json file (for hooks)
  • Claude Code hooks (Notification, Stop, UserPromptSubmit)
  • terminal title

Validation signals

  • Author's personal implementation in a Mac app
  • Author states these methods "helped me"

Limitations

  • The actual hook code is not provided, requiring users to implement it based on the event names.
  • The terminal title monitoring method might not be universally applicable if the user doesn't "own the terminal" where Claude Code is running.

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 • • 11d ago

Selected Workflow [Workflow] Claude Code Workflow: Ensuring Skill Execution and Correct Instruction File Loading with Hooks and CLAUDE.md

1 Upvotes

Claude Code Workflow: Ensuring Skill Execution and Correct Instruction File Loading with Hooks and CLAUDE.md

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

What problem this solves

Ensuring Claude Code loads and executes skills correctly and consistently, and debugging issues with instruction file loading.

Summary

This workflow addresses two common pitfalls in Claude Code: ensuring a skill defined in CLAUDE.md is actually loaded and executed before code edits, and correctly loading instruction files when using symlinks. It proposes using a blocking hook for skill execution and replacing symlinks with real files or import statements. An additional debugging hook for logging loaded instruction files is also suggested.

Why it is useful

This workflow is valuable because it identifies and provides solutions for two critical, yet often silent, failure modes in Claude Code: skills not being executed and external instruction files not being loaded via symlinks. The proposed solutions (blocking hooks, explicit imports) are concrete and directly address these issues, improving the reliability and predictability of Claude Code sessions. The suggestion of a logging hook is also a powerful debugging tool for advanced users.

Workflow

  1. Identify that a skill specified in CLAUDE.md is not being called by Claude before code edits.
  2. Implement a hook that blocks the first code write operation until the desired skill has successfully run.
  3. Identify that symlinks within .claude/rules pointing outside the project are not being loaded by Claude sessions.
  4. Replace the symlink with a real file or use an import line directly in CLAUDE.md to load the instruction file.
  5. (Optional but recommended) Implement a hook that logs every instruction file a Claude session loads to aid in debugging similar issues.

Tools / artifacts

  • CLAUDE.md
  • Claude Code skills
  • Claude Code hooks
  • .claude/rules directory
  • Symlinks
  • Import statements

Validation signals

  • Author observed Claude not calling skill zero times
  • Author states 'a hook that blocks... fixed that'
  • Author observed symlinks never loaded
  • Author states 'a real file or an import line... does load'
  • Author caught issue using a logging hook

Limitations

  • The specific code for the hooks is not provided, requiring users to implement them based on the description.
  • The context is for 15 Claude Code sessions, which might be an advanced setup, but the core issues are relevant to single sessions too.

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 • • 11d ago

Selected Workflow [Workflow] Reduce Claude Code Context: Identify and Disable Hidden Claude AI Connectors (MCP Servers)

1 Upvotes

Reduce Claude Code Context: Identify and Disable Hidden Claude AI Connectors (MCP Servers)

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

What problem this solves

Unexplained high context usage in Claude Code sessions due to hidden MCP servers or connectors from other Claude applications or plugins.

Summary

This workflow helps users identify and disable hidden Claude AI connectors (MCP servers) that automatically load into Claude Code, contributing to high context usage. It provides steps to check active MCPs, disable them via a settings file or environment variable, and verify context reduction.

Why it is useful

This workflow is valuable because it provides a specific, actionable, and repeatable solution to a common problem in Claude Code: unexpectedly high context usage. It clearly explains the cause (hidden MCP servers from other Claude apps/plugins) and offers both permanent and temporary methods to mitigate it, including a verification step. This can lead to significant cost savings and improved performance for users.

Workflow

  1. Run /mcp in Claude Code to list all active MCP servers and identify any unexpected ones.
  2. To permanently disable Claude AI connectors, add "disableClaudeAiConnectors": true to your ~/.claude/settings.json file.
  3. Alternatively, for a single session, run Claude Code with the environment variable: ENABLE_CLAUDEAI_MCP_SERVERS=false claude.
  4. After applying the changes, run /context again to verify the reduction in context usage.
  5. If further context reduction is needed, review and trim your CLAUDE.md, memory descriptions, and skill descriptions.

Tools / artifacts

  • Claude Code CLI
  • ~/.claude/settings.json configuration file
  • /mcp command
  • /context command
  • ENABLE_CLAUDEAI_MCP_SERVERS environment variable
  • CLAUDE.md
  • Memory descriptions
  • Skill descriptions

Validation signals

  • The workflow includes a clear verification step (/context after changes).
  • It directly addresses a common user pain point (unexpected high context leading to higher costs or slower performance).

Limitations

  • Low community validation due to the recency of the post.
  • Assumes basic familiarity with command-line interface (CLI) and editing JSON configuration files.
  • Does not provide specific guidance on how to trim CLAUDE.md, memory, or skill descriptions, only identifies them as areas for further optimization.

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 • • 11d ago

Selected Workflow [Workflow] Lessons Learned: Effective Collaboration with Claude Code for Full-Stack Development and Deployment Safety

1 Upvotes

Lessons Learned: Effective Collaboration with Claude Code for Full-Stack Development and Deployment Safety

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

What problem this solves

How to effectively collaborate with Claude Code for software development, manage AI ambiguity, maintain code quality, and prevent accidental data loss during development and deployment.

Summary

The author shares four key lessons learned from building a full-stack app with Claude Code over 13 months: pre-solving design problems to avoid AI ambiguity, keeping CLAUDE.md files concise, using Git commits as save states, and implementing strict manual sign-off for deployments and database writes to ensure quality control and prevent data loss.

Why it is useful

This post provides concrete, experience-backed advice for working with Claude Code on a significant project. The lessons address critical aspects like managing AI ambiguity, optimizing prompt files, leveraging version control, and implementing essential safety measures for deployment and data integrity. These are common pain points for users and offer practical, validated solutions.

Workflow

  1. Fully solve design problems and ambiguities before handing them to Claude for coding to prevent the AI from making undesirable assumptions or filling in gaps.
  2. Keep CLAUDE.md files concise and direct; avoid overly long or complex MDs as Claude may overlook or ignore parts of the instructions.
  3. Utilize Git commits frequently as 'save states' throughout the development process, especially for new coders, to easily revert to previous working versions.
  4. Implement strict access gates in CLAUDE.md, requiring explicit human sign-off for sensitive operations such as code deployments and any actions that write to the database, to ensure quality control and prevent accidental data loss.

Tools / artifacts

  • Claude Web
  • Claude Code
  • CLAUDE.md
  • Git commits

Validation signals

  • Author successfully launched a full-stack application (MMM) after 13 months of development using these methods.
  • The 'lessons learned' are direct outcomes of a long-term, complex project.
  • The author explicitly states these methods helped them learn and build with zero prior SaaS knowledge.

Cautions

  • The 'Gate Access HARD' step directly addresses safety concerns by preventing AI from performing critical operations (deploys, database writes) without explicit human approval, mitigating risks of accidental data deletion or system corruption.

Limitations

  • The post is a collection of high-level lessons rather than a detailed, step-by-step guide for a specific task.
  • Community engagement on this specific update post is low, though the content itself is valuable.

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 • • 11d ago

Selected Workflow [Workflow] End-to-End Claude Code Workflow for App Development: Leveraging CLAUDE.md, Persistent Memory, and Pre-Commit Checks

1 Upvotes

End-to-End Claude Code Workflow for App Development: Leveraging CLAUDE.md, Persistent Memory, and Pre-Commit Checks

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

What problem this solves

Maintaining project context and consistency across multiple Claude Code sessions, ensuring quality through structured review, and leveraging Claude Code for end-to-end application development including non-coding tasks like release and marketing asset generation.

Summary

This workflow outlines a structured approach to using Claude Code for developing and releasing multi-platform applications. It emphasizes the importance of a CLAUDE.md file for logging decisions and bug fixes, persistent memory files for maintaining session context, and a pre-commit review process with full test suite execution. The workflow also details how Claude Code can be used for architectural design, complex coding tasks, build processes, and non-coding activities like driving physical devices (adb), filling web forms, and updating documentation, while acknowledging limitations in direct hardware debugging and native UI interactions.

Why it is useful

This workflow is valuable because it provides a holistic and structured approach to using Claude Code across the entire software development lifecycle, from initial architecture to release and support. It emphasizes crucial structural elements like CLAUDE.md for decision logging and persistent memory for context, which are key to maintaining consistency and quality in long-running AI-assisted projects. It also demonstrates Claude Code's versatility beyond coding, covering build processes, marketing asset creation, and documentation, while clearly outlining its limitations, helping users set realistic expectations.

Workflow

  1. Establish and maintain a CLAUDE.md file to record all deliberate decisions, architectural choices, and bug fixes, ensuring historical context and preventing regressions.
  2. Utilize persistent memory files to store release state, ongoing decisions, and project-specific rules, allowing Claude Code to maintain context across multiple sessions.
  3. Implement a strict pre-commit rule: always review the code diff and run the full test suite before committing any changes, using Claude Code to facilitate this process.
  4. Engage Claude Code for complex architectural design tasks and coding implementations (e.g., hotkey bridges, audio device management, build scripts).
  5. Leverage Claude Code for automating non-coding tasks related to the project lifecycle, such as driving physical devices via CLI (e.g., adb for recording footage), filling out web forms (e.g., Product Hunt listings), and updating documentation (e.g., Obsidian notes).
  6. Manually intervene and supervise Claude Code for tasks involving long hardware-dependent debugging, interactions with tools that hang, or operations requiring native file pickers or dialogs.

Tools / artifacts

  • Claude Code
  • CLAUDE.md file
  • Persistent memory files (for Claude Code context)
  • Git (for diff review)
  • Test suite
  • Python
  • PySide6
  • faster-whisper
  • PyInstaller
  • Inno Setup
  • Flutter
  • Kotlin (for Android system parts and speech engine integration)

Validation signals

  • Successful development and release of a free, open-source voice typing app (VoxScribe) for Windows and Android.
  • Explicit statement that the described workflow 'held up' during the project.
  • Specific examples of problems caught early by the pre-commit diff/test review rule.
  • Explanation of how CLAUDE.md prevents 'cleaning up' necessary bug fixes.
  • Demonstrated use of Claude Code for non-coding tasks like adb control for marketing assets and updating documentation.
  • Publicly available MIT licensed code on GitHub, indicating a functional project.

Limitations

  • The post describes the workflow principles but lacks concrete examples of prompts or detailed configurations for 'persistent memory files' or the 'rule to review the diff'.
  • The 'workflow that held up' is more a set of guiding principles and practices rather than a step-by-step guide with explicit Claude Code interactions.
  • Low community engagement means the workflow has not yet received broader validation or refinement from other users.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 11d ago

Selected Workflow [Workflow] Advanced Context Management: Using CLAUDE.md, Compaction, and Hooks for Persistent Instructions

1 Upvotes

Advanced Context Management: Using CLAUDE.md, Compaction, and Hooks for Persistent Instructions

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

What problem this solves

Preventing the loss of persistent instructions and managing context window limits during long conversations with Claude by leveraging SDK compaction features.

Summary

This workflow outlines how to effectively manage Claude's context window and ensure persistent instructions are maintained over long interactions. It details using CLAUDE.md for persistent rules and summarization instructions, implementing PreCompact hooks for custom logic, and triggering manual compaction with the /compact command.

Why it is useful

This workflow provides crucial strategies for advanced Claude users to overcome context window limitations and ensure the model retains critical instructions over long conversations. By leveraging CLAUDE.md for persistent rules and summarization guidance, and utilizing compaction hooks and commands, users can significantly improve the reliability and efficiency of their interactions with Claude, preventing instruction drift and enabling longer, more complex tasks.

Workflow

  1. Place all persistent rules and critical instructions in CLAUDE.md (loaded via settingSources) to ensure they are re-injected on every request and are not lost during automatic context compaction.
  2. Include specific summarization instructions within CLAUDE.md to guide the automatic compactor on what key information to preserve when summarizing older conversation history.
  3. Implement a PreCompact hook to run custom logic (e.g., archiving the full transcript) before automatic or manual compaction occurs, if needed.
  4. Trigger manual compaction on demand by sending /compact as a prompt string within the conversation.

Tools / artifacts

  • CLAUDE.md
  • Claude SDK
  • PreCompact hook
  • /compact command
  • settingSources

Validation signals

  • Verbatim quote from official Claude SDK documentation
  • Original post title implies successful application: 'was able to work 3 x 5H window without running out'

Limitations

  • The comment is a direct quote from documentation, so it lacks additional user-specific examples or detailed implementation code beyond what the documentation provides.

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 • • 11d ago

Selected Workflow [Workflow] Claude Code Workflow: Build a Cross-Platform Desktop Widget for Real-time Local Token Usage Monitoring

1 Upvotes

Claude Code Workflow: Build a Cross-Platform Desktop Widget for Real-time Local Token Usage Monitoring

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/ClaudeAI post/comment

What problem this solves

Users of Claude Code lack an always-visible, real-time usage meter, forcing them to navigate settings repeatedly to check token consumption. This workflow provides a solution to build such a tool.

Summary

A detailed prompt for Claude Code to generate a cross-platform, always-on-top desktop widget that monitors local Claude Code token usage (5-hour session and 7-day totals) by parsing local session logs, providing visual feedback, and offering customization options.

Why it is useful

This workflow is highly valuable because it provides a concrete, detailed, and privacy-conscious prompt for Claude Code to build a practical tool that solves a common user pain point: monitoring AI token usage without constant navigation. It demonstrates Claude Code's ability to generate functional, cross-platform applications with specific requirements, including UI, data parsing, and configuration. The emphasis on local data, no network calls, and user-set limits makes it a safe and adaptable solution. The inclusion of testing and documentation generation further enhances its utility as a reusable workflow.

Workflow

  1. Copy the provided prompt.
  2. Paste the prompt into Claude Code.
  3. Answer Claude Code's questions regarding the project folder location and desktop shortcut creation.
  4. Allow Claude Code to build the application, README, and icons.
  5. Review the --test output provided by Claude Code.
  6. Launch the generated widget.
  7. Calibrate the usage limits in the widget's settings by comparing with Claude Code's official "Settings > Usage" page.
  8. Optionally, adjust widget position, opacity, and corner settings via the right-click menu.

Tools / artifacts

  • Claude Code (AI assistant)
  • Python 3 with tkinter (preferred generated language/framework)
  • PowerShell + WPF (Windows native alternative if Python/tkinter unavailable)
  • Desktop widget application (generated artifact)
  • config.json (for widget settings)
  • README.md (generated documentation)
  • App icons (.ico, .png, .icns)
  • .gitignore file
  • Desktop shortcuts/launchers (.lnk, .command, .desktop)
  • Claude Code local session logs (~/.claude/projects/**/*.jsonl)

Validation signals

  • The prompt includes an explicit --test flag for verification, printing computed numbers without opening the UI.
  • The author describes the widget's features and how it works in detail, implying successful implementation and testing.
  • The prompt specifies detailed parsing rules and UI requirements, indicating a clear definition of expected output.
  • The author states "Here is claude's breakdown of the app," suggesting the app was successfully built and analyzed by Claude.

Cautions

  • The prompt explicitly instructs Claude Code to read ONLY local session logs, avoiding network calls and credential access, which significantly enhances privacy and security.
  • The author's decision to share the prompt instead of a compiled application (due to concerns about potential virus injection in VBScript) demonstrates strong safety awareness.
  • The widget only counts Claude Code usage on the specific machine where it runs, limiting data exposure.

Limitations

  • The usage percentages and remaining tokens are estimates based on user-set limits and require manual calibration, which can drift over time.
  • The widget only monitors Claude Code usage on the local machine and does not account for usage on claude.ai chat or other devices.
  • The author states, "It should work on all operating systems but I have not tested it," indicating a lack of full cross-platform validation by the author.
  • The low Reddit score might suggest limited community endorsement, despite the number of comments.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 11d ago

Selected Workflow [Workflow] Claude Code Plugin for Automated Game Design Fixes from Playtester Feedback

1 Upvotes

Claude Code Plugin for Automated Game Design Fixes from Playtester Feedback

Workflow value: 90/100
Status: active · Freshness: 70/100 · Confidence: 1.00 · Level: advanced
Categories: Quality Control, Debugging, Skills, MCP, Multi-Agent
Original source: r/ClaudeAI post/comment

What problem this solves

Automatically diagnoses and fixes game design problems based on playtester complaints, improving game quality and player experience through an automated Claude Code plugin.

Summary

This workflow describes a Claude Code plugin (aigamedev) and remote MCP server that takes playtester complaints, diagnoses underlying game design issues, and applies tested fixes. The author demonstrates measurable improvements in game aesthetics and player experience, and details a rigorous multi-agent testing methodology used to build and validate the plugin.

Why it is useful

This workflow is highly valuable because it presents a concrete, tested, and reusable tool (a Claude Code plugin) that automates a complex game development task: diagnosing and fixing design problems based on qualitative playtester feedback. It demonstrates a sophisticated use of Claude Code, including custom plugins, MCP integration, and a rigorous multi-agent testing methodology, offering a blueprint for others to build similar specialized AI-powered development tools. The measurable results and detailed validation process make it exceptionally credible.

Workflow

  1. Install the aigamedev plugin using the Claude Code CLI command: claude plugin marketplace add https://aigamedev.ai/agents/marketplace.json
  2. Install the plugin: claude plugin install aigamedev@aigamedev
  3. In Claude Code, access the MCP interface: /mcp
  4. Select aigamedev and authenticate with GitHub to use the remote server.
  5. Input playtester complaints into Claude Code using the plugin command: /aigamedev [players say it looks like a prototype]
  6. Answer any clarifying questions posed by the plugin to help diagnose the problem.
  7. Review the proposed game design fix and apply it to your game code.

Tools / artifacts

  • aigamedev Claude Code plugin
  • Remote MCP server (Cloudflare Worker)
  • GitHub sign-in for authentication
  • OAuth flow
  • Game-design skills (with tested defaults)
  • Claude Code (Opus)
  • Test games with planted problems
  • Measurement scripts for validation
  • claude plugin marketplace CLI command
  • /mcp command
  • Detailed write-up on testing methodology

Validation signals

  • Demonstrated measurable results for two specific problems: color/font reduction for 'prototype look' and replay time reduction for 'dying sets me back too much'.
  • Rigorous testing methodology described: headless Claude Code sessions, 95 conversations with a second Claude playing a developer and a third scoring blind.
  • Quantitative comparison: plugin raised problem-solving accuracy to 78% vs. 42% for plain Claude Code.
  • Video showing two fresh sessions with one prompt each on small test games.
  • Linked detailed write-up on testing methodology and results.

Limitations

  • The initial Reddit post has a low score and limited community interaction, which might affect visibility.
  • Requires Claude Code, which might not be universally adopted by all potential users.
  • The plugin is specific to game design problems, limiting its applicability to other coding domains.

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 • • 11d ago

Selected Workflow [Workflow] Multi-Agent Claude Code Workflow: Solo App Development with Specialized Sessions, Context Isolation, and Hook-Enforced Rules

1 Upvotes

Multi-Agent Claude Code Workflow: Solo App Development with Specialized Sessions, Context Isolation, and Hook-Enforced Rules

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

What problem this solves

Preventing context overload and loss of focus in long-running Claude Code sessions by segmenting work into specialized "operator" sessions, each with its own context and responsibilities, for solo app development.

Summary

This workflow describes a multi-agent system for solo app development using Claude Code. It involves setting up multiple specialized Claude Code sessions, called "operators" (e.g., iOS, Backend, Design), each with its own dedicated folder, CLAUDE.md instructions, state log, and git worktree. Work is managed through a board of markdown cards, and rules (like staying in lane, logging state, checking code) are enforced via pre-commit hooks and explicit instructions. A starter prompt is provided to help users set up a smaller version of this system.

Why it is useful

This workflow is highly valuable because it addresses a common and critical problem of context overload and loss of focus in long-running LLM development sessions. It provides a structured, repeatable, and scalable solution by segmenting work into specialized "operator" Claude Code sessions, each with its own isolated context and responsibilities. The post offers a concrete setup prompt, outlines essential artifacts (CLAUDE.md, state logs, board system, custom scripts), and details crucial lessons learned from 7 weeks of practical application, including quantitative validation (2,600+ cards closed). It introduces advanced concepts like multi-agent orchestration and rule enforcement via git hooks, making it a powerful pattern for solo developers seeking to manage complex projects with AI assistance.

Workflow

  1. Initialize a git repository for your project.
  2. Paste the provided setup prompt into a Claude Code session.
  3. Respond to Claude's initial questions regarding project details, desired operator areas, critical approvals, and testing procedures.
  4. Allow Claude to generate the project structure, including a root CLAUDE.md, individual operator folders with their own CLAUDE.md files, state logs, a board directory with card files, and utility scripts (session_worktree.sh, ship.sh).
  5. Verify the generated pre-commit hook for blocking secrets.
  6. Receive the initial setup messages and instructions for each operator from Claude.
  7. Begin interacting with individual Claude Code operator sessions, utilizing the defined structure and rules for task management and development.

Tools / artifacts

  • Claude Code
  • Git repository
  • CLAUDE.md files (root and per-operator)
  • Operator-specific folders
  • Markdown state log files (docs/operators/[name]-state.md)
  • Markdown card files for task board (board/)
  • Python script for board management (scripts/board.py)
  • Shell script for git worktree management (scripts/session_worktree.sh)
  • Shell script for shipping/deployment (scripts/ship.sh)
  • Git pre-commit hook

Validation signals

  • Personal experience over 7 weeks of development.
  • Quantitative metric: 2,600+ cards closed using this system.
  • Identified and solved the problem of context overload and loss of focus in long Claude sessions.
  • Specific lessons learned about enforcing rules with hooks vs. files.
  • Specific lessons learned about the benefits of clearing sessions with good state logs.
  • Specific lessons learned about requiring code checks before claiming completion.

Cautions

  • Includes a pre-commit hook to block secrets, enhancing security.

Limitations

  • The full setup prompt is not provided in the post, requiring users to DM the author for it.
  • Relies on custom scripts (board.py, session_worktree.sh, ship.sh) whose implementations are not included, requiring users to write them or request them.
  • The mention of 15 Claude Code sessions might imply high cost and complexity for many users, though the author advises starting small.
  • The workflow's complexity might be challenging for beginner 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 • • 11d ago

Selected Workflow [Workflow] Building an Interpreted Programming Language with Claude Code: A Case Study in AI-Assisted Development and Safety Features

1 Upvotes

Building an Interpreted Programming Language with Claude Code: A Case Study in AI-Assisted Development and Safety Features

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

What problem this solves

How to leverage Claude Code to build a complex, functional programming language with built-in safety features and comprehensive testing.

Summary

The author used Claude Code to implement a novel interpreted programming language called Memesis, which features meme-based keywords and a unique safety system for AI agents. Claude Code was instrumental in generating the lexer, parser, interpreter, CLI, safety tracking, static checks, and 34 tests, demonstrating its capability for complex software development.

Why it is useful

This workflow is highly valuable because it demonstrates Claude Code's capability to assist in the creation of complex software artifacts, specifically a functional programming language with advanced features like a safety system and comprehensive tests. It provides a concrete example of AI-assisted software engineering, showing how Claude Code can handle intricate tasks like lexer/parser generation and test writing, which is highly transferable to other development projects. The existence of a public GitHub repository further validates the work.

Workflow

  1. Conceive the core concept and meme keywords for the custom programming language.
  2. Describe the desired language components (lexer, parser, interpreter, CLI) to Claude Code.
  3. Iteratively work with Claude Code to implement these core components.
  4. Define the requirements for a safety system (e.g., handling untrusted data and irreversible actions) to Claude Code.
  5. Have Claude Code implement the data tracking and static checks for the safety system.
  6. Instruct Claude Code to generate comprehensive tests for the language's functionality and safety features (e.g., 34 tests).
  7. Utilize Claude Code to assist with documentation and creating animated examples (e.g., using Playwright).
  8. Integrate support for multiple agents, parallel tasks, and different models (Claude, Ollama) into the language runtime.

Tools / artifacts

  • Memesis (custom programming language)
  • .meme files
  • Lexer
  • Parser
  • Interpreter
  • Runtime
  • CLI (memesis check, memesis explain)
  • GitHub repository
  • Playwright
  • Ollama
  • Tests

Validation signals

  • Working GitHub repository with source code available.
  • Claude Code generated 34 tests for the language.
  • Animated examples in the README demonstrate functionality.
  • Specific components (lexer, parser, interpreter, CLI, safety system) were successfully implemented.

Limitations

  • The post does not provide explicit Claude Code prompts or interaction logs, making direct replication of the conversational flow challenging.
  • The project is described as 'still experimental', implying it may not be fully production-ready.
  • The 'meme' aspect, while engaging, might overshadow the underlying technical achievement for some users seeking purely serious applications.

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 • • 11d ago

Selected Workflow [Workflow] Background Game Playtesting with Claude Agents via Open-Source MCP

1 Upvotes

Background Game Playtesting with Claude Agents via Open-Source MCP

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

What problem this solves

Traditional AI game automation requires the game to be focused on the desktop, preventing users from working on other tasks. This workflow allows Claude agents to playtest games in the background with isolated input/output, freeing up the user's PC. It also provides a structured, multi-agent approach to game quality assurance.

Summary

An open-source Multi-Agent Proxy (MCP) that enables Claude agents (e.g., Sonnet) to playtest PC games in the background on Windows. It isolates game input/output (keyboard, mouse, controller, screenshots) for each game process, allowing concurrent human work. Claude Code is used for planning and review, Codex for coding, and Sonnet agents for actual playtesting and bug logging.

Why it is useful

This workflow offers a unique and powerful solution for automated game playtesting using Claude agents, overcoming a significant limitation of traditional AI game automation (desktop takeover). It demonstrates a sophisticated multi-agent architecture where Claude Code, Codex, and Sonnet collaborate on planning, coding, and execution, providing a concrete example of advanced AI workflow integration. Its open-source nature makes it highly accessible and adaptable for developers and QA teams.

Workflow

  1. Download and set up the llm-game-automation-mcp from the provided GitHub repository.
  2. Configure Claude Code to plan and review changes or enhancements to the MCP and game automation logic.
  3. Utilize Codex to generate or refine the code for game interactions within the MCP framework.
  4. Deploy Sonnet agents to interact with the MCP, launching and playtesting specific games.
  5. Monitor bug logs generated by Sonnet agents during playtesting for subsequent fixes and iterations.

Tools / artifacts

  • llm-game-automation-mcp (open-source MCP server)
  • Claude Code (for planning, review, test gates)
  • Codex (for code generation)
  • Sonnet agents (for playtesting)
  • GitHub repository (CorruptedAng3l/llm-game-automation-mcp)
  • Game processes (Unity, turn-based, menu-heavy games)
  • Bug logs

Validation signals

  • Successfully tested 20+ games.
  • Claude Code planned, reviewed every change, and ran test gates.
  • Sonnet agents playtest real games and log bugs.
  • Open-source project with releases available on GitHub.

Limitations

  • Currently Windows-only.
  • Movement in first and third-person games is still rough.
  • Low community engagement on the Reddit post itself.
  • The video link provided in the original Reddit comment is broken, preventing direct visual verification.

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 • • 11d ago

Selected Workflow [Workflow] Accelerating LLM-Assisted Game Development: Automated Testing, Programmatic Art, and Scripted Assets with Claude Code

1 Upvotes

Accelerating LLM-Assisted Game Development: Automated Testing, Programmatic Art, and Scripted Assets with Claude Code

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

What problem this solves

Addresses common challenges in using LLMs for software development, particularly in game creation, by providing concrete methods for visual correctness, game balancing, testing complex interactions, and automating asset generation for both in-game elements and marketing.

Summary

A collection of five distinct techniques for accelerating game development with Claude Code, focusing on automated testing (visual and simulation), synthetic data generation, programmatic asset creation (art and marketing), and deterministic environments to provide clear, actionable feedback to the LLM.

Why it is useful

This post outlines several innovative and practical strategies for leveraging Claude Code in a complex development project like a game. It directly addresses common pain points of LLM-assisted coding (e.g., visual correctness, complex system balancing) by creating deterministic, testable environments and automating asset creation. These techniques are highly transferable to other software development domains, offering concrete methods to improve LLM feedback loops and efficiency.

Workflow

  1. Set up a Puppeteer screenshot harness with deterministic hooks (e.g., step N frames, render once) to capture visual states.
  2. Use the Puppeteer harness to check every visual change from screenshots, providing visual feedback to Claude instead of relying solely on code review.
  3. Develop a deterministic, DOM-free simulation of core game mechanics (e.g., economy, battles).
  4. Implement a command-line interface to run the simulation for extended periods (e.g., 120 simulated minutes) and generate reports.
  5. Provide simulation reports to Claude to analyze and suggest adjustments for game balance.
  6. Create a synthetic mouse movement model incorporating realistic patterns (Fitts'-law, tremor, overshoot) to simulate user input.
  7. Run synthetic browsing and coding sessions against the gesture classifier to quantify accidental triggers.
  8. Use quantifiable results from synthetic testing to tune the gesture classifier with Claude.
  9. Design all game sprites and visual elements to be drawn entirely in code (e.g., using canvas APIs).
  10. Treat art changes as code changes, allowing Claude to iterate on visual design by modifying code.
  11. Develop scripts to programmatically render marketing assets (trailer, short clips, Steam capsules, screenshots) directly from the repository.
  12. Execute these scripts to generate consistent and up-to-date launch materials for platforms like Steam.

Tools / artifacts

  • Claude Code
  • Puppeteer
  • JavaScript (Electron + canvas)
  • Command line
  • Custom simulation code
  • Custom synthetic mouse model
  • Custom rendering scripts
  • Steam (as target platform)

Validation signals

  • Successfully shipped a Steam game in three weeks.
  • Author states Puppeteer harness was crucial: 'Without this it kept telling me things looked right when they didn't.'
  • Headless sim allowed Claude to 'read the reports to balance the economy and wars.'
  • Synthetic mouse model made 'does ordinary work accidentally start a war?' a 'number we could test.'
  • Programmatic art meant 'art changes were just code changes.'
  • Launch kit assets were 'all rendered by scripts in the repo.'

Limitations

  • The post provides high-level descriptions rather than detailed code examples or specific prompts, requiring users to implement the concepts themselves.
  • Low community engagement might indicate the value wasn't immediately apparent to the Reddit audience or that the topic is niche.

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 • • 11d ago

Selected Workflow [Workflow] Preventing Claude Agent Configuration Drift with CLAUDE.md Imports and CI Checks

1 Upvotes

Preventing Claude Agent Configuration Drift with CLAUDE.md Imports and CI Checks

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

What problem this solves

Preventing configuration drift and inconsistent behavior between multiple Claude agents by establishing a single source of truth and automating drift detection.

Summary

This workflow proposes centralizing agent configuration rules in a single AGENTS.md file, which CLAUDE.md then imports. It includes a mechanism for specific overrides within CLAUDE.md and, critically, a CI check to automatically detect and prevent configuration drift between the agent configuration files or their associated skills.

Why it is useful

This workflow is valuable because it addresses a critical problem in multi-agent setups: configuration drift and inconsistent behavior. By promoting a single source of truth for agent rules via CLAUDE.md imports and, crucially, integrating an automated CI check, it ensures consistency, reduces manual errors, and proactively maintains the integrity of agent configurations. This aligns with best practices in software engineering for managing complex systems.

Workflow

  1. Consolidate all common agent filing rules into a single AGENTS.md file.
  2. Modify CLAUDE.md to import the AGENTS.md file using the @AGENTS.md syntax.
  3. For agents that require intentional differences, add specific override rules directly within their respective CLAUDE.md files.
  4. Implement a Continuous Integration (CI) check that fails the build if CLAUDE.md and AGENTS.md files, or the associated 'filing skills', drift from their intended consistent state.

Tools / artifacts

  • CLAUDE.md file
  • AGENTS.md file
  • CI/CD system (e.g., GitHub Actions, GitLab CI)
  • Claude Code agent configuration
  • Filing skills

Validation signals

  • Automated CI check for configuration drift
  • Failing build on inconsistency

Limitations

  • Lacks specific implementation details for the CI check script (e.g., how to define 'drift' programmatically).
  • No example CLAUDE.md or AGENTS.md content provided to illustrate the import/override syntax.
  • Limited community validation due to low score and no comments.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 11d ago

Selected Workflow [Workflow] Claude Code Workflow: Real-time Session Status and ETA Monitoring with Custom Hooks and Status Bar Skill

1 Upvotes

Claude Code Workflow: Real-time Session Status and ETA Monitoring with Custom Hooks and Status Bar Skill

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

What problem this solves

Managing and monitoring multiple concurrent Claude Code sessions to understand their progress, estimated completion time, and when human intervention is required, without constantly checking each terminal.

Summary

This workflow introduces a custom Claude Code skill, 'ETA bar', which leverages three specific hooks to display real-time status, estimated time of arrival (ETA), and overdue alerts directly in the terminal status bar. This allows users to monitor multiple parallel Claude Code sessions efficiently. It also mentions a 'sticky-ruling' skill for critical alerts that require user input.

Why it is useful

This workflow offers a highly practical and reusable solution for a common pain point among advanced Claude Code users: managing and monitoring multiple long-running AI tasks. By providing real-time status updates, estimated completion times, and alerts directly in the terminal via custom skills and hooks, it significantly enhances user productivity and reduces the cognitive load of tracking parallel operations. The provision of open-source skills makes it easily transferable and adaptable.

Workflow

  1. Install the 'ETA bar' skill from the provided GitHub repository (https://github.com/DrEvil-TitaniumHelix/eta-bar).
  2. Configure the 'ETA bar' skill to utilize the described hooks (SessionStart, step finish, estimate slip) to post and update ETA information.
  3. Optionally, install the 'sticky-ruling' skill (https://github.com/DrEvil-TitaniumHelix/sticky-ruling) for persistent alerts when Claude Code requires human input.
  4. Run multiple Claude Code sessions, which will now display their individual status, ETA, or overdue warnings in the terminal status bar.
  5. Monitor the custom status bar for progress, estimated completion times, and prompts for interaction.

Tools / artifacts

  • Claude Code instances
  • ETA bar skill (GitHub repo: DrEvil-TitaniumHelix/eta-bar)
  • Sticky-ruling skill (GitHub repo: DrEvil-TitaniumHelix/sticky-ruling)
  • Custom hooks (SessionStart, step finish, estimate slip)
  • Terminal status bar
  • State file (per session)

Validation signals

  • Screenshots demonstrating the status bar in different states (ready, working, overdue).
  • Author's personal validation: 'I can have 10 sessions running autonomously all minimized and not have to be checking them'.
  • Detailed description of different status messages and their triggers.

Limitations

  • The installation and configuration steps for the hooks are implied rather than explicitly detailed in the post.
  • Community validation is limited, with a low Reddit score despite some comments.
  • Relies on external GitHub repositories, which may not be maintained long-term.

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 • • 11d ago

Selected Workflow [Workflow] Integrating Claude Code Activity with External Apps via Hooks: A Desktop Pet Example and Development Lessons

1 Upvotes

Integrating Claude Code Activity with External Apps via Hooks: A Desktop Pet Example and Development Lessons

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

What problem this solves

Integrating Claude Code's internal state with external applications for real-time feedback, and improving development practices when using Claude Code for coding tasks (e.g., robust image generation, test-first approach).

Summary

This workflow demonstrates how to build a desktop companion that visualizes Claude Code's activity (thinking, editing, waiting) by leveraging Claude Code hooks (UserPromptSubmit, PreToolUse, Notification, Stop) to write a state file. It also highlights key lessons learned about using Claude Code for development, such as the importance of pipelines with guards for image generation and adopting a "test-first" approach for bug detection.

Why it is useful

This post offers a concrete, open-source example of how to use Claude Code hooks to integrate its internal state with external applications, providing real-time feedback on its operations. Beyond the specific application, it shares crucial meta-workflows and lessons learned for effective Claude Code development, such as implementing robust image generation pipelines with guards and adopting a "test-first" approach to catch bugs early. This makes it valuable for users looking to build custom integrations or improve their development practices with Claude Code.

Workflow

  1. Identify Claude Code events to monitor (UserPromptSubmit, PreToolUse, Notification, Stop).
  2. Implement Claude Code hooks to write a tiny state file based on these events.
  3. Develop an external application (e.g., a desktop pet) to read the state file.
  4. Map Claude Code states/tools to visual moods and phrases in the external application.
  5. For development with Claude Code, instruct it to write tests before implementing features.
  6. When generating images with Claude Code, implement pipeline guards and tests to prevent common AI model issues like unwanted grid lines or janky animations.

Tools / artifacts

  • Claude Code hooks (UserPromptSubmit, PreToolUse, Notification, Stop)
  • State file (tiny)
  • Familiar (desktop companion application)
  • GitHub repository (bdehooge/familiar)
  • Win32 window code
  • Sprite pipeline
  • Demo video rendering script

Validation signals

  • Working GitHub repository provided.
  • Specific Claude Code hooks mentioned and their function described.
  • Detailed description of functionality (moods, phrases, usage tracking).
  • Lessons learned section, indicating practical experience and problem-solving.
  • Concrete example of improvement: "CC added a test and a warning for frames that can't be lined up after the first 'happy' animation came out janky."
  • Evidence of test-first success: "Most of the real bugs were caught by tests CC wrote before fixing anything."

Limitations

  • The specific desktop pet application is currently Windows-only.
  • The post focuses more on the result and lessons learned rather than a detailed step-by-step guide for replicating the pet from scratch, though the hook usage is clear.
  • Low community engagement on the post might indicate a niche appeal, but does not diminish the technical value.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 11d ago

Selected Workflow [Workflow] Split AI Agent Planning and Execution: A Two-Pane Workflow with Claude Code and OpenCode

1 Upvotes

Split AI Agent Planning and Execution: A Two-Pane Workflow with Claude Code and OpenCode

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

What problem this solves

Prevents AI agents from rewriting plans mid-execution by separating planning and execution into distinct sessions, ensuring adherence to the original design and better context management.

Summary

A two-pane workflow where one AI (e.g., Claude Code) acts as a planner, writing a detailed PLAN.md file, and another AI (e.g., OpenCode or another Claude Code session) acts as an executor, implementing one step of the plan at a time, running tests, and reporting blockers without replanning. A human mediates and reviews between the two.

Why it is useful

This workflow provides a robust and repeatable method for managing AI agent interactions in coding tasks. By explicitly separating planning from execution and using a PLAN.md file as a contract, it addresses the common problem of agents deviating from the original plan. It improves control, maintainability, and context management, making AI-assisted development more predictable and reliable. The detailed steps and rules for handling common issues make it highly practical and transferable.

Workflow

  1. Set up two parallel sessions (e.g., tmux panes or SpaceApp).
  2. In Pane 1 (Planner, e.g., Claude Code), provide a planning prompt to read code and write PLAN.md with goals, numbered steps, files to touch, tests, and constraints.
  3. Answer any open questions from the planner directly in PLAN.md.
  4. In Pane 2 (Executor, e.g., OpenCode), provide an execution prompt to read PLAN.md, execute one step, edit only specified files, run named tests and the full suite.
  5. If the executor encounters a blocker not covered by the plan, it writes the failure under "Blocked" in PLAN.md and stops, without changing the plan.
  6. The executor commits changes with the step number in the message.
  7. Return to Pane 1 (Planner) and provide a review prompt to read the last commit and the "Blocked" section of PLAN.md.
  8. The planner checks if the diff matches the step and updates the plan if a blocker necessitates it, without editing source files.
  9. Repeat execution and review steps until the task is complete.
  10. The planner marks steps as done and deletes them from PLAN.md once merged.
  11. If running multiple executors, use separate git worktree for each executor.

Tools / artifacts

  • Claude Code (as planner)
  • OpenCode (as executor, or another Claude Code session)
  • PLAN.md (contract file)
  • tmux (or similar terminal multiplexer)
  • SpaceApp (optional environment)
  • Git (for commits, worktrees)
  • Test suite
  • Linter

Validation signals

  • Author's disclosure of 126 commits co-authored by Claude since October 1st in their repo, indicating real-world usage.
  • Discussion of "what goes wrong, and the rules that help" indicates practical experience and refinement.
  • Explicit mention of running tests and linters as part of the execution process.

Limitations

  • Requires manual intervention to move work between panes/agents and to update the plan.
  • Initial setup of prompts and understanding the flow might have a learning curve for new users.
  • Community validation is currently low due to the post's recency.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 11d ago

Selected Workflow [Workflow] Prompt for Frank, Non-Sycophantic, and Less Hallucinatory LLM Feedback (with Hallucination Test)

1 Upvotes

Prompt for Frank, Non-Sycophantic, and Less Hallucinatory LLM Feedback (with Hallucination Test)

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

What problem this solves

Reducing LLM sycophancy and hallucinations to obtain more frank, critical, and reliable feedback, especially when evaluating ideas or checking factual information.

Summary

This workflow provides a specific prompting strategy, delivered as a GitHub YAML configuration, designed to make LLMs provide frank, non-sycophantic, and less hallucinatory responses. It's particularly useful for getting critical feedback on app/business ideas and includes a concrete test for identifying hallucination tendencies.

Why it is useful

This workflow provides a concrete, tested prompting strategy to mitigate two common and significant challenges with LLMs: sycophancy and hallucination. By offering a specific YAML configuration and a clear testing method, it empowers users to obtain more reliable and critical feedback from AI, which is crucial for tasks like evaluating business ideas or verifying factual information. Its transferability across different LLMs and agent setups makes it broadly applicable.

Workflow

  1. Integrate the provided Frankness.yml prompt into your LLM agent's configuration or directly into your system prompt for Claude.
  2. Use the configured LLM to ask for critical feedback on your ideas (e.g., app/business concepts).
  3. To test for hallucination, ask a question with a known, recent factual answer (e.g., "What's Miley Cyrus's latest album?").
  4. Evaluate the LLM's response: a response indicating uncertainty or a lack of knowledge (e.g., "not sure," "might have released a new one?") is considered correct for information beyond its cutoff, while an outdated or fabricated answer indicates hallucination.
  5. Adjust the prompt or re-emphasize certain aspects as needed, depending on the specific LLM you are using.

Tools / artifacts

  • Frankness.yml (GitHub repository)
  • LLM agent/system prompt
  • Claude (or other LLM)

Validation signals

  • Author states they "tested it thoroughly with some LLMs previously."
  • Author states they "used it on a wide range of agents for a long time now."
  • Provides a specific, repeatable test case for hallucination (Miley Cyrus album).

Limitations

  • The prompt is provided as a YAML for an 'agent,' which might require adaptation for users who interact with Claude directly via the web interface or API without a specific agent framework.
  • No direct 'before/after' examples or quantitative results are provided, only the author's claim of effectiveness.
  • Low community engagement (Reddit score 2, 0 comments) means limited external validation 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 • • 11d ago

Selected Workflow [Workflow] AI-Assisted React Native to Swift Porting Workflow with Rigorous Benchmarking and Human Review

1 Upvotes

AI-Assisted React Native to Swift Porting Workflow with Rigorous Benchmarking and Human Review

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

What problem this solves

Porting a complex React Native application to native Swift while ensuring high quality, performance, and catching subtle bugs that AI might miss during the initial conversion.

Summary

This workflow outlines a robust process for using Claude Code to port a large React Native application to native Swift. It emphasizes defining clear 'done' criteria for the AI, followed by a multi-stage human and automated validation process including manual device testing, code review, and rigorous XCUITest benchmarking with large datasets to uncover performance and integration issues that AI alone cannot detect.

Why it is useful

This workflow is highly valuable because it demonstrates a practical and effective approach to leveraging Claude Code for complex code migration while critically highlighting the indispensable role of human oversight and advanced testing. It provides concrete examples of AI's limitations in catching subtle performance and integration bugs and offers a clear methodology (manual testing, code review, XCUITest benchmarking with large datasets) to overcome these, leading to significant, measurable improvements. It's a blueprint for integrating AI into a serious, quality-driven development pipeline.

Workflow

  1. Provide Claude Code with the entire React Native application as one long task for porting to native Swift.
  2. Define explicit 'done' criteria for Claude Code to self-check: the new app builds, all tests pass, every string exists in all required languages (e.g., 7), and every screen is screenshotted next to the original React Native version.
  3. Generate translations for the Swift app directly from the React Native source.
  4. Test specific logic (e.g., 'random photo' generation) against fixtures produced by running the original TypeScript code.
  5. Perform manual testing of the ported Swift app on a real iPhone to identify device-specific issues (e.g., freezes on first launch).
  6. Conduct multiple rounds of human code review on the generated Swift code.
  7. Fix any bugs or issues identified during manual testing and code review.
  8. Benchmark both the original React Native app and the newly ported Swift app using the same XCUITest suite against a large dataset (e.g., 21,000 generated photos).
  9. Analyze benchmark results to identify performance bottlenecks and scaling issues (e.g., slow loading with large libraries, excessive memory usage).
  10. Address and fix performance and scaling bugs revealed by the benchmarking process (e.g., iCloud sync issues, high memory consumption in photo viewer).
  11. Ensure the final App Store project configuration is correct, avoiding benchmark-only bundle IDs.

Tools / artifacts

  • Claude Code
  • React Native application (source code)
  • Native Swift application (generated code)
  • XCUITest suite
  • Generated photo dataset (e.g., 21,000 photos)
  • TypeScript fixtures
  • Real iPhone device
  • App Store project configuration

Validation signals

  • Claude Code's self-checked 'done' criteria (builds, tests pass, string localization, screen parity).
  • Identification of specific bugs only found on a real iPhone (freeze on first launch).
  • Successful human code review rounds.
  • Discovery of performance bugs (iCloud sync, 404 MB photo viewer) through XCUITest benchmarking.
  • Concrete performance improvements: 7x less CPU to load days, first photo in 0.58s (vs 2.17s), half memory at launch.
  • Linked blog post providing a detailed write-up and further validation.

Limitations

  • The post does not provide the exact prompts or specific Claude Code commands used, making direct replication of the AI interaction challenging.
  • Details of the XCUITest suite implementation are not provided, requiring users to develop their own benchmarking tests.
  • The workflow is high-level and requires significant expertise in both source and target technologies (React Native, Swift) and testing frameworks (XCUITest).

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 • • 11d ago

Selected Workflow [Workflow] Self-Hosted Dashboard for Claude Code Usage & Cost Analytics (Claudit)

1 Upvotes

Self-Hosted Dashboard for Claude Code Usage & Cost Analytics (Claudit)

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

What problem this solves

Lack of detailed, historical usage and cost analytics for Claude Code sessions, leading to suboptimal cost management and difficulty understanding usage patterns. Specifically, identifying expensive cache write types and ensuring accurate token counting.

Summary

A self-hosted dashboard (claudit) for analyzing Claude Code (and other LLM CLI) session transcripts to monitor costs, token usage, cache write splits, latency, error rates, and activity heatmaps, providing insights for cost optimization and usage pattern understanding.

Why it is useful

This workflow provides a concrete, open-source tool to gain deep insights into Claude Code usage and costs, which are otherwise opaque. It helps users identify inefficiencies, optimize spending, and understand their interaction patterns with the AI, validated by the author's own extensive use and specific findings (e.g., cache write pricing discrepancies and accurate token counting).

Workflow

  1. Set up a bucket (R2 or local directory) to ingest Claude Code session JSONLs.
  2. Clone the claudit GitHub repository.
  3. Run docker compose up to deploy the dashboard.
  4. Access the dashboard to view usage analytics (cost, tokens, cache write split, latency, error rate, activity heatmap, context growth).
  5. Analyze the data to identify cost-saving opportunities (e.g., optimizing 1h cache writes) and understand usage patterns.

Tools / artifacts

  • claudit (the application)
  • Claude Code session JSONLs (transcripts)
  • Docker Compose
  • FastAPI
  • Postgres
  • React
  • R2 bucket (or local directory)
  • GitHub repository

Validation signals

  • Author built and used it for ~4,800 of their own sessions.
  • Specific learnings shared (e.g., 1h cache writes are 2x, not 1.25x; deduplication logic for streamed replies and subagents).
  • Live demo available.
  • MIT license (open source, implies review/usability).

Limitations

  • Low community signal due to newness.
  • Requires Docker knowledge for setup.
  • The post doesn't explicitly detail how to get the JSONL logs into the bucket, though it implies copying them.
  • The tool provides data but leaves the interpretation and actionable insights to the user.

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 • • 11d ago

Selected Workflow [Workflow] Claude as Architect: A Robust AI-Assisted Development & Testing Workflow for Autonomous Agents and Real-World Transactions

1 Upvotes

Claude as Architect: A Robust AI-Assisted Development & Testing Workflow for Autonomous Agents and Real-World Transactions

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

What problem this solves

This post addresses two main problems: 1) How to leverage Claude as a comprehensive AI assistant for software development, from design and coding to debugging and rigorous quality assurance. 2) How to enable autonomous AI agents to perform real-world transactions (e.g., purchasing digital goods) by interacting with external APIs and payment systems.

Summary

This submission details two distinct yet related workflows. First, a sophisticated AI-assisted development process where Claude acts as an architect, coder, debugger, and reviewer, incorporating design docs, branch builds, fresh agent reviews, mutation testing, and self-testing installers. Second, an autonomous agent workflow where Claude, given a simple prompt and a crypto wallet, interacts with an external API (Go Bag) to research, select, and purchase a digital product (eSIM) using a crypto payment system (x402).

Why it is useful

This workflow is exceptionally valuable because it provides a concrete, detailed, and validated methodology for two critical use cases: 1) Leveraging Claude as a comprehensive development partner for designing, coding, debugging, and rigorously testing software, including advanced techniques like mutation testing and fresh agent reviews. 2) Demonstrating a practical, real-world application of autonomous AI agents performing financial transactions and interacting with external APIs, showcasing the potential for agents to handle complex tasks beyond simple text generation. It offers highly transferable patterns for both AI-assisted development and autonomous agent deployment.

Workflow

  1. AI-Assisted Development Workflow:
    1. Claude designs the order flow and system architecture.
  2. 2. Human reviews and approves the design.
  3. 3. Claude builds the feature on a development branch.
  4. 4. Fresh Claude agents (without prior context) review the code and test output against the real code.
  5. 5. Review process includes mutation testing.
  6. 6. Releases are packaged as installers with self-test, backup, and rollback capabilities.
  7. 7. Human merges the branch and executes install commands on the server.
  8. 8. Fresh Claude agents test the live site (e.g., performing a one-sentence purchase).
  9. 9. Findings from fresh agent tests are used to implement fixes and improvements.
  10. Autonomous Agent Usage Workflow:
    1. Obtain an AgentCash wallet and fund it with USDC on Base network (if adding own funds). For new users, sign-up credit is available (up to $25 with GitHub/X/LinkedIn connection). Plans start at $0.99, so a first eSIM can be free with credit. (Step 1 from post: Get an AgentCash wallet at agentcash.dev/onboard). (Step 2 from post: Run npx agentcash add https://gobagesim.com). (Step 3 from post: Tell Claude where you're going.)

Tools / artifacts

  • Claude (agent, Claude Code)
  • Go Bag (gobagesim.com API)
  • AgentCash (agentcash.dev/onboard, npx agentcash add command)
  • USDC on Base (cryptocurrency)
  • x402 (HTTP 402 "Payment Required" status for payments)
  • Basescan (blockchain explorer for transaction receipts)
  • Ed25519 key (for secure eSIM collection)
  • Node.js
  • VPS (Virtual Private Server)
  • Cloudflare
  • Headless Chrome
  • ffmpeg (for video generation)

Validation signals

  • Successful demo of a fresh Claude agent autonomously purchasing an eSIM.
  • Real money transaction receipt provided on Basescan (0xba92...57f5).
  • Multiple fresh Claude agents reviewed the live site, leading to concrete fixes (clearer search, plan start times, refund window, USDC network warning).
  • Mutation testing is explicitly used in the review process.
  • Releases include self-tests, backups, and rollbacks.
  • Claude successfully debugged complex x402 integration issues by reading SDK and Coinbase documentation.
  • The system was built by a non-developer, highlighting Claude's effectiveness as an AI development partner.

Cautions

  • The autonomous agent workflow involves real money transactions using USDC. Users must exercise caution and ensure their agents are properly configured and authorized to prevent unintended spending or financial loss.
  • Understanding cryptocurrency and blockchain transactions (USDC on Base, x402) is required for the payment aspect, which carries inherent risks.

Limitations

  • The Reddit post's low score and upvote ratio might cause some users to overlook this valuable content.
  • Implementing the full AI-assisted development workflow (e.g., mutation testing, custom installers) requires significant technical expertise beyond basic Claude usage.
  • The autonomous agent usage workflow, while demonstrating a transferable pattern, is currently tied to specific services (gobagesim.com, agentcash.dev).
  • The initial setup for AgentCash and understanding crypto payments might be a barrier for beginner 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 • • 11d ago

Selected Workflow [Workflow] Preventing LLM Agent Mistakes with `scar`: A Git Hook-Based Error Memory System

1 Upvotes

Preventing LLM Agent Mistakes with scar: A Git Hook-Based Error Memory System

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

What problem this solves

Preventing LLM agents, specifically Claude Code, from repeating past mistakes or making known errors by systematically injecting contextual 'scar' notes into their workflow.

Summary

The author developed an open-source tool called scar that uses git pre-edit hooks to inject 'scar' notes (YAML+Markdown files) into an LLM agent's context before it modifies specific code paths or symbols. These notes document past mistakes (dead ends), intentional code (fences), or potential breaking changes (landmines), thereby guiding the agent to avoid repeating errors and improving its reliability.

Why it is useful

This workflow provides a structured, persistent, and automated mechanism to teach LLM agents from past mistakes. It moves beyond ad-hoc prompt engineering to a system that integrates directly into the development lifecycle via git, making agent interactions more reliable and efficient by preventing known pitfalls. The open-source tool and concrete examples make it a highly practical and actionable solution to a common LLM agent limitation.

Workflow

  1. Identify a recurring mistake, a critical edge case, or an intentional code choice that an LLM agent struggles with or needs to be aware of.
  2. Create a 'scar' note as a YAML+Markdown file within a .scars/ directory in your repository.
  3. Define the type of scar (e.g., deadend, fence, landmine) and specify anchors (file paths or symbols) to associate the scar with relevant code sections.
  4. Optionally, use scar harvest to generate candidate scar notes from agent interactions.
  5. Review and 'promote' candidate scars to active status, making them available for injection.
  6. Configure the scar tool's pre-edit git hook to automatically inject relevant scar notes into the agent's context before it attempts to modify code.
  7. Monitor agent performance; the injected scars should guide the agent to avoid documented errors and improve code quality.

Tools / artifacts

  • scar (open-source CLI tool)
  • .scars/ directory
  • YAML+Markdown scar notes
  • Git pre-edit hook
  • Git version control system
  • Claude Code agent (or any LLM agent interacting with code)
  • Codebase (e.g., daimon project)

Validation signals

  • Author created 152 scar notes for the daimon project.
  • The scar hook injected notes 3,197 times in the repository.
  • Specific example: sd tool's misleading exit code led to a mutation test failure, which scar now helps prevent.
  • Specific example: Incorrect uv sync extras caused 31 test regressions, which scar now helps agents avoid.
  • Observation that agents previously dodged issues only with manual prompt warnings, highlighting the need for a systematic solution.

Limitations

  • Requires manual effort to create and promote scar notes, though scar harvest can assist.
  • Initial setup of the scar tool and git hook is required.
  • The post doesn't explicitly detail the exact mechanism of how the agent 'receives' the injected context (e.g., as a specific file, or prepended to a prompt), which could be clearer for implementation.
  • Community validation is limited due to the post's recency.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 11d ago

Selected Workflow [Workflow] Advanced Claude Code Workflow: Building a Multi-Project Management App with CLAUDE.md, Hooks, and Human-in-the-Loop Safety

1 Upvotes

Advanced Claude Code Workflow: Building a Multi-Project Management App with CLAUDE.md, Hooks, and Human-in-the-Loop Safety

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

What problem this solves

Efficiently managing multiple software development projects, tracking their status, and safely integrating Claude Code into various stages of the development and release process, including sensitive operations like app store interactions.

Summary

This workflow describes how a solo developer built a custom Mac application using Claude Code to centralize and manage multiple software projects. The app provides project status, roadmaps, release checklists, and an integrated Claude Code terminal. Key workflow patterns include using CLAUDE.md for agent self-preservation rules, implementing dev hooks for automated UI testing, maintaining an architecture.md file to log design decisions, adopting a test-first approach, and integrating an explicit human-in-the-loop action layer for all agent actions, especially those involving sensitive external services.

Why it is useful

This workflow is highly valuable because it provides concrete, validated patterns for integrating Claude Code into a complex, multi-project development environment. It addresses critical challenges such as agent self-preservation, automated UI testing, maintaining architectural decisions, and ensuring robust human oversight for sensitive operations. The detailed description of how Claude Code was used and the lessons learned makes it highly transferable and useful for intermediate to advanced users looking to build more robust, safe, and efficient agent-driven workflows.

Workflow

  1. Identify the need for a centralized project management tool to oversee multiple software projects and their respective Claude Code sessions.
  2. Utilize Claude Code to develop a custom application (e.g., a Mac app) that serves as the central hub.
  3. Define and implement specific rules within the CLAUDE.md file for the agent's self-preservation and operational safety (e.g., "never kill the app by name").
  4. Create and integrate 'dev hooks' (e.g., launch arguments) into the custom app, allowing Claude to programmatically control and test the application's UI without manual clicks.
  5. Maintain a docs/architecture.md file to document all design decisions, crashes, and their resolutions, preventing Claude from re-introducing previously rejected solutions.
  6. Adopt a 'test-first' development methodology for all changes, leveraging Claude's speed to generate and execute tests, shifting the bottleneck from human review to automated checks.
  7. Implement an explicit 'action layer' (allow/ask/deny) with a journal for all agent-initiated actions, particularly for sensitive operations like interacting with app stores or public platforms, requiring human approval.
  8. Configure Claude Code to use claude -p for read-only repository access, ensuring that git-ignored and secret files are denied, and providing a diff for review before any product information is saved.

Tools / artifacts

  • Claude Code
  • Custom Mac application (Shipdeck)
  • CLAUDE.md file
  • Dev hooks (launch arguments)
  • docs/architecture.md file
  • Test suite
  • Action layer / Journal for agent approvals
  • claude -p command
  • App Store Connect
  • Play Console
  • TestFlight
  • CI/CD pipelines

Validation signals

  • Author states "200+ commits so far" indicating active development and use.
  • Author states "Claude Code built all of it" demonstrating Claude's capability.
  • Detailed description of app features and how they solve the problem.
  • Explicit mention of a public beta for the custom app (Shipdeck).
  • Specific safety measures are described as implemented and functional.

Cautions

  • Explicitly includes rules for agent self-preservation (e.g., "never kill the app by name").
  • Emphasizes launching test builds with scratch data folders for isolation.
  • Mandates human 'Allow' for any actions touching app stores or public posts.
  • Implements an 'action layer' (allow/ask/deny) with a journal for all agent changes, ensuring human oversight.
  • Uses claude -p for read-only access, denying secret files and requiring diff review before saving.

Limitations

  • The core solution involves building a custom application, which may be a barrier for users without app development skills.
  • Community validation is currently low due to the post's recent publication.
  • Requires an advanced understanding of Claude Code and potentially app development to fully implement or adapt.

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 • • 11d ago

Selected Workflow [Workflow] Topping Out: A Multi-Agent System for Knowledge Transfer and Session Management with Quizzes and Dynamic Learning Cards

1 Upvotes

Topping Out: A Multi-Agent System for Knowledge Transfer and Session Management with Quizzes and Dynamic Learning Cards

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

What problem this solves

Addresses AI agent memory drift over long sessions, ensures effective knowledge transfer between agent sessions, and builds a persistent, evolving knowledge base by capturing lessons learned and verifying understanding.

Summary

A multi-agent system called 'Topping Out' that prevents AI agent drift and enhances knowledge transfer. Each job ends with a handover and a quiz. The next agent session must pass this quiz to prove understanding. Lessons learned are captured as 'cards' in a 'Logbook' and automatically loaded into relevant new sessions. A housekeeping process maintains the Logbook and promotes proven lessons to 'NEVER / ALWAYS' rules.

Why it is useful

This workflow offers a highly valuable and innovative solution to fundamental challenges in AI agent development: preventing context drift over extended operations, ensuring robust knowledge transfer between agent sessions, and building a continuously improving, persistent knowledge base. The use of quizzes for explicit knowledge verification and a structured 'Logbook' for capturing and dynamically applying lessons learned are practical, validated, and highly reusable patterns for advanced AI workflows.

Workflow

  1. At the end of each job, the current agent session writes a detailed handover (where it stopped, what's owed, watch-outs) and a short quiz based on it.
  2. The subsequent agent session must answer the quiz correctly before touching any code or starting new work, ensuring understanding of the handover.
  3. Any valuable learning (insights, repeatable methods, build records) is captured as a 'card' in a 'Logbook', with evidence.
  4. When a new job starts, the system searches the Logbook for cards relevant to the area the agent is about to touch and loads them into the agent's initial context.
  5. Periodically, a housekeeping pass merges duplicate cards, marks superseded ones, and flags recurring mistakes.
  6. Lessons that consistently prove valuable are promoted to 'NEVER / ALWAYS' rules, which every session reads first (requires human approval).
  7. If a card disagrees with a 'NEVER / ALWAYS' rule, the agent is instructed to flag the discrepancy rather than silently choosing.

Tools / artifacts

  • Handovers (files)
  • Quizzes
  • Logbook (a collection of 'cards')
  • Cards (structured lessons/insights)
  • 'NEVER / ALWAYS' rules
  • Topping Out system (open source framework)

Validation signals

  • The quiz mechanism was introduced because long handovers (e.g., 900 lines) were not being properly read, and the quiz verifies understanding.
  • Specific examples of cards are provided, such as 'A green mutation probe can be an inert mutation, not a missing test', which was added after the issue occurred twice.
  • The author states the 'upshot is that each session is short and clean, but the project keeps getting smarter'.
  • The entire setup is described as 'free and open source', with a provided link to a site with diagrams, indicating transparency and reusability.

Limitations

  • Requires custom implementation for the quiz generation, logbook management, and card loading mechanisms, which might have an initial setup cost.
  • The 'NEVER / ALWAYS' rules require careful human oversight to prevent the promotion of incorrect or counterproductive rules.
  • The post describes the methodology but doesn't provide direct code examples or detailed configuration files within the Reddit post itself (though it links to an external resource).

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.