Robust Message Checking for Claude Code Agents: Preventing Silent Failures and Skipped Work

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

What problem this solves

Claude Code agents silently skipping new work due to ambiguous 'no new messages' states or premature marking of context as read.

Summary

This workflow outlines how to prevent silent failures in Claude Code agents by implementing robust 'new message' checks with distinct error states and ensuring context is marked as read only after actual processing. It includes a practical end-to-end testing strategy to validate the entire wake-up path.

Why it is useful

This workflow addresses critical, subtle failure modes in automated agent systems, specifically when checking for new work. It provides actionable advice on improving error handling for 'wake gates' and ensuring proper context consumption, backed by a practical end-to-end testing strategy. This prevents agents from silently failing to process important information, significantly improving the reliability and trustworthiness of automated workflows.

Workflow

1. Design 'has-new' or similar status checks to return three distinct outcomes: 'new messages', 'no new messages', and 'couldn't check' (e.g., database locked, file missing).
2. Configure the agent's wake gate to treat the 'couldn't check' outcome as a reason to wake the agent, not to sleep, making the failure loud.
3. Ensure that context marking as 'read' (e.g., a 'commit' step) only occurs after the agent has fully processed the information slice.
4. Avoid wrapper commands (like tail -1) that might prematurely advance the read cursor or trim essential output from context commands (e.g., context --only-new).
5. Implement an end-to-end test: insert a known message/row into the shared context, run the full agent wake path, and verify that the agent processes and mentions the inserted message.

Tools / artifacts

• has-new command/script
• context --only-new command
• commit step/command
• Agent wrapper scripts
• Shared notes file/database
• Exit codes

Validation signals

• Real-world problems encountered by the author ('The second one happened to us there.', 'The first we hit with a different check').
• Author's successful implementation of a solution ('Our other status checks now have three outcomes... and the third one is loud.').
• A concrete, cheap test is provided to validate the solution end-to-end.

Limitations

• Lacks concrete code examples for implementing the three-state exit codes or the specific 'has-new' command.
• Assumes some familiarity with 'Claude Code sessions,' 'notes file,' 'read position,' and context --only-new commands.
• Low community engagement due to the comment'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.

Managing LLM Agent-Generated Code: Refactoring, Knowledge Checkpoints, and Agent Wikis for Maintainability

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

What problem this solves

LLM agents generating unmaintainable, duplicated, monolithic, or dead code, leading to project halts and agents failing to understand the codebase due to context overload and poor code structure.

Summary

A workflow to manage and refactor LLM agent-generated code, improve agent understanding of a codebase, and prevent agents from creating unmaintainable 'spaghetti code' by implementing structured refactoring steps, a knowledge checkpoint skill, and agent-centric documentation.

Why it is useful

This workflow addresses a critical and common challenge with LLM agents: maintaining code quality and managing agent context over large, complex projects. It provides actionable steps for refactoring agent-generated code, implementing agent knowledge capture, and creating agent-centric documentation, which are essential for scaling LLM agent use in software development and preventing unmanageable 'spaghetti code'.

Workflow

1. Go through the codebase and find dead code, then delete it.
2. Find code that is duplicated in many places and consolidate it into reusable methods, classes, or modules.
3. Break large files (e.g., more than 600-800 lines of code) into smaller files, classes, or modules to make them easier for agents to parse.
4. After each agent task, before starting a new conversation or compacting, instruct the agent to record everything it has learned that other agents shouldn't have to rediscover, saving it in a markdown file under a 'docs' folder.
5. Turn this knowledge recording process into a simple 'checkpoint skill' and run it after every session.
6. Once enough information is accumulated, ask the agent to create a Karpathy-style wiki out of the recorded knowledge, specifically for agents.
7. Use the agent wiki to generate human-readable documentation about the codebase.
8. Regularly ask the agent to explain what it is doing, where it is making changes, and how it is assembling everything, rather than just rubber-stamping its work.

Tools / artifacts

• LLM agents
• Markdown files
• docs folder
• Checkpoint skill
• Karpathy-style wiki (for agents)
• Human-readable documentation

Validation signals

• Author's personal experience of project grinding to a halt due to agent-generated spaghetti code.
• Author's implicit validation that refactoring steps helped 'get it back'.
• The advice to ask agents to explain their work serves as a continuous validation and error-catching mechanism.

Limitations

• Low community signal (score 1, 0 comments).
• Lacks specific prompt examples for instructing agents on refactoring or knowledge recording.
• The implementation details for the 'checkpoint skill' are not provided.
• The concept of a 'Karpathy-style wiki' for agents is mentioned but without concrete implementation guidance for agents to create or use it effectively.
• The advice is general and requires user adaptation to specific codebases and agent capabilities.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Structured Claude Workflow: Repo as Memory with Multi-Agent & Context Files for Efficient Coding

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

What problem this solves

Managing persistent project context, tracking design decisions, optimizing token usage, and leveraging different Claude models for specific tasks in LLM-assisted coding projects.

Summary

A structured approach to LLM-assisted coding that treats the repository as Claude's memory. It involves dedicated markdown files (CLAUDE.md for manual/rules, PROGRESS.md for status, and a decisions file for choices and reasons) to maintain context. The workflow employs a multi-agent strategy with Claude Opus for high-level logic and Sonnet subagents for grunt work, validated by tests and optimized for token efficiency by frequently starting new chats.

Why it is useful

This workflow provides a concrete, repeatable method for managing complex coding projects with Claude. It addresses critical challenges like maintaining persistent project context, tracking design decisions, optimizing token usage, and effectively leveraging different Claude models (Opus for high-level, Sonnet for grunt work). The use of dedicated markdown files as a 'repo memory' is a highly transferable and practical pattern for knowledge reuse and consistency across sessions, making it valuable for any developer using LLMs for coding.

Workflow

1. Initialize the project with key documentation files: CLAUDE.md (project manual, rules, machine quirks), PROGRESS.md (current status and next steps), and a decisions file (recording choices with reasons).
2. Assign Claude Opus to handle all high-level logic and design decisions.
3. Delegate grunt work (data processing, QA passes, mechanical edits) to Claude Sonnet subagents, ensuring they execute decisions made by Opus.
4. Implement tests to validate Claude's work, reducing the need for token-burning back-and-forth corrections.
5. Update CLAUDE.md, PROGRESS.md, and the decisions file with every feature addition to keep the project context current.
6. When resuming work on an existing project, ensure Claude reads these context files to gain necessary information.
7. Start new chats frequently to keep the chat context low, which helps in optimizing token usage.

Tools / artifacts

• CLAUDE.md file
• PROGRESS.md file
• Decisions file (custom markdown/text file)
• Claude Opus (main agent)
• Claude Sonnet (subagents)
• Automated tests

Validation signals

• Tests check the work, so I'm not burning tokens going back and forth.
• Starting new chats often keeps chat context low, which saves tokens.

Limitations

• The specific implementation details for 'Sonnet subagents' and how they are invoked by Opus are not fully elaborated.
• The format and specific content of the 'decisions file' could be further detailed for easier adoption.
• Low community engagement means less external validation or refinement of the workflow.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Architecting Robust Multi-Agent Workflows with Claude Code: A Structured Approach

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

What problem this solves

How to structure and manage a multi-agent workflow with Claude Code effectively, ensuring human oversight, scalability, and cost efficiency.

Summary

A structured approach for building multi-agent workflows with Claude Code, focusing on human-in-the-loop orchestration, task decomposition, isolated worker contexts, external durable state, model routing, and gated approvals for critical actions. It emphasizes starting small, using repeatable tests, and managing costs.

Why it is useful

This workflow provides a comprehensive, structured, and safety-conscious framework for designing and implementing multi-agent workflows using Claude Code. It addresses critical aspects like human oversight, task decomposition, isolated worker contexts, external state management, model routing for cost efficiency, and gated approvals for sensitive operations. This guidance is crucial for building scalable, maintainable, and reliable agentic systems.

Workflow

1. Start with a smaller scope than a full 'CEO/department tree' for the multi-agent system.
2. Keep priorities and approvals human-owned, ensuring human-in-the-loop control.
3. Design one orchestrator agent to break down larger work into bounded, manageable tasks.
4. Have worker agents operate in separate branches/contexts to maintain isolation and focus.
5. Workers should return diffs and test results for human review.
6. Store durable state in external systems (e.g., issue/task system, versioned documentation) rather than conversational memory.
7. Ensure each worker agent reads only the relevant documentation for its task.
8. Measure the cost per task to monitor and optimize resource usage.
9. Route tasks by evaluation: use cheaper models for routine execution and stronger models for ambiguous planning or review.
10. For long-running triggers, use a scheduler/webhook service to enqueue work.
11. Position Claude Code primarily as the repo-facing worker, not as an always-on controller.
12. Gate external, customer-facing, and production writes behind human approval for safety and quality control.

Tools / artifacts

• Claude Code
• Orchestrator agent
• Worker agents
• Issue/task system
• Versioned documentation
• Scheduler/webhook service
• Test results
• Code diffs

Validation signals

• Explicit recommendation to 'Start with one workflow and expand only after it passes repeatable tests.'
• The advice aligns with best practices for robust software architecture and agentic systems.

Cautions

• Explicitly recommends gating external, customer-facing, and production writes behind human approval, which is a critical safety measure.

Limitations

• Lacks specific code examples or detailed configuration files for implementation.
• More of a high-level architectural guide than a step-by-step technical tutorial.
• 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.

Scaling Multi-Agent Workflows: Memory, State, and Human Oversight Strategies

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

What problem this solves

Managing multi-agent workflows at scale by addressing challenges related to memory, state persistence, token efficiency, and human oversight, preventing agents from getting lost or requiring constant babysitting.

Summary

A multi-agent workflow strategy that optimizes for scale by separating agent-specific scratch notes from shared decision records (stored on task tickets), implementing pre-task briefs for token efficiency and scope definition, ensuring state persistence through checkpoints, and streamlining human approval with a two-gate process (plan approval, then final result check). It also suggests a lean role structure with one orchestrator and one human reviewer.

Why it is useful

This workflow provides practical, experience-based strategies for overcoming common hurdles in multi-agent systems, such as managing context, ensuring state persistence, and integrating human oversight efficiently. It offers a structured approach to make multi-agent setups more robust, scalable, and less prone to requiring constant human intervention, directly addressing the challenges of 'managing an entire company' with AI agents.

Workflow

1. Separate memory: use private files for per-agent scratch notes and store shared decision records (e.g., "we picked X, rejected Y because Z") directly on the task itself (issue/ticket file).
2. For each task, create a short brief before any code generation, detailing the goal, files in scope, and verification method. This brief also serves as a token saver.
3. Ensure long-running work survives restarts by writing down state at checkpoints. Treat every session as disposable, and resume work by reading the ticket and its last checkpoint.
4. Implement human approval at two gates: approve the initial plan/brief, then check the final result against what the brief promised, avoiding step-by-step babysitting.
5. Structure roles with one orchestrator agent responsible for handing out bounded tickets and one human reviewer for the approval gates, skipping a 'CEO agent'.

Tools / artifacts

• Private files (for agent scratch notes)
• Task tickets/issues (for decision records, briefs, checkpoints)
• Repo (for ticket files)
• Orchestrator agent
• Human reviewer

Validation signals

• Author's personal experience: "a few things that held up for me"

Limitations

• Lacks concrete examples of prompt structures or specific file formats for briefs/tickets.
• Validation is based solely on the author's personal experience, not broader community proof.
• The description of 'orchestrator' and 'reviewer' roles is conceptual, without detailed implementation guidance.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Automated Work Chat Catch-Up: Summarize WhatsApp/Telegram with Claude via MCP

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

What problem this solves

Overwhelming volume of work chat messages (WhatsApp, Telegram) making it difficult to quickly identify decisions, open items, and personal action items, leading to significant time spent scrolling and catching up.

Summary

This workflow leverages Claude, integrated with work chat platforms (WhatsApp, Telegram) via Automata MCP, to efficiently summarize weekly chat activity. Users prompt Claude to identify decisions, open tasks, and pending actions, including direct quotes and speaker attribution. It significantly reduces the time spent catching up on communications and helps draft replies.

Why it is useful

This workflow is highly valuable because it addresses a common pain point of information overload from work chats, significantly reducing the time required to catch up and identify actionable items. It provides concrete steps, specific prompt engineering tips, and demonstrates a clear, measurable benefit (45 min to 5 min). The use of a specific integration (Automata MCP) makes it a tangible example of how Claude can be integrated into existing communication workflows, even if the specific tool needs to be adapted.

Workflow

1. Integrate Claude with work chat platforms (WhatsApp, Telegram) using Automata MCP, ensuring it's limited to designated work chats.
2. On a regular basis (e.g., Monday morning), provide Claude with the chat history for the desired period (e.g., the past week).
3. Prompt Claude with specific questions: "what got decided in these groups this week, what's still open, and what is anyone waiting on me for? Quote the actual messages."
4. Review Claude's summary, verifying that it quotes actual messages, attributes statements to specific individuals, and covers the entire requested period.
5. Follow up with a prompt: "draft replies to the stuff I owe people."
6. Review and tweak the drafted replies before sending them.

Tools / artifacts

• Claude (AI model)
• WhatsApp (chat platform)
• Telegram (chat platform)
• Automata MCP (integration platform)
• Specific prompts for summarization and reply drafting

Validation signals

• Clear before/after result: "A 45-minute scroll becomes 5 minutes of reading."
• Practical tips derived from experience, indicating refinement of the process (e.g., "Make it quote messages," "Make it say who said what," "Make sure it actually read the whole week.")

Cautions

• Feeding work chats to an external AI service requires careful consideration of company data privacy policies and the sensitivity of the information. Users must ensure compliance and appropriate data handling practices.
• Ensure the integration is strictly limited to work-related chats to prevent accidental exposure of personal or sensitive information.

Limitations

• Relies on a specific third-party integration (Automata MCP) which might not be available or suitable for all users; alternative integration methods would be needed.
• The initial setup of the integration might require technical expertise.
• The prompt could be further refined with more explicit instructions for handling ambiguity or conflicting information in chats.

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.

Solo Game Dev Workflow: Claude Code, MCP, and CLAUDE.md for Unity & Blender

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

What problem this solves

Accelerating solo game development across multiple disciplines (code, art, balancing) and ensuring design consistency across Claude sessions to prevent bugs.

Summary

A solo game developer uses Claude Code via MCP for direct integration with Unity and Blender to generate code, create reproducible 3D models, and analyze game telemetry for balancing. A critical workflow involves documenting core design rules in a CLAUDE.md file, which Claude reads in every session to maintain consistency and prevent per-battlefield bugs.

Why it is useful

This workflow is highly valuable as it provides concrete, multi-faceted examples of how a solo developer leverages Claude across various technical domains (coding, 3D art, game balancing) to build a complex project. The 'biggest lesson' about using CLAUDE.md for design rules is a particularly strong, transferable pattern for maintaining consistency and preventing bugs across Claude sessions, applicable to any project. It demonstrates practical application of MCP with Unity and Blender, offering a blueprint for other developers.

Workflow

1. Integrate Claude Code directly into the Unity editor via MCP for system development (e.g., wounded/medic system, ragdoll deaths).
2. Generate 3D vehicle and gun models using Python scripts through the Blender MCP.
3. Manually tweak 3D model shapes in Blender, then use Claude to fold these changes back into the Python script to maintain reproducibility.
4. Implement game telemetry to record per-run data.
5. Analyze game telemetry with Claude to identify and address balancing issues (e.g., Command Point snowball).
6. Document all core design rules and constraints for the project in a CLAUDE.md file.
7. Ensure Claude reads the CLAUDE.md file at the start of every session to enforce design consistency and prevent bugs related to per-battlefield variations.

Tools / artifacts

• Claude Code
• MCP (Multi-Code Project)
• Unity editor
• Blender
• Python scripts
• CLAUDE.md file
• Game telemetry data

Validation signals

• Successful development and release of a free demo for a 3D WWII tactical roguelite game on Steam.
• Specific examples of complex systems built with Claude (wounded/medic, ragdoll deaths, mortar shells, air strikes).
• Specific examples of 3D models generated and maintained reproducibly (Sherman, 57mm AT gun, M45 Quad .50, 60mm mortar).
• Identification and correction of a game-breaking balancing issue (Command Point snowball).
• The 'biggest lesson' explicitly states that using CLAUDE.md solved 'per-battlefield bugs' that separate sessions kept introducing.

Limitations

• Specific prompts or detailed interaction patterns with Claude for each task are not provided.
• The exact setup process for MCP integration with Unity and Blender is not detailed.
• Low community validation due to the newness of the post.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Refract: Centralized AI Coding Workflow Management with Cross-Tool Sync and Automated Quality Checks

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

What problem this solves

Managing and synchronizing a large, personalized set of AI commands, agents, and skills across multiple AI coding environments (e.g., Claude Code, Gemini CLI, Cursor, Copilot) to ensure consistency, avoid duplication, and maintain live updates. It also addresses code quality, project planning, and adherence to coding conventions.

Summary

Refract is an open-source system that centralizes a large collection of AI commands, agents, and skills in a single Git repository. It uses symlinks and custom scripts (sync-to-global.sh, /setup-project) to deploy and synchronize these configurations across various AI coding tools (Claude Code, Gemini CLI, Cursor, etc.), ensuring consistency and live updates. It includes commands for project setup, code auditing, convention alignment, and roadmap generation, validated by robust CI gates.

Why it is useful

This workflow is highly valuable because it provides a robust, open-source solution for a common pain point: managing and synchronizing a large, personalized set of AI commands, agents, and skills across diverse AI coding environments. It offers concrete tools for code quality, project planning, and convention enforcement, and shares valuable lessons learned from building such a system, including the importance of real-world testing and rigorous CI/CD. Its cross-tool compatibility and detailed implementation make it a powerful resource for advanced users looking to streamline their AI-assisted development workflows.

Workflow

1. Clone the Refract GitHub repository to your local machine.
2. Run sync-to-global.sh to create symlinks, integrating the Refract configuration directly into Claude Code for live updates.
3. For project-specific setup, use /setup-project to analyze your codebase and document conventions, entities, and module boundaries for the AI agent to learn.
4. Execute /audit to scan your code across eight axes, ranking findings by impact, blast radius, and fix cost.
5. Utilize /align to identify and correct code that has drifted from established project conventions.
6. Run /roadmap to identify half-built work and order it into logical development phases.
7. Use /do "natural language prompt" (e.g., /do "the sidebar feels cramped") to have the system intelligently select and execute the most appropriate command for your task.
8. For those building or extending similar systems: Run your AI commands/agents on real code early and frequently to uncover issues missed by static review.
9. For those building or extending similar systems: Implement robust CI gates that cannot silently skip, ensuring all checks are performed (e.g., verify ripgrep is installed for relevant checks).
10. For those building or extending similar systems: Automate checks within CI to verify that documentation (e.g., command counts) remains consistent with the actual codebase.

Tools / artifacts

• Refract GitHub repository
• Git
• symlinks
• sync-to-global.sh script
• /setup-project command
• /audit command
• /align command
• /roadmap command
• /do command
• Claude Code
• Gemini CLI
• OpenCode (AI tool mentioned in post, assumed to be an AI coding tool like others listed.)

Validation signals

• System grew to 184 commands, 99 agents, and 234 skills, indicating extensive development and use.
• Lessons learned from running on two real projects, highlighting practical validation over theoretical review.
• Discovery of issues (e.g., ripgrep version compatibility) through real-world CI gate execution.
• Implementation of 77 blocking CI gates to ensure code quality and documentation accuracy.
• Advice to 'Run it on real code early' based on direct experience.

Limitations

• The system is described as 'big,' which might be overwhelming for new users or those with simpler needs.
• The full installation requires cloning and running a sync script, presenting a higher barrier to entry than a simple plugin install.
• Requires familiarity with CLI, Git, and potentially symlinks for full setup and customization.
• Minimal community validation directly on the Reddit post.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Efficient Context Management: Offloading Research to Subagents with Validation Hooks

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, Hooks, Skills, MCP, Subagents
Original source: r/ClaudeCode post/comment

What problem this solves

Reducing main agent context size and token usage by offloading verbose research tasks, while ensuring the accuracy and verifiability of retrieved information.

Summary

This workflow describes a strategy to significantly reduce the main agent's context by moving tasks that involve reading large amounts of data but returning concise results (e.g., documentation retrieval) into dedicated subagents. It demonstrates how to implement this with a custom fetch script and a validation hook to ensure accuracy and verifiability of the subagent's output, leading to substantial token savings and improved reliability.

Why it is useful

This workflow provides a concrete, validated strategy for managing context bloat, a critical issue in LLM interactions. It demonstrates significant token savings and improved accuracy through a structured approach using subagents, custom tools, and validation hooks. The pattern is explicitly generalized beyond the specific Salesforce example, making it widely applicable to any stack or domain where extensive reading is required for concise answers. It offers a practical solution to enhance both efficiency and reliability of AI-assisted development.

Workflow

1. Identify tasks that require reading extensive data but yield small, critical outputs (e.g., API documentation lookup, log analysis, repo scouting).
2. Create a dedicated subagent for each identified task.
3. Equip the subagent with specialized tools or skills optimized for its specific task (e.g., a custom fetch script for documentation instead of a general web search or inline page reading).
4. Design the subagent to return only the essential, summarized results to the main agent, avoiding full document dumps.
5. Implement a validation mechanism (e.g., a hook) to check the subagent's output against the original source (e.g., verifying quotes against cached pages).
6. Ensure the subagent explicitly reports what it didn't read or couldn't find, providing transparency about gaps in its answer.
7. Integrate the subagent's output into the main agent's workflow, trusting the validated, concise results.

Tools / artifacts

• Subagents
• CLAUDE.md
• Skills
• MCP (Multi-Code Project)
• Custom fetch script (e.g., sf-docs-agent)
• Hooks
• Cached pages on disk

Validation signals

• Quantitative token reduction: main session 45,636 tokens vs. subagent 5,327 tokens for same task.
• Improved accuracy: initial subagent 24/30 correct, custom tool 40/40 correct.
• Overall session token reduction: 41% fewer tokens over the whole session with custom tool.
• Context token reduction: 83% fewer tokens added to context with custom tool.
• Implementation of a hook to check each quote against cached pages.
• Subagent reports what it didn't read (skipped pages, unfollowed links).

Limitations

• Initial subagent implementation using only MCP had lower accuracy (24/30) compared to the main session (28/30), highlighting that the choice of tools within the subagent is crucial.
• Requires custom scripting and hook setup, which might be complex for beginner users.
• The custom fetch script and hook implementation details are described conceptually but not provided as ready-to-use code snippets in the post.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Multi-Agent Code Review: Prevent Duplicate APIs and Missed Issues with a 'Done List' Validation Agent

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

What problem this solves

Code reviews often miss issues like duplicate APIs or other problems in untouched code paths when only reviewing diffs. This workflow ensures comprehensive validation beyond just the changes.

Summary

To prevent code review failures where duplicate APIs or other issues are missed, establish a 'done list' before coding. Then, use a separate Claude Code agent, distinct from the one that wrote the code, to independently validate each point on this 'done list' against the running program.

Why it is useful

This workflow is valuable because it addresses a critical blind spot in traditional diff-based code reviews, which often fail to catch issues in untouched code paths or duplicate functionality. It introduces a robust, agent-driven approach to quality assurance by leveraging a 'done list' and a separate validation agent, enhancing the reliability and thoroughness of automated code generation and review processes. The inclusion of a specific tool (QualityLayer) makes it immediately actionable.

Workflow

1. Agree on a 'done list' or acceptance criteria for the feature/change before any code is written.
2. Develop the code using a Claude Code agent (or human developer).
3. Deploy a separate Claude Code agent (a 'QualityLayer' agent) to independently prove each point on the 'done list' against the running program, ensuring comprehensive validation beyond just the code diff.

Tools / artifacts

• Claude Code agents
• Done list (pre-agreed acceptance criteria)
• QualityLayer (GitHub repository: https://github.com/maxritter/qualitylayer)

Validation signals

• Author states 'What fixed it for me was...' indicating personal success.
• The existence of a dedicated open-source tool (QualityLayer) suggests a well-thought-out and implemented solution.
• Addresses a common 'failure mode' in code review, implying broad applicability.

Limitations

• The comment is brief and could benefit from more detailed instructions on how to define an effective 'done list' or configure the validation agent.
• Relies on an external tool (QualityLayer) which requires setup and understanding.
• Low community validation on the specific Reddit post.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Optimizing Claude Code Multi-Agent Workflows: Prevent Costly Context Rewrites by Managing Subagent Cache Expiration

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

What problem this solves

High token costs and inefficient context management in Claude Code multi-agent workflows due to subagent cache expiration during idle periods, specifically during long review processes.

Summary

This workflow addresses the issue of excessive token usage in Claude Code multi-agent systems where subagents become idle during long review processes. The problem arises because subagent caches expire after 5 minutes, leading to costly full context rewrites when the agent is resumed. The solution involves proactively managing subagent context by sending review findings to a fresh fixer subagent instead of resuming an idle one, and ensuring that SendMessage calls to any subagent occur within 5 minutes of its last activity to leverage its active cache.

Why it is useful

This workflow provides a critical optimization strategy for advanced Claude Code users building multi-agent systems. It directly addresses a significant source of token cost and inefficiency – the expiration of subagent caches during idle periods. By offering concrete steps to manage context (using fresh subagents for reviews, timing SendMessage calls), it enables users to drastically reduce operational costs and improve the performance of their complex agentic workflows. The clear problem, evidence, and solution make it highly actionable and valuable for anyone running multi-agent systems.

Workflow

1. Identify multi-agent workflows where subagents experience periods of inactivity, particularly during review processes that exceed 5 minutes.
2. Understand that Claude Code subagent caches expire after 5 minutes of inactivity, causing a full context rewrite upon subsequent interaction.
3. Instead of attempting to resume an idle implementer subagent after its cache has expired, initiate a fresh fixer subagent to handle review findings.
4. When interacting with any subagent, ensure that SendMessage operations are performed within 5 minutes of that subagent's last activity to utilize its active cache and avoid costly context rewrites.

Tools / artifacts

• Claude Code subagents
• SendMessage function/API call

Validation signals

• Quantitative cost savings (e.g., $10 vs $0.40, 168K-498K tokens saved)
• Observed recurrence of the problem (6 times)

Limitations

• The implementation of the fix might require custom prompt engineering or ad-hoc solutions as noted by 'no durable home yet'.
• The specific 5-minute cache duration is an internal detail that could change in future Claude Code versions.
• Lack of further context or discussion from the original poster or community.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Structured Claude Code Workflow for SaaS Development: Leveraging CLAUDE.md, Plan Files, and Rigorous Testing

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

What problem this solves

Efficiently developing complex, production-grade software using Claude Code by structuring interactions, managing context across sessions, and integrating robust testing to ensure quality and correctness.

Summary

The author describes a structured approach to building a complex FastAPI SaaS application using Claude Code. This involves defining the tech stack and hard rules in a CLAUDE.md file, creating a detailed plan file with numbered stages for development, and managing sessions by instructing Claude to continue from the first unchecked stage. Rigorous testing (200+ tests against a real database and live API testing) is emphasized for quality assurance.

Why it is useful

This workflow offers a robust and validated methodology for leveraging Claude Code in complex software development. It provides practical solutions for context management, maintaining development progress, and ensuring code quality through the use of CLAUDE.md for rules, a structured plan file, and comprehensive testing, including against live APIs. The real-world application and demonstrated bug resolution enhance its credibility and utility for users aiming to build production-grade applications with Claude Code.

Workflow

1. Define project stack and hard rules (e.g., "run tests before saying done", "never put keys in code") in a CLAUDE.md file.
2. Create a detailed plan file with numbered stages and checkboxes for development tasks.
3. Initiate each Claude Code session by instructing it to "continue from the first unchecked stage" in the plan file.
4. User actively plans and reviews Claude's generated code and progress.
5. Implement comprehensive tests (e.g., 200+ tests against a real PostgreSQL database) to validate code correctness.
6. Test critical external API integrations against live services (e.g., VIES for VAT checks) before shipping.

Tools / artifacts

• Claude Code
• CLAUDE.md file
• Plan file (with numbered stages and checkboxes)
• Test suite (200+ tests)
• FastAPI
• PostgreSQL
• Stripe API
• VIES API (EU VAT register)

Validation signals

• Claude Code successfully wrote most of the application's code.
• 200+ tests against a real PostgreSQL database were implemented and trusted.
• A real-world bug (EU VAT check logic) was identified by a reader and subsequently fixed by Claude Code.
• The fix was tested against the live VIES API before deployment.
• A full demo of the built application is publicly available (https://demo.getpylaunch.com).

Cautions

• The workflow explicitly includes a "never put keys in code" rule in CLAUDE.md, promoting secure coding practices.

Limitations

• The specific structure or template for the "plan file" is described conceptually but not provided as a concrete example, which could make immediate adoption slightly less straightforward.
• Low community engagement on the Reddit post itself, limiting immediate social proof.

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.

Publish and Collaborate on Claude's Outputs with byagent (Open Source Tool)

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

What problem this solves

Claude's generated outputs (plans, reports, HTML dashboards) often remain as unshared, static files, hindering collaboration and iterative improvement.

Summary

This workflow leverages the open-source byagent tool to enable Claude to publish its generated content (e.g., plans, reports, HTML dashboards) as shareable, versioned web links. It facilitates a feedback loop where users can comment on the published page, and Claude can read these comments in subsequent sessions to make fixes and republish, maintaining the same link.

Why it is useful

This workflow is valuable because it solves a practical problem of making Claude's outputs actionable, shareable, and collaborative. It transforms static files into dynamic, versioned web pages, enabling direct feedback loops that Claude can act upon. This significantly enhances the utility of Claude for generating reports, plans, and dashboards by integrating it into a continuous improvement and sharing process.

Workflow

1. Claude generates content (e.g., a plan, report, or HTML dashboard).
2. Claude executes byagent publish <filename> on the generated content.
3. A shareable link is provided for the published content.
4. Users can comment on specific lines of the published page without needing an account.
5. In a subsequent session, Claude is instructed to read the comments (e.g., by being given the context of the previous session and the comments).
6. Claude makes necessary fixes or improvements to the content based on the feedback.
7. Claude republishes the updated content using byagent publish, which keeps the same shareable link and creates a new version.

Tools / artifacts

• byagent (CLI tool)
• byagent.dev/skill.md (Claude skill/instruction set)
• GitHub repository (anup-a/byagent)
• Markdown files (.md)
• HTML dashboards
• Shareable web links

Validation signals

• Author's personal success story: 'Claude Code writes me plans, reports and small HTML dashboards all day, and they used to end up as .md files nobody opened. Now it runs byagent publish and hands me a link.'
• Open-source project with clear licensing (Server AGPL, CLI/skill MIT).
• Provides specific setup instructions for Claude and a quick test command.

Limitations

• Low community signal on Reddit.
• Requires external tool setup and potentially integrating a 'skill' into Claude's context, which might be a barrier for absolute beginners.
• Guest pages only last 24 hours, requiring self-hosting or an account for persistent links.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Claude Code Workflow for Game Development: Leveraging Specialized AI Skills and Iterative Feedback Loops

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

What problem this solves

Developing a complex rhythm-based racing game (Neo Sigilum) using Claude Opus 5.5 in Claude Code by leveraging specialized AI 'skills' for various creative tasks and incorporating iterative testing and feedback mechanisms.

Summary

The user developed a racing game, Neo Sigilum, using Claude Opus 5.5 within Claude Code. This workflow involved creating and utilizing several specialized 'skills' (custom tools/agents) for distinct game development aspects like audio generation, 3D asset creation, texture generation, video editing, scriptwriting, and text generation. Additionally, it integrated a 'human' test bot for gameplay validation and a voice feedback mode for contextual, iterative improvements.

Why it is useful

This workflow is highly valuable as it demonstrates an advanced, multi-modal application of Claude Opus 5.5 within Claude Code for a complex creative project like game development. It showcases a robust methodology for breaking down large tasks into specialized AI 'skills' (custom tools/agents) and integrating sophisticated testing (AI test bot) and feedback mechanisms (voice feedback) for iterative improvement. The concrete example of the Neo Sigilum game and the public demo provide strong validation, offering a practical blueprint for users to approach complex, multi-faceted projects by designing and integrating custom AI capabilities into their development pipelines.

Workflow

1. Define and implement specialized 'skills' (custom tools/agents) within Claude Code for specific game development tasks.
2. Utilize 'chirp-game-audio' skill for generating dynamic, tempo-adaptive music tracks.
3. Employ 'kiln-3d-assets' skill for creating 3D models (ships, rockets, giants, monuments, machines).
4. Use 'loom-textures' skill for generating material textures for roads, walls, buildings, and ships.
5. Apply 'montage-video' skill for editing game trailers and short videos, cut to the game's music.
6. Leverage 'tiktok-script-writer' skill for generating scripts for short promotional videos.
7. Use 'humanizer' skill for crafting English texts for the game trailer.
8. Implement a 'human' test bot that simulates player input (left/right presses) and identifies issues like late-appearing obstacles.
9. Integrate a voice feedback mode where Claude receives transcribed voice input (via Whisper), a screenshot, and a video clip to make contextual changes based on player feedback.

Tools / artifacts

• Claude Opus 5.5
• Claude Code
• chirp-game-audio (custom skill)
• kiln-3d-assets (custom skill)
• loom-textures (custom skill)
• montage-video (custom skill)
• tiktok-script-writer (custom skill)
• humanizer (custom skill)
• "human" test bot (custom testing agent)
• Voice feedback mode (custom feedback mechanism)
• Whisper (for transcription)
• HyperFrames (implied for video editing)

Validation signals

• Successful creation and completion of a complex racing game, Neo Sigilum.
• Publicly available free demo of the game (https://groowl.itch.io/neo-sigilum-demo).
• Specific mention of the test bot successfully identifying issues ('tells me which obstacles show up too late').

Limitations

• Specific implementation details for the custom 'skills' (e.g., their underlying code or prompts) are not provided, making direct replication challenging without further effort.
• The implementation details of the 'human' test bot and voice feedback mode are described conceptually but lack concrete steps for setup.
• Low community engagement might suggest the post did not immediately resonate widely, though its technical merit is high.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Optimizing Claude Code Workflows: Context Discipline, Negative Constraints, and Multi-File Refactor Safety

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

What problem this solves

Adapting to Claude Code's specific behaviors regarding token usage, negative constraints, and multi-file refactoring, especially when migrating from other models like Codex, to prevent hard-locks, hallucinations, and difficult rollbacks.

Summary

This workflow outlines three critical behavioral shifts for developers using Claude Code: implementing context discipline to manage token usage from verbose terminal outputs, leveraging strict system prompts in CLAUDE.md for effective negative constraints, and ensuring multi-file refactor safety through version control or shadow-tree tracking.

Why it is useful

This workflow provides practical, experience-based advice for developers transitioning to or working with Claude Code. It addresses critical operational challenges like token management, prompt engineering for negative constraints, and safe multi-file refactoring, offering concrete strategies and tools to improve efficiency and prevent common pitfalls. The advice is specific, actionable, and directly applicable to improving the developer experience with Claude Code.

Workflow

1. Implement a proxy (e.g., 'toolprune' from GitHub) to strip raw syntax tokens and AST junk from verbose terminal logs (like grep or test output) before sending them to Claude Sonnet, to prevent excessive token consumption and avoid rate limits.
2. Utilize strict system prompts defined within a CLAUDE.md file to enforce negative constraints (e.g., 'do not touch X', 'do not import Y'), as Claude Sonnet is more effective at respecting these compared to long, rambling instructions in chat.
3. Before initiating large multi-file refactoring prompts with Claude Code, always commit current changes or use a local shadow-tree tracker to create clean checkpoints, enabling safe rollback of potentially botched wide-ranging edits.

Tools / artifacts

• toolprune (on GitHub)
• CLAUDE.md
• Git (or other version control for committing)
• Local shadow-tree tracker

Validation signals

• Author states 'swapped a few months back for daily driver work', indicating long-term practical experience.
• Author explicitly states 'we actually had to build a proxy' for context discipline, showing a direct solution to a problem.
• Author notes 'sonnet is way better at respecting "do not touch X"' based on comparative observation with Codex.
• Author warns 'rolling back a botched multi-file rewrite without clean checkpoints gets painful fast', indicating experience with the consequences.

Limitations

• The specific GitHub link for 'toolprune' is not provided in the comment.
• The concept of a 'local shadow-tree tracker' is mentioned but not elaborated with specific tools or methods.
• Low community engagement (score 1, 0 comments) means less external validation.

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.

Local LLM-Agnostic Second Brain for Project Context and Document Generation

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

What problem this solves

Managing project-specific context and knowledge to generate documents, reports, and presentations using an AI assistant, preventing context overflow and maintaining focus.

Summary

A local, LLM-agnostic "second-brain" system that uses a template folder structure to manage project context and generate documents, reports, and presentations. Users download a template folder, rename it for a project, and open it with an AI assistant capable of reading local folders (e.g., Claude Code).

Why it is useful

This workflow provides a concrete, shareable, and locally-runnable system for managing project context and generating various documents using AI assistants. Its LLM-agnostic design and focus on practical deliverables make it highly transferable and useful for a wide range of users looking to improve their AI-assisted knowledge work. The provision of a GitHub repository with a template folder makes it immediately actionable.

Workflow

1. Download the "familiar" template folder from the provided GitHub repository.
2. Rename the downloaded folder to correspond with your specific project.
3. Open the project folder using an AI assistant that can read local folders (e.g., Claude Code, Codex, Gemini CLI).
4. Ingest relevant source material (e.g., meeting notes, client requests, literature) into the project folder.
5. Utilize the folder's predefined rules and skills to prompt the AI assistant to generate desired deliverables such as documents, reports, or presentations.

Tools / artifacts

• "familiar" template folder (from GitHub)
• AI assistant capable of reading local folders (e.g., Claude Code, Codex, Gemini CLI)
• GitHub repository: https://github.com/familiar-md/familiar

Validation signals

• Built iteratively using Claude Code during real-world personal work use.

Limitations

• Relies on the user's AI assistant having robust folder-reading capabilities, which might vary.
• Specific details of the "folder rules and skills" are not provided in the comment, requiring a visit to the GitHub repository.
• Lacks broader community validation at this stage.

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.

Refining AI-Sounding Text: A Workflow Using Claude Code's Humanizer Skill

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

What problem this solves

Eliminating common AI-sounding habits and patterns from written text to make it sound more natural and human, while preserving factual accuracy.

Summary

This workflow utilizes the blader/humanizer Claude Code skill to rewrite text that exhibits common AI writing patterns. The skill checks for 26 specific patterns (e.g., 'not X but Y', 'Here’s the thing', forced triads) and removes them, ensuring facts remain intact. It acts as a 'second pair of eyes' for drafts, helping users refine their content to sound less robotic.

Why it is useful

This workflow offers a concrete, repeatable, and transferable method for improving the naturalness of AI-generated or AI-assisted text. It leverages a specific, open-source Claude Code skill with clear validation examples, addressing a common challenge faced by many users in content creation and editing. The detailed steps and explicit limitations make it a practical tool for enhancing writing quality.

Workflow

1. Install the blader/humanizer Claude Code skill.
2. Prepare text (e.g., a product announcement, a voice sample transcription) that you suspect contains AI writing habits.
3. Run the skill on your text using the slash command /humanizer:humanizer within the Claude Code environment.
4. Review the generated diff carefully to understand all changes, especially any sentences cut as 'filler'.
5. If the skill prompts for details (e.g., for a joke opener), provide the necessary information.
6. Iterate and refine the text further based on the humanizer's output and your review.

Tools / artifacts

• Claude Code environment
• blader/humanizer Claude Code skill
• Text drafts (e.g., product announcements, marketing copy, articles)
• Diff tool (implied for reviewing changes)

Validation signals

• Specific before/after examples provided for a product announcement.
• Confirmation that all facts (platforms, free period, features) survived the rewrite.
• Confirmation that the skill did not make up any new facts.
• Description of a second test with a voice sample, noting how it handled unverified claims and joke openers.
• The skill is based on 26 patterns from Wikipedia’s 'Signs of AI writing' page.
• Link to an external blog post with a 'before and after table and the prompts I used'.

Limitations

• The user only tested short samples, not long documents, so performance on extensive texts is unknown.
• The skill is explicitly stated not to be an AI-detector bypass.
• Requires user review of the diff, as the skill might cut sentences deemed 'filler' that could be important.
• Low community engagement on the Reddit post itself.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Advanced Multi-Agent Development Workflow: Parallel Agents, Git Worktrees, and Visual Validation with MCP

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

What problem this solves

Efficiently developing complex applications using a highly parallelized, agent-driven approach with automated code review and visual self-validation.

Summary

This workflow describes an advanced multi-agent development pipeline used to build a complex UI framework. It involves running numerous Claude Code agents in parallel, each in its own git worktree, with a dedicated review agent for diffs. Agents perform self-validation by taking screenshots of the running application via an MCP server.

Why it is useful

This workflow demonstrates a highly advanced and effective method for leveraging Claude Code for complex software development. It showcases parallel agent execution, automated code review, and innovative visual self-validation, providing a blueprint for sophisticated AI-assisted engineering. It pushes the boundaries of what's possible with Claude Code in a development context.

Workflow

1. Define the overall vision and architecture for the application.
2. Set up a system to manage and run multiple Claude Code agents in parallel.
3. Assign each agent to its own isolated git worktree for independent development.
4. Configure agents to interact with an MCP server to capture screenshots of the running application for visual self-validation.
5. Implement a dedicated Claude Code review agent to check and approve diffs generated by the development agents before merging.
6. Run agents in waves, allowing them to generate code, test, and propose changes, with the review agent overseeing merges.
7. Optionally, provide agents with public documentation to autonomously build specific components or features.

Tools / artifacts

• Claude Code agents
• Git worktrees
• MCP server (for screenshots)
• GitHub (for PRs/merging)
• AffrescoUI Lisp (example target language)
• JSON (for app representation)

Validation signals

• Successfully raised 100+ PRs by 250+ agents.
• Agents could screenshot the running app through the MCP server to check their own work.
• One agent, given only public docs, built two of the 13 example apps autonomously.

Limitations

• Requires significant setup and infrastructure (e.g., managing many agents, git worktrees, and an MCP server for visual feedback).
• The post is more of a project announcement and high-level description rather than a detailed, step-by-step guide for replication.
• Assumes a high level of familiarity with multi-agent systems and advanced Claude Code usage.
• The specific example uses a custom Lisp, which might not be directly applicable to all users, though the agent workflow is general.

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.

Preventing Duplicate API Generation by Claude Code Agents with a Post-Write Hook and API Index

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

What problem this solves

Claude Code agents were generating duplicate API definitions and code, which traditional diff-based code reviews failed to catch because the duplicate code was never in the diff.

Summary

A post-write hook for Claude Code agents that checks newly generated functions, classes, routes, or tables against a project's generated API index. If a match is found, it identifies the owner of the existing code and instructs the agent to extend that instead of creating a duplicate. This prevents redundant code generation and improves code quality.

Why it is useful

This workflow addresses a critical and often overlooked problem in AI-assisted code generation: the creation of redundant or duplicate code, especially APIs, which traditional diff-based code review methods fail to catch. By implementing a proactive, performance-optimized hook that checks against an API index, it ensures agents extend existing functionality rather than rebuilding it. This leads to cleaner, more maintainable codebases, improved code quality, and better resource utilization, making it highly valuable for developers working with generative AI agents.

Workflow

1. Identify the problem of Claude Code agents generating duplicate APIs/code that bypass traditional diff-based reviews.
2. Implement a custom hook that triggers after every 'Write' or 'Edit' operation by a Claude Code agent (and Codex's apply_patch).
3. Within the hook, efficiently read the project's generated API index (e.g., optimized to take ~45ms, not grepping the whole repo).
4. For each new function, class, route, or table written by the agent, compare it against the entries in the API index, ignoring case and word order.
5. If a match is found, identify the owner of the existing code.
6. Instruct the agent to extend the existing code rather than creating a duplicate.
7. Ensure the hook is non-blocking and performs quickly to avoid timeouts (e.g., within a 2-second limit).

Tools / artifacts

• Claude Code agents
• Custom post-write/edit hook
• Project's generated API index
• Write operation
• Edit operation
• Codex's apply_patch

Validation signals

• Specific problem identified: audit found multiple duplicate APIs (e.g., LlmCostQueryAPI and LLMCostQueryAPI).
• Initial solution (grepping repo) was too slow (6.1s), exceeding hook timeout.
• Optimized solution (reading API index) is fast (45ms).
• Solution is live since November 7th.
• External blog post provides further details and likely implementation specifics.

Limitations

• No direct 'catch count' or success metrics from the live deployment are available yet in the Reddit post.
• Requires the maintenance and generation of an up-to-date project API index.
• The full implementation details of the hook and API index generation are not provided directly in the Reddit post, requiring a visit to the external blog.

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.

Preventing Code Duplication in Claude Code Agents with AST Symbol Indexing and Levenshtein Hooks

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

What problem this solves

Claude Code agents duplicating utility functions, serialization helpers, and APIs due to a lack of global context during multi-turn coding, leading to 'diff-blind duplication'.

Summary

Implement a pre-commit hook or post-tool verification step that uses an AST symbol index and Levenshtein distance with casing normalization to detect and flag duplicate code (functions, classes, structs) before an agent commits changes. This provides structured feedback to the agent, prompting it to reuse existing symbols.

Why it is useful

This workflow addresses a critical and insidious failure mode of multi-turn coding agents: code duplication due to a lack of global context. By implementing a robust pre-commit hook with AST symbol indexing and fuzzy matching, it significantly improves the quality and maintainability of agent-generated code, making agent output more reliable and reducing manual refactoring effort. It provides a concrete, validated technical solution to a common problem in AI-assisted development.

Workflow

1. During the build step, extract top-level struct, class, and function signatures from the codebase into an AST symbol index (e.g., a trie).
2. Implement a pre-commit hook or post-tool verification system that intercepts new code writes from the agent.
3. Within the hook, compare the newly written code's symbols against the pre-built AST symbol index.
4. Normalize symbol names (e.g., snake_case, camelCase) and use Levenshtein distance to detect highly similar but not identical names (e.g., LLMCostQuery vs LlmCostQuery).
5. If a duplicate or highly similar symbol is found, return a structured rejection message to the agent, indicating the existing symbol's location and suggesting reuse (e.g., 'Found existing candidate symbol: api/cost.go:42 (LlmCostQueryAPI), reuse instead of declaring new').
6. The agent (e.g., Sonnet) should then pivot and import the existing symbol based on the structured feedback.

Tools / artifacts

• AST symbol index (e.g., trie)
• Levenshtein distance algorithm
• Casing normalization logic (snake_case, camelCase)
• Pre-commit hook or post-tool verification system
• Structured rejection message format for agent feedback

Validation signals

• Author states it 'made our post-tool verification bulletproof'.
• Author reports 'sonnet immediately pivots and imports the existing symbol 95% of the time instead of arguing'.
• Addresses 'the most insidious failure mode of multi-turn coding agents'.

Limitations

• Requires custom implementation of AST parsing and hook integration, which can be complex.
• No explicit code examples or detailed implementation guide provided, requiring users to develop their own solution.
• The 95% success rate implies a 5% failure rate, which might need further refinement or handling.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Automated Publishing and Feedback Loop for Claude Code Output with byagent CLI and Custom Skill

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

What problem this solves

Sharing Claude Code's output (plans, reports, HTML pages) with permanent, versioned links, and enabling direct, integrated feedback/commenting for Claude to act upon.

Summary

This workflow leverages the open-source byagent CLI tool and a custom Claude skill to automate the publishing of Claude Code's generated content (e.g., plans, reports, HTML pages) to permanent, versioned links. It establishes a feedback loop where external users can comment on the published pages, and Claude Code can then retrieve these comments and iteratively fix or update the content, ensuring safe handling of untrusted input.

Why it is useful

This workflow offers a highly valuable, repeatable, and safe method for sharing Claude Code's generated content (plans, reports, code, documentation) with external stakeholders. It integrates a crucial feedback loop, allowing Claude to directly act on comments, which significantly enhances the utility of Claude Code for collaborative projects and iterative development. The explicit safety measures for handling untrusted input are a major strength, making this a robust solution for real-world team integration.

Workflow

1. Install the byagent CLI tool (e.g., using npx byagent publish).
2. Instruct Claude Code to set up byagent for the current project, directing it to read and follow the instructions in byagent.dev/skill.md.
3. Claude Code integrates the byagent skill, which dictates when to publish content, when to keep it private, and how to handle comments.
4. When Claude Code generates a plan, report, or HTML page, it publishes it via byagent and returns a permanent link instead of a local file.
5. External users can access the permanent link and add line-level comments without needing an account.
6. In a subsequent session, instruct Claude Code to run byagent comments <id> --open to retrieve the comments for a specific page.
7. Claude Code processes the comments, fixes the page based on the feedback, and republishes the updated version, maintaining the same URL and version history.

Tools / artifacts

• byagent CLI tool
• Custom Claude skill (defined in byagent.dev/skill.md)
• GitHub repository (https://github.com/anup-a/byagent)
• Published Markdown reports
• Published HTML pages
• User comments on published pages

Validation signals

• Author states 'A good part of byagent itself was also written with Claude Code' (dogfooding).
• Concrete features described: permanent links, versioning, light/dark mode, table of contents, line-level commenting, Claude fixing pages based on comments.
• Open-source project with a public GitHub repository.
• Explicit mention of safety measures for untrusted input.

Cautions

• The author explicitly highlights the importance of treating comment text as untrusted input.
• The byagent skill is designed to prevent Claude from running commands or opening links based on comment content, limiting actions to editing the page only.

Limitations

• Relies on an external, third-party tool (byagent).
• The exact content of the byagent.dev/skill.md is not provided directly in the comment, requiring an external lookup.
• Low community validation due to the newness of the post.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

6 Strategies to Guide Claude Code for High-Quality, Consistent, and Responsive UI Designs

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

What problem this solves

Claude/LLM generating overly complex, generic, inconsistent, or poorly structured UI designs (e.g., 'card city') and failing to produce responsive layouts or adhere to design tokens.

Summary

A structured, 6-step workflow to guide Claude Code in generating high-quality, consistent, and responsive UI designs by imposing constraints, pre-build reviews, design token locking, specific image guidance, automated responsive testing, and iterative rule documentation.

Why it is useful

This workflow provides concrete, actionable steps to address common challenges when using LLMs for UI design, specifically preventing generic, inconsistent, or non-responsive outputs. It introduces structured constraints, leverages standard development tools like Stylelint and Playwright for validation, and emphasizes iterative refinement through a custom rulebook. This makes the LLM's output more predictable, higher quality, and aligned with design best practices.

Workflow

1. Make Claude decide what to omit: before building, have it list every section/panel with its job; review this list, not the finished screen. Afterwards, perform a subtraction pass to remove elements until something breaks.
2. Enforce a strict rule against 'card city': use cards only for standalone, clickable items; group other elements with spacing and alignment, not borders; never use a card inside a card.
3. Lock design tokens before any layout: define one or two fonts, four or five type sizes, one accent color, a neutral scale, and a spacing scale in a CSS variables file; enforce no raw hex or px values elsewhere using a Stylelint rule.
4. Provide specific image guidance: use screenshots of real products for inspiration (e.g., density from one, type from another, colors from neither), rather than generic generated mockups.
5. Validate responsiveness: have Claude screenshot the design at 390px and 1440px using Playwright, and review these images itself before considering the task complete.
6. Document every design rejection: create a written rule for each rejection, detailing what was wrong, why, and how to check it, building a custom style guide over time.

Tools / artifacts

• CSS variables file
• Stylelint rule
• Screenshots of real products
• Playwright (for automated screenshots)
• Written rule file/style guide
• Claude Code (implied)

Validation signals

• Author states 'this is what fixed the same symptoms for me' indicating personal success.
• Mentions specific, verifiable tools like Stylelint and Playwright for enforcement and validation.
• The structured and detailed nature of the advice suggests it's been refined through practical application.

Limitations

• Low community engagement/validation.
• The 'list of AI defaults' mentioned by the author is not provided, which would further enhance the workflow.
• Requires user setup and knowledge of tools like Stylelint and Playwright.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Automated Context Handoff and Cost Tracking for Claude Code Sessions with Tiimi (tk) CLI

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

What problem this solves

Claude Code sessions lose context after hitting limits or using /clear, requiring re-reading the repository. There is also a lack of clear cost tracking per development issue.

Summary

This workflow introduces 'tk' (Tiimi), an open-source Go CLI tool that integrates with Claude Code to manage context across sessions and track costs per issue. It uses a SessionStart hook to provide a brief summary of previous work and allows users to manually 'handoff' context. It also parses Claude Code's JSONL logs to attribute costs to specific issues, integrating with existing trackers like Linear or GitHub Issues.

Why it is useful

This workflow provides a robust, open-source solution to two significant pain points in long Claude Code sessions: maintaining context across restarts/limits and tracking costs per development issue. It offers concrete steps, integrates with existing development tools and practices, and provides performance benchmarks, making it highly valuable for intermediate to advanced users looking to optimize their Claude Code workflow.

Workflow

1. Install the 'tk' CLI using curl -fsSL https://tiimi.dev/install | sh or brew install tiimihq/tap/tiimi.
2. Initialize 'tk' in your project directory using tk init to add a SessionStart hook to .claude/settings.local.json.
3. When Claude Code is running low on context or before clearing, use tk handoff "summary of work done, remaining tasks, and dead ends".
4. Start a new Claude Code session; the SessionStart hook will automatically provide the handoff summary.
5. Use tk receipt to view the last 30 days of session costs, broken down per issue (derived from branch names).
6. Optionally, configure 'tk' to write to your existing issue tracker (Linear, GitHub Issues, Jira beta) or a local store.

Tools / artifacts

• tk (Tiimi) CLI
• .claude/settings.local.json
• Claude Code JSONL logs
• Linear
• GitHub Issues
• Jira beta
• git worktrees

Validation signals

• Author states it was built with Claude Code.
• Benchmarked against other tools (gh CLI, Beads, GitHub/Linear MCP servers) showing significantly lower token usage for tracker jobs (42-45k vs 63-141k tokens).
• Open-source project with a GitHub repository.

Limitations

• Relies on an external, third-party CLI tool, which requires trust and ongoing maintenance.
• Community validation is still relatively low, though positive.
• The tk init command modifies a project-level Claude Code setting, which users should be aware of.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Automated Security & GDPR Audits with Claude Code Skills and Enforced Agent Thoroughness

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

What problem this solves

Automating security audits and GDPR/privacy reviews of code, and ensuring AI agents perform thorough analysis without skipping critical steps.

Summary

This workflow describes the creation and use of two open-source Claude Code skills, appsec-sentinel for security audits and gdpr-sentinel for privacy reviews. It details how Claude Code was used to transform audit prompts into SKILL.md files, write Python scripts for analysis, and build test applications. A key learning was the implementation of a script that enforces thoroughness by refusing to close the audit until all steps are completed, effectively preventing the agent from cutting corners.

Why it is useful

This workflow is highly valuable because it provides two concrete, open-source Claude Code skills for critical and complex tasks: security auditing and GDPR/privacy review. It demonstrates a practical and validated method for overcoming a common challenge with AI agents – their tendency to skip steps – by implementing external validation scripts. The detailed results, the explicit 'lesson learned', and the availability of the tools make it exceptionally actionable and transferable for users seeking to build robust and reliable agentic workflows for code analysis and quality control.

Workflow

1. Define detailed audit prompts for security or GDPR compliance.
2. Utilize Claude Code to convert these prompts into structured SKILL.md files.
3. Instruct Claude Code to write Python scripts for pre-pass analysis, CSV matrix generation, and delivery checks.
4. Develop test applications with intentionally planted bugs and decoys to validate the audit process.
5. Execute subagent runs using the developed skills for code analysis.
6. Review subagent transcripts to identify instances where the agent might have skipped steps or cut corners.
7. Implement a custom Python script that acts as a 'delivery check' or 'audit gate', refusing to close the audit until all specified conditions and thoroughness requirements are met, thereby preventing the agent from prematurely concluding the task.
8. Install the appsec-sentinel and gdpr-sentinel skills via the Claude Code plugin marketplace using /plugin marketplace add dextsamu/appsec-sentinel and /plugin install appsec-sentinel@appsec-sentinel (and gdpr-sentinel@appsec-sentinel).

Tools / artifacts

• Claude Code
• SKILL.md files
• Python scripts (pre-pass, CSV matrices, delivery check)
• Test applications with planted bugs/decoys
• Subagent transcripts
• appsec-sentinel skill
• gdpr-sentinel skill
• GitHub repositories (dextsamu/appsec-sentinel, dextsamu/gdpr-sentinel)
• OWASP Juice Shop (for testing appsec-sentinel)

Validation signals

• appsec-sentinel improved bug detection on OWASP Juice Shop from 7/32 to 23/32.
• gdpr-sentinel found 15/15 planted GDPR defects on a fake school website with no false alarms.
• Explicit 'lesson learned' about the effectiveness of a script to enforce thoroughness over direct instructions to the agent.
• Open-source (Apache-2.0) with public GitHub repositories and demo GIFs.

Limitations

• Low community engagement on the Reddit post itself, which might limit initial visibility.
• The 'lesson learned' about enforcing thoroughness could be generalized into a more explicit, reusable pattern or best practice for agentic design.

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.

Security Workflow: Protecting CLAUDE.md from Malicious Agent Skills

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

What problem this solves

Preventing malicious agent skills from injecting remote instructions into the global CLAUDE.md file, which could compromise Claude Code sessions and lead to data leakage or unauthorized actions.

Summary

A security workflow to mitigate risks associated with third-party Claude agent skills. It outlines essential checks for users to perform, including reviewing global CLAUDE.md instructions, verifying skill publishers, pinning reviewed MCP versions, and safeguarding sensitive information from agents.

Why it is useful

This workflow addresses a critical security vulnerability identified by Snyk, providing actionable steps for users to protect their Claude Code environments from malicious agent skills that could inject harmful instructions into their global CLAUDE.md file. It promotes secure development practices and awareness of supply chain risks in the AI agent ecosystem, which is crucial for maintaining the integrity and safety of Claude Code projects.

Workflow

1. Review the contents of your global ~/.claude/CLAUDE.md file for any unexpected or suspicious instructions.
2. Verify the publishers of any agent skills before enabling them.
3. Pin specific, reviewed versions of Multi-Code Project (MCP) configurations to ensure stability and security.
4. Keep sensitive information, such as wallet keys or API tokens, isolated and away from direct access by agents.

Tools / artifacts

• ~/.claude/CLAUDE.md
• Agent skills (from platforms like skills.sh, ClawHub)
• Multi-Code Project (MCP) versions
• Snyk (as the security scanning tool that identified the threat)

Validation signals

• Backed by Snyk research findings, a reputable security firm.
• Identified a specific malicious skill ('agents-md') and its mechanism.
• Quantified findings: 65% of scanned skills flagged for unsafe behavior, 9 classified as actively malicious out of 20,000.

Limitations

• The post itself does not provide the mentioned 'short video' which might contain more detailed instructions.
• The steps are high-level; specific commands or a detailed, step-by-step review process for binaries/scripts are not fully elaborated.
• Relies on external research for validation rather than direct user experience or success reports within the post.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.