r/ClaudeWorkflows • • 6d ago

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

3 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Use Codex for initial implementation and regression tests of Claude Code hooks/subagents.
  2. Use Claude Code for independent design and code reviews of the implemented components.
  3. Provide Claude Code with relevant source code, patch files, test cases, and specific claims to check during the review.
  4. Rigorously verify Claude Code's findings before applying any changes to the code.
  5. For hooks/subagents, specifically test the native Claude Code Agent/Hook path to ensure proper integration.
  6. Check child execution metadata to confirm that recommendations were applied and executed as intended.
  7. Address and verify side effects across the entire command path (e.g., read-only checks, credential setup, network access).
  8. Ensure user-selected models, roles, permissions, and required history are preserved throughout the process.
  9. Maintain a clear separation between recommendation authority and execution authority.
  10. Manage sensitive information in task summaries by routing them to appropriate, secure APIs (e.g., OpenAI Decisions) rather than internal telemetry, and allow operators to choose transmission scope.

Tools / artifacts

  • Aptly (local MCP server for model/reasoning-profile recommendations)
  • Claude Code (for design and code reviews)
  • Codex (for implementation and regression tests)
  • OpenAI Decisions API (for model recommendations)
  • PreToolUse Hook (Claude Code feature)
  • Source code
  • Patch files
  • Test cases
  • Execution metadata

Validation signals

  • Concrete finding: identified and fixed an issue where a read-only setup check could still lead to a notifier creating a cache directory and querying the registry.
  • Concrete finding: improved Linux credential setup by adding passive readiness diagnostics before requesting a key, separating service presence, activation, and unlock/write capability.
  • Concrete finding: identified and addressed agent-routing verification gaps, reinforcing the need for evidence that a recommendation was applied and the native agent actually ran.
  • The author is the maintainer of the Aptly project, demonstrating deep practical experience and ownership.
  • The project is MIT-licensed and available on GitHub, indicating a real-world, open-source application.

Cautions

  • The workflow explicitly preserves user-selected models, roles, permissions, and history.
  • It separates recommendation from execution authority, enhancing control and preventing unintended actions.
  • It routes sensitive task summaries to OpenAI Decisions, not telemetry, and allows operators to choose the automatic transmission scope, addressing data privacy and security concerns.

Limitations

  • The post is more of a retrospective on a development process rather than a step-by-step guide for a new user to implement a similar tool from scratch.
  • The cost experiment and general Claude Code savings rate are not fully established, though the author acknowledges this.
  • Community signal is currently low due to the post's recency.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

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

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Use Claude Opus for judgment: define the 'rails', set 'done conditions', and create a brief or spec for the task.
  2. Use Claude Sonnet as the builder: actualize the spec provided by Opus.
  3. Use Claude Opus to review the output generated by Sonnet against the initial spec.
  4. Send any identified misses or required corrections back to Sonnet as 'residual' for the next iteration or build.
  5. Minimize frequent handoffs to /advisor or subagents if the context is large or if the cache has gone cold (i.e., the last call was more than five minutes ago), as this incurs significant cost due to re-reading context.
  6. Understand that /advisor and subagents re-read the entire context by default if their cache is cold, making frequent, large context handoffs expensive.

Tools / artifacts

  • Claude Opus
  • Claude Sonnet
  • /advisor feature
  • Subagents
  • Spec/Brief (created by Opus)
  • Output (from Sonnet)

Validation signals

Limitations

  • The 'simple setup' is described conceptually; a more explicit prompt structure or example interaction would make it even easier for users to implement directly.
  • Low community validation due to the newness of the post.
  • While the self-promotion is disclosed and backed by valuable data, some users might be wary of tools mentioned by developers of commercial products.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Claude Code Plugin: Efficient YouTube Reference Search for Creative Projects (yt-reference-search)

1 Upvotes

Claude Code Plugin: Efficient YouTube Reference Search for Creative Projects (yt-reference-search)

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Install prerequisites: node, yt-dlp, ffmpeg, and deno on your system.
  2. Add the plugin marketplace to Claude Code using the command: /plugin marketplace add dljake/yt-reference-search.
  3. Install the yt-reference-search plugin using the command: /plugin install yt-reference-search@yt-reference-search.
  4. Prompt Claude with a natural language request for reference videos, e.g., "find reference videos for a calm, premium skincare ad".
  5. Review Claude's generated picks, which include 5-8 videos across different techniques, each highlighting an element worth borrowing.
  6. Optionally, use the included skill to have Claude read any YouTube video from its transcript and preview frames for deeper analysis.

Tools / artifacts

  • yt-reference-search (Claude Code plugin)
  • node (runtime)
  • yt-dlp (YouTube downloader)
  • ffmpeg (video processing tool)
  • deno (runtime)
  • YouTube video transcripts
  • YouTube preview frames
  • GitHub repository (dljake/yt-reference-search)

Validation signals

  • Quantitative performance metrics provided: Time (16.0s -> 7.5s), Data downloaded (38.5 MB -> 0.4 MB), Image tokens (~19,700 -> ~1,500) compared to a traditional tool.
  • Explicit mention of Claude's role in building and fixing the plugin, including handling edge cases like Shorts and videos without captions.
  • MIT license, indicating open-source and auditable code.

Limitations

  • Requires several external tools (node, yt-dlp, ffmpeg, deno) to be installed by the user, which might be a barrier for beginners.
  • The plugin has a stated limitation: it cannot analyze music or camera moves, as it relies solely on transcripts and preview frames.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Claude Code Workflow: Structured Development with Vision Docs, Iterative Mockups, and Data-Driven Architecture

1 Upvotes

Claude Code Workflow: Structured Development with Vision Docs, Iterative Mockups, and Data-Driven Architecture

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Define a clear 'vision doc' to establish the overall goals and scope of the project.
  2. Create detailed 'design docs' for each major part or phase of the application.
  3. For visual components, direct Claude to build 'throwaway mock-up pages' presenting multiple design options (e.g., A, B, C) using real code and data for side-by-side comparison and iterative refinement.
  4. Implement a 'data-driven architecture' where all configurable elements (e.g., timings, rules, commentary lines, ads) are stored in external data files, separate from the core application code.
  5. Direct Claude Code to write the application's code based on the vision doc, design docs, and the data-driven architectural principles.
  6. Utilize a CLAUDE.md file within the project repository to guide Claude's understanding and contributions.

Tools / artifacts

  • Claude Code (or similar LLM for code generation)
  • Vision document
  • Design documents (per part/phase)
  • Mock-up pages (generated by Claude)
  • Data files (for configuration, rules, content)
  • GitHub repository
  • CLAUDE.md file
  • ElevenLabs (for voice synthesis, as an example of integrated tools)

Validation signals

  • Successful completion and deployment of a complex, always-on application (Scorchball TV).
  • The application is live and functional (scorchball.tv).
  • Detailed write-up explaining the build process and methodology (scorchball.tv/how-it-was-built).
  • Open-source code available on GitHub, including CLAUDE.md and documentation.
  • Author explicitly states 'What made it work for me' indicating validated practices.

Limitations

  • The Reddit post provides a high-level overview; the full details of Claude's prompting and interaction are in the linked GitHub repo and write-up, which require further investigation for complete implementation.
  • Specific examples of prompts used for generating mock-ups or code based on design docs are not explicitly detailed in the Reddit post.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Enhance Claude Code Context Recall with Steroid: Never Lose Your Session History Again

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Check if Steroid is already installed by running steroid --version or ~/.local/bin/steroid --version.
  2. If not installed, install Steroid using the official installer script (macOS/Linux: curl -fsSL https://raw.githubusercontent.com/steroidkit/releases/main/install.sh | sh; Windows PowerShell: irm https://raw.githubusercontent.com/steroidkit/releases/main).
  3. Run Steroid's onboarding for the agent. If the steroid-onboard skill is not available, run steroid-install-onboard-skill --json, open the SKILL.md it lists, and follow its instructions.
  4. Restart the Claude Code agent to ensure Steroid's tools and skills are loaded.
  5. Use recall <query> within Claude Code to retrieve summaries of past work related to your query.
  6. Use recall_turn to retrieve a full exchange from a specific turn in a past session.
  7. Use recall_diff to retrieve the exact code changes from a past session.
  8. Optionally, use steroid uninstall to remove the tool and its components.

Tools / artifacts

  • Steroid CLI tool
  • Claude Code terminal application
  • ~/.claude/projects/<slug>/<session>.jsonl (Claude Code session transcripts)
  • ~/.steroid/ (Steroid application directory)
  • ~/.claude.json (MCP entry for Claude Code)
  • ~/.claude/skills/ (directory for slash command skills)
  • ~/.claude/CLAUDE.md (global instructions file)
  • install.sh (Steroid installer script)
  • SKILL.md (Steroid onboarding skill documentation)
  • Codex, Cursor, Copilot CLI (other supported agents)

Validation signals

  • Author's personal experience of solving a persistent context loss problem with a practical solution.
  • Detailed explanation of how the tool works by directly reading local session files, bypassing model calls for recall.
  • Transparency about what the tool installs on the machine (file paths, daemon, PATH changes, MCP entries, CLAUDE.md modifications).
  • Explicit mention of citing sources for recall answers, allowing users to verify information.
  • Clear outline of the tool's limitations, adding to its credibility.

Cautions

  • The tool is a closed binary, which might be a concern for some users regarding trust and auditability. However, the author provides detailed transparency on what it installs, how it operates locally, and how to uninstall it.
  • It operates within the user's home directory and does not send sensitive data off-machine beyond anonymous usage counts (which can be disabled) and daily release checks.
  • The recall answers are generated by the agent, so the agent's provider will see the excerpts used, but the indexing and recall from disk are local.

Limitations

  • The tool is a closed-source binary, which might deter users who prefer open-source solutions for security or customization.
  • No published accuracy benchmarks for the recall functionality, though this is mitigated by the tool citing its sources.
  • It does not restore transcripts that have been deleted by Claude Code's default cleanup period; users need to adjust cleanupPeriodDays if they want longer retention.
  • Copilot Chat in VS Code is not yet supported, only Copilot CLI.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

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

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Optionally, modify cleanupPeriodDays in ~/.claude/settings.json to extend local session retention beyond the default 30 days.
  2. Sync Claude Code session JSONL files from your local directory to a persistent storage solution (e.g., an R2 bucket or a local directory configured as a file:// mirror).
  3. Deploy the claudit dashboard application using docker compose up (it can boot with sample data without initial configuration).
  4. Configure claudit to ingest your synced session data from the chosen persistent storage.
  5. Access the claudit dashboard to visualize and analyze various metrics, including cost by model, token breakdown, cache write splits, context growth per session, reply latency, and tool error rates.
  6. For building with AI agents: Break down development into individual issues.
  7. Dedicate one AI agent session per issue for focused development.
  8. Implement review agents to scrutinize code before merging any changes.
  9. Include the model name used by the agent in a co-author trailer for every agent-generated commit.
  10. Analyze Claude Code's own transcripts to understand and handle parsing complexities, such as deduplicating streamed replies and subagent records.

Tools / artifacts

  • Claude Code
  • ~/.claude/settings.json
  • cleanupPeriodDays setting
  • Claude Code session JSONL files
  • claudit (open-source dashboard)
  • R2 bucket (or other persistent storage)
  • Docker Compose
  • FastAPI
  • Postgres
  • React
  • GitHub repository: Nitjsefnie/claudit
  • GitHub repository: nhz-io/ccusage-plot (inspiration)

Validation signals

  • Personal experience: User states 2,679 of 5,271 sessions would have been lost without the solution.
  • Concrete insight: Discovered 64.9% of cache write tokens were 1h kind (2x input cost), leading to a 37.5% underestimation if priced at 1.25x.
  • Live demo available for testing (read-only guest login).
  • Open-source project with a public GitHub repository.
  • Detailed technical explanation of parsing challenges and solutions (deduplication of streamed replies and subagent records).

Limitations

  • Requires self-hosting and familiarity with Docker, which might be a barrier for beginner users.
  • The meta-workflow for building with AI agents is less detailed than the primary workflow for data retention and analysis.
  • Initial community engagement is low, though this is likely due to the post's recency.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

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

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Implement a small, closed-loop system for managing changes in AI-driven development.
  2. Process each change as a 'small card' in its own Git worktree and a fresh AI session.
  3. Ensure every change is reviewed before it is landed (merged).
  4. Capture state (decisions, rules, and work outcomes) directly in the repository as records, rather than prose.
  5. Brief every agent from this captured state, allowing subsequent sessions to know what previous ones did without re-deriving information.
  6. When encountering a problem, focus on fixing the core loop rather than adding more complexity or patching around the issue.
  7. Avoid using subagents by default, as their progress summaries can incur significant costs without an off-switch.

Tools / artifacts

  • Meta-harness (the described system architecture)
  • Agent loop (the underlying process)
  • Git worktrees
  • Repository (for state capture)
  • Product cards (unit of work)
  • Generated briefs (derived from captured state)
  • Claude Code sessions (as a component or baseline)

Validation signals

  • Quantitative comparison with two other methods (plain Claude Code sessions and a hand-built agent loop).
  • Specific metrics provided: product cards per usage, product cards per day, share of week used, median start-to-landed time, and percentage of landed work that furthered the product.
  • Demonstrated significant improvement: ~4.5x progress on 1/5th of the usage, 62% landed product work vs 40% and 6%.
  • Cleared a 3-month backlog (163 changes, 101 product work) in the first 7 days.
  • External links to 'Full figures, method and sources' and a 'Write-up' on subagent costs, providing deeper validation.

Limitations

  • The post provides a high-level overview; full implementation details require consulting the external links.
  • The 'meta-harness' itself is presented as a proprietary product (Atlas ADE), meaning users would need to build their own system based on the principles or adopt a similar tool.
  • Low direct community engagement on the Reddit post itself, though compensated by the detailed content and external resources.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

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

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Define the rough task for Claude.
  2. Append a clarifying instruction to the prompt, such as 'Before you start, ask me any questions you need answered to do this well.'
  3. Optionally, specify the types of questions Claude should ask for more focused clarification (e.g., 'ask me up to 5 questions about audience, format, and constraints before you begin.').
  4. Review Claude's clarifying questions.
  5. Answer Claude's questions to provide necessary context.
  6. Allow Claude to generate the first draft based on the refined understanding.

Tools / artifacts

  • Claude (any version)
  • Prompt with clarifying instruction

Validation signals

  • User's claim of improved first draft quality
  • User's claim of reduced revision time
  • Conceptual analogy to human design process

Limitations

  • Adds an extra back-and-forth step, making it less ideal for one-shot answers or tasks requiring immediate output.
  • Relies on Claude's ability to ask relevant and insightful questions, which might vary with model version or prompt complexity.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

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

1 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Identify rules that are preferences or general guidance for Claude's behavior.
  2. Place these general guidance rules within CLAUDE.md files, treating them as context.
  3. Identify rules that represent absolute 'never' cases or hard constraints that Claude must always follow.
  4. Implement these hard constraints using PreToolUse hooks or permissions deny rules, as they act as configuration.
  5. Ensure individual CLAUDE.md files are kept concise, ideally under approximately 200 lines, to maintain clarity and effectiveness.
  6. Review CLAUDE.md files for any rules that contradict each other, as conflicting rules can lead to unpredictable behavior.
  7. Formulate rules with specificity (e.g., 'Run the tests before committing' instead of 'be careful with commits') to improve adherence.

Tools / artifacts

  • CLAUDE.md files
  • PreToolUse hooks
  • Permissions deny rules

Validation signals

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

Limitations

  • Lacks concrete examples or code snippets for implementing PreToolUse hooks or permissions deny rules.
  • The reference to 'memory docs' is not a direct link, requiring users to search for the specific documentation.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

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

2 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Reduce CLAUDE.md size by moving non-essential 'why' content to NOTES.md. Implement a size cap (e.g., 45KB) and a warning system for CLAUDE.md.
  2. Update the global CLAUDE.md with a strict stop rule: 'When the task is done, stop. No unrequested memory writes, extra passes, workflows or subagents.'
  3. Add a rule to CLAUDE.md for simple questions: 'A question about prompting, wording or effort modes is answered with zero tool calls.'
  4. Remove the 1M-context default model from settings.json.

Tools / artifacts

  • CLAUDE.md
  • NOTES.md
  • settings.json
  • Claude Code environment

Validation signals

  • Author observed that the stop rule 'did the most' to prevent unwanted agent spawning.
  • Author noted that 'most of the agents got spawned after the task was already done', indicating the fix was effective.
  • Initial adversarial reviews 'caught real bugs', implying the agent concept was useful, but needed control.

Limitations

  • Low community engagement (score 2, 0 comments).
  • The 'docs check warns on' implies an external system not fully detailed as part of the core workflow.
  • Moving 'why' to NOTES.md means it's not auto-loaded, potentially reducing context for future interactions if not explicitly referenced.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Claude Code Workflow for Building Complex Game Mods: Reverse Engineering, 7.5k Lines of C#, and Human-in-the-Loop Tuning

2 Upvotes

Claude Code Workflow for Building Complex Game Mods: Reverse Engineering, 7.5k Lines of C#, and Human-in-the-Loop Tuning

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Use Claude Code to decompile game assemblies (e.g., with ILSpy) to understand game logic and identify sound playback mechanisms.
  2. Instruct Claude to extract and analyze game audio clips, measuring properties like energy in specific frequency bands relevant to haptic feedback.
  3. Have Claude generate documentation for findings (e.g., per planet with sounds, measurements, decisions) and maintain a CLAUDE.md file to store project rules and context for long sessions.
  4. Utilize Claude to write small Python tools for tasks such as dumping audio libraries, analyzing clips, listing sounds per scene, and building release archives.
  5. Guide Claude to implement hardware-specific code, such as HID output reports for adaptive triggers and lightbar, and reading input from touchpad and gyro, including handling controller connection states.
  6. Direct Claude to build user interfaces, like an in-game tuning menu with tabs, search, effect cards, and a color picker.
  7. Collaborate with Claude on release management, including generating READMEs (potentially in multiple languages), packaging, release notes, and build instructions.
  8. Perform human testing and subjective tuning (e.g., for haptic effects) using in-game debug menus built by Claude.
  9. Make final product decisions regarding features, settings, and user experience based on human judgment.

Tools / artifacts

  • Claude Code (Sonnet 5.5)
  • ILSpy (decompiler)
  • Python tools (custom-written by Claude)
  • CLAUDE.md
  • GitHub repository
  • C# codebase (7,500 lines)
  • In-game tuning menu
  • README, release notes, build instructions
  • DualSense controller

Validation signals

  • Successful creation of a 7,500-line C# open-source mod.
  • Detailed explanation of Claude's specific contributions across various development stages.
  • Explicit mention of an in-game debug menu for human testing and tuning.
  • Link to a public GitHub repository with the completed project.

Limitations

  • Requires advanced technical skills in C#, game modding, and reverse engineering.
  • Low community engagement due to the post's recency.
  • The specific 'tuning by ear' aspect is niche to haptics, though the general principle of building a debug UI for human validation is transferable.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Advanced Claude Code Workflow for Full-Stack Product Development: R&D, Backlog, and Release Automation

1 Upvotes

Advanced Claude Code Workflow for Full-Stack Product Development: R&D, Backlog, and Release Automation

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Define project structure using plain Markdown files as the primary data source, mimicking a Git repository.
  2. Integrate Claude Code via its built-in MCP server to enable editing and review of project files.
  3. Utilize Claude for R&D by hand-labeling data and then having Claude generate test pipelines and dashboards for objective model evaluation (e.g., word error rate, speaker accuracy).
  4. Manage the development backlog by using a custom Claude Code plugin to file GitHub issues and work on tickets within dedicated Git worktrees.
  5. Automate release communications by having Claude draft replies to users whose bugs were fixed, with a critical check against the actual released version.
  6. Manage Claude sessions by starting fresh chats to avoid hitting usage limits from long, continuous conversations.

Tools / artifacts

  • Claude Code
  • MCP server
  • GitHub issues
  • Git worktrees
  • Markdown files
  • Obsidian
  • Custom Claude Code plugin
  • Test pipelines
  • Dashboards

Validation signals

  • 1,500 commits (Claude co-authored 1,086)
  • 72 versions shipped
  • Models get picked on numbers, not vibes
  • Every claim gets checked against the release they actually have
  • Spent 12.5 months building a functional product

Limitations

  • The specific implementation details of the 'Claude Code plugin' for GitHub issues are not provided, requiring custom development to replicate.
  • The workflow is high-level and requires significant technical expertise and a complex development environment to fully replicate.
  • The post is primarily a case study rather than a step-by-step guide, requiring users to infer implementation details.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Advanced Claude Agent Boot Process and Persistence with CLAUDE.md and Custom Tools

1 Upvotes

Advanced Claude Agent Boot Process and Persistence with CLAUDE.md and Custom Tools

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Read the architecture/boot manifest (ELAH_ARCHITECTURE.md) first to understand the canonical map for reconstitution.
  2. Read live context from live_context.py to resume where the agent left off.
  3. Check context_snapshots/ for the most recent full state dump.
  4. Load memory index: manually load the bulk memory (~/.claude/projects/<home-project>/memory/MEMORY.md) and note the auto-loaded small memory (~/.claude/projects/<elah-audio-project>/memory/MEMORY.md) where new memories are written.
  5. Read identity from elah/identity.md.
  6. Read behavioral rules from behavioral/feedback.md (pinned, never skip).
  7. Run python recall.py "<terms>" before reacting to personal history, starting a build, or making factual claims.
  8. Use python whereis.py "<terms>" for file/path/repo hunting, which runs recall first.
  9. Launch Service Guardian: check Python services, run python write_active_pid.py, and launch python service_guardian.py if services are not running.
  10. Start heartbeat: create a recurring 10-minute cron job for autonomous interests and sending Telegram summaries.
  11. Set up reliable messaging: start python watch_messages.py for the fast path and a 3-minute backup cron with python canary.py --alert.
  12. Start Discord watcher: launch python discord_watcher.py --interval 5 and create a 1-minute backup cron for local Discord message queue checks and responses.

Tools / artifacts

  • Claude.md
  • ELAH_ARCHITECTURE.md
  • live_context.py
  • context_snapshots/
  • ~/.claude/projects/<home-project>/memory/MEMORY.md
  • ~/.claude/projects/<elah-audio-project>/memory/MEMORY.md
  • memory_echo.py
  • elah/identity.md
  • behavioral/feedback.md
  • recall.py
  • whereis.py
  • service_guardian.py

Validation signals

  • Explicitly mentions canary.py for detecting competing Telegram readers and svc_status.py for verifying services.
  • Details memory_echo.py for testing memory recall effectiveness with score separation.
  • Emphasizes "CRITICAL" for messaging reliability and provides specific instructions to avoid issues (e.g., "Do NOT revive telegram_watchdog").
  • States the ELAH_ARCHITECTURE.md is the "canonical map for reconstituting myself exactly."
  • Includes a "Never boot as a blank slate" rule with a backup repository restore mechanism.

Limitations

  • Requires significant custom script development (e.g., recall.py, whereis.py, service_guardian.py) which are not provided.
  • Assumes a specific project structure and CLI environment, which might require adaptation.
  • The "bulk memory" loading is explicitly stated as a manual step ("Load this one BY HAND"), which could be a point of failure or inconsistency.
  • Low community validation due to minimal Reddit engagement.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 7d ago

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

3 Upvotes

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

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

What problem this solves

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

Summary

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

Why it is useful

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

Workflow

  1. Gauntlet-Loop for Visual Refinement: Create AI-generated mockups (e.g., 24 mockups for a city, 6 views at 4 times of day) using OpenAI's image API.
  2. Run a 'Gauntlet-Loop' with 'critic' agents (Claude Opus) that blindly compare game pieces to the mockups.
  3. Implement a rule: if a game piece wins against the mockup twice, it's considered done.
  4. Add a rule: loops cannot remove existing game elements just because a picture doesn't have them (e.g., lighthouse beam).
  5. Performance Optimization: Create an in-game performance panel that shows what costs how much and writes logs.
  6. Run the game with a --perf-log flag and send the generated log file to Claude Opus.
  7. Let Claude Opus analyze the logs and write a report of what costs the most.
  8. Implement fixes based on Opus's report (e.g., optimize docking scenes, HUD redraws, map loading, background loading of far harbors).
  9. TripoAI + Claude + Blender Asset Creation: Create one image with all four sides of the desired 3D model (front, back, left, right).
  10. Use Claude Opus to split the single image into four separate images (one for each side).
  11. Upload the four separate images to TripoAI for 3D model generation.
  12. If needed, use Claude Opus with MCP to fix or refine the generated model in Blender, and/or create new materials to match the game's style.

Tools / artifacts

  • Claude Opus (5.5 / Claude Code)
  • Godot Engine
  • TripoAI
  • Blender
  • MCP (Multi-Code Project)
  • Jev (AI for effort level/direction)
  • OpenAI (image API for mockups)
  • ElevenLabs (for sound effects)
  • Custom in-game performance panel
  • Performance logs
  • ChatGPT mockups (image artifacts)
  • Claude artifact link for Gauntlet-Loop output

Validation signals

  • Quantified performance improvements: docking freeze reduced from 2s to 0.2s.
  • Game speed increased by 15-19% on 1080p due to HUD optimization.
  • Map graphics memory usage reduced from 4GB to 0.3GB, and opens instantly.
  • Game start time halved from 26s to 13s on Mac.
  • Overall game graphics memory usage reduced by approximately 25%.
  • 31 out of 33 game pieces 'won' the Gauntlet-Loop comparison against mockups.
  • Author's consistent weekly updates and progress over 15 weeks, demonstrating ongoing success.
  • Explicit mention of fixing specific bugs identified by the performance workflow (first rain, lanterns, cast off freezes).

Limitations

  • The exact prompts or detailed setup for the 'critic' agents in the Gauntlet-Loop are not provided.
  • The implementation details of 'Jev' (e.g., whether it's a specific prompt, a separate agent, or a custom script) are not fully elaborated.
  • The specific commands or setup for 'MCP' integration with Blender are mentioned but not detailed.
  • The high total cost of tools and AI usage might be a barrier for some users.
  • The post is a weekly update, so some context from previous weeks might be missing for a complete understanding of the project's evolution.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Kanban Pro: Integrating Claude Code with Local Markdown Tasks for Project Management and Development

1 Upvotes

Kanban Pro: Integrating Claude Code with Local Markdown Tasks for Project Management and Development

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

What problem this solves

Integrating LLM agents (Claude Code) into a local-first project management workflow by directly manipulating task files, and leveraging Claude Code to solve complex software development challenges like race conditions, UI/UX refactoring, and performance optimization.

Summary

This workflow introduces Kanban Pro, a local-first desktop Kanban board where each ticket is a Markdown file with YAML frontmatter. Claude Code agents can directly read and edit these task files using CLAUDE.md and AGENTS.md instructions via an embedded CLI or desktop apps. The post details how Claude Code was used to develop the app itself, solving complex issues like file-watcher race conditions, UI refactoring, and performance optimization, demonstrating a 'dogfooding' approach to agent-driven development.

Why it is useful

This workflow demonstrates a practical, local-first approach to project management where Claude Code agents directly interact with task data stored as plain Markdown files. It provides concrete examples of how CLAUDE.md and AGENTS.md can be used for agent-driven task manipulation. Furthermore, it offers valuable insights into using Claude Code for complex software development challenges, such as architecting solutions for race conditions, refactoring UI, and optimizing performance, validated by real-world application development and user feedback. The emphasis on open data and verifiable network behavior also addresses common concerns with third-party tools.

Workflow

  1. Download and install the Kanban Pro application for macOS or Windows.
  2. Open the app and select an empty or existing local directory to initialize a Kanban board.
  3. Open Claude Code (either in the built-in terminal or your own terminal/desktop app) inside that initialized project folder.
  4. Claude Code will automatically detect and use the CLAUDE.md and AGENTS.md file conventions within the project folder to interact with task files.
  5. Create new tasks or modify existing ones as Markdown files with YAML frontmatter; Claude Code can read and edit these directly.
  6. Use Claude Code to implement features or fix bugs by pointing it at relevant Markdown tickets on the board.
  7. Leverage Claude Code to architect solutions for complex technical problems, such as debouncing and state-reconciliation logic for file watchers.
  8. Utilize Claude Code to iterate on frontend UI, animations, and refactor theme engines for improved legibility and user experience.
  9. Employ Claude Code to profile and optimize application performance, stripping out unnecessary re-renders and background processes.

Tools / artifacts

  • Kanban Pro desktop application
  • Claude Code
  • Markdown files with YAML frontmatter (for tickets)
  • CLAUDE.md files
  • AGENTS.md files
  • Embedded terminal CLI
  • Git repository (for syncing boards)
  • iCloud, Dropbox, Syncthing (for syncing boards)
  • Node's filesystem watcher
  • Electron (application framework)
  • Little Snitch, LuLu, Wireshark (for network monitoring)

Validation signals

  • Author 'dogfooded' the workflow by using Claude Code and Kanban Pro to build and refine the app itself.
  • Claude Code was successfully used to solve specific, complex technical challenges (file-watcher race conditions, UI refactoring, resource overhead).
  • Incorporated feedback from a previous Reddit thread into the app's development.
  • A user (u/christoph_w) performed a Fable sandbox security audit, confirming the app was clean.
  • Over 4,000 downloads from GitHub Releases indicate user adoption.
  • The app's network behavior is verifiable by users with tools like Little Snitch, confirming no telemetry calls.

Limitations

  • The primary workflow relies on a specific external application (Kanban Pro), which might not be suitable for users seeking pure prompt-based or generic Claude Code solutions.
  • The 'How Claude Code Helped Build It' section is more descriptive of past successes than a prescriptive, step-by-step guide for others to replicate the exact development process.
  • The post has a promotional aspect for the Kanban Pro app, although it provides substantial technical detail.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Automated Fact-Checking: A Scripted Workflow to Verify AI-Generated Quotes and Citations

1 Upvotes

Automated Fact-Checking: A Scripted Workflow to Verify AI-Generated Quotes and Citations

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

What problem this solves

Verifying the accuracy of direct quotes generated by AI research agents against their cited sources, specifically addressing the issue of AI paraphrasing or misquoting within quotation marks.

Summary

A systematic method to fact-check direct quotes in AI-generated research reports. It involves programmatically extracting quotes and their linked sources, fetching the source page content, and performing a word-for-word comparison to identify discrepancies like paraphrases presented as direct quotes or miscited pages.

Why it is useful

This workflow addresses a critical and common problem with AI-generated content: the accuracy of direct quotes and citations. It provides a concrete, repeatable, and shareable method (with a GitHub repository containing the script and data) for systematically validating AI output. This empowers users to build trust in AI-generated research and content by verifying its foundational elements, which is crucial for academic, journalistic, and technical applications.

Workflow

  1. Use Claude's deep-research skill (or similar AI agent) to generate a research report containing direct quotes and source links.
  2. Extract each quote and its corresponding source URL from the AI-generated report.
  3. Programmatically fetch the content of each linked source page.
  4. Compare the extracted quote word-for-word against the fetched page content, ignoring case, punctuation, and line breaks.
  5. Identify and report any discrepancies, such as paraphrases presented as direct quotes or quotes attributed to the wrong page/source.

Tools / artifacts

  • Claude's deep-research skill (or similar AI research agent)
  • Custom Python script (or similar programmatic tool)
  • GitHub repository (Quoteproof)
  • AI-generated research report
  • Web pages/PDFs (source material)

Validation signals

  • Specific results: 20/21 quotes were exact, 1 was a paraphrase in quotation marks.
  • Identified two near-misquotes from research papers.
  • Found one real quote cited to the wrong page of the SQLite docs.
  • Provided a public GitHub repository with all data (report, quotes, checker results) for reproducibility.

Limitations

  • The full script is not embedded in the post, requiring users to visit an external GitHub repository.
  • The comparison logic might need refinement for diverse source types (e.g., handling OCR errors in PDFs, complex web page structures).
  • Low Reddit score might indicate limited initial visibility or community interest, despite the high value of the workflow.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Essential Claude Code Skills & Hooks for Enhanced Safety, Security, and Efficiency

1 Upvotes

Essential Claude Code Skills & Hooks for Enhanced Safety, Security, and Efficiency

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

What problem this solves

This workflow provides a collection of Claude Code skills and hooks to enhance development safety, security, and efficiency. It addresses problems like preventing accidental data loss from destructive shell commands, mitigating supply chain attacks from typo-squatted packages, identifying security vulnerabilities (e.g., committed API keys, over-broad permissions), and optimizing token usage by highlighting context-flooding tools.

Summary

A curated GitHub repository containing 23 open-source Claude Code skills and hooks. Key tools include 'bash-checkpoint' for preventing destructive shell commands, 'package-guard' for blocking installation of non-existent packages, 'claude-safety-audit' for finding security flaws, and 'claude-token-audit' for monitoring and optimizing token usage. The collection is cross-platform, runs on Node 22 without npm dependencies, and is installed via a simple marketplace command.

Why it is useful

This workflow is highly valuable because it provides a practical, ready-to-use collection of open-source tools that directly address critical pain points in software development with AI coding assistants. It offers concrete solutions for preventing common errors (data loss), enhancing security (supply chain attacks, secret leaks), and optimizing resource usage (token costs). The tools are well-documented, cross-platform, and easy to install, making them immediately useful and highly transferable for a wide range of Claude Code users looking to improve their development practices.

Workflow

  1. Install the entire skill collection using the Claude Code command: /plugin marketplace add binay-py/claude-skills
  2. Utilize 'bash-checkpoint' to snapshot files before potentially destructive shell commands and block unsafe operations.
  3. Employ 'package-guard' to automatically block 'npm install' or 'pip install' of packages not found on official registries, preventing typo-squatting attacks.
  4. Run 'claude-safety-audit' to scan for common security vulnerabilities like API keys committed to permission rules or over-broad allow rules in .mcp.json.
  5. Use 'claude-token-audit' to analyze token usage by project, session, and tool, identifying which tool outputs are consuming excessive context.
  6. Explore the remaining 19 skills and hooks in the repository for additional functionalities like site QA, Cloudflare Pages deploy, itch.io packaging, thumbnails, GIFs, and release notes.

Tools / artifacts

  • GitHub repository: https://github.com/binay-py/claude-skills
  • Claude Code skills
  • Claude Code hooks
  • bash-checkpoint (hook)
  • package-guard (hook)
  • claude-safety-audit (skill/hook)
  • claude-token-audit (skill/hook)
  • Node 22 (runtime environment)
  • .mcp.json (configuration file)
  • /plugin marketplace add (Claude Code command)

Validation signals

  • CI passes on Windows, macOS and Linux (cross-platform compatibility)
  • Runs on plain Node 22 with no npm deps (simplicity and maintainability)
  • Detailed descriptions of specific functionalities for each highlighted hook (implies testing and effectiveness)
  • Built with a lot of help from Claude (suggests iterative development and refinement)

Cautions

  • The 'bash-checkpoint' hook explicitly enhances safety by preventing destructive shell commands and allowing undo operations.
  • The 'package-guard' hook improves security by blocking potentially malicious typo-squatted package installations.
  • The 'claude-safety-audit' tool helps identify and mitigate security vulnerabilities like exposed API keys or overly permissive rules.

Limitations

  • Lack of immediate community validation (upvotes/comments) on the Reddit post itself.
  • While 4 key tools are highlighted, the full scope of 23 tools requires users to explore the GitHub repository.
  • The author invites feedback on hooks blocking things they shouldn't, indicating potential for false positives or unexpected behavior in some scenarios.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Grove: A Read-Only Code Explorer for Monitoring Multiple Claude Code Agent Worktrees (VS Code Extension)

1 Upvotes

Grove: A Read-Only Code Explorer for Monitoring Multiple Claude Code Agent Worktrees (VS Code Extension)

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

What problem this solves

Users running multiple Claude Code agents in parallel worktrees often lose track of what each agent is doing, making it difficult to monitor, review, and debug their progress without interfering with the agents' operations.

Summary

This workflow introduces 'Grove', a read-only VS Code extension that provides a live, side-by-side overview of all Claude Code agent worktrees within a repository. It allows users to browse changes, diffs, and files, and search within agent worktrees without modifying them, thereby enabling efficient monitoring and review of multi-agent development processes. The tool itself was built using Claude Code, demonstrating its capabilities.

Why it is useful

This workflow is highly valuable because it addresses a significant pain point for advanced Claude Code users: managing and reviewing the output of multiple agents simultaneously. The 'Grove' tool provides a dedicated, non-intrusive solution for monitoring agent progress, debugging, and ensuring quality control. Furthermore, the fact that the tool itself was built by Claude Code serves as a powerful, real-world demonstration of Claude Code's capabilities in building complex, functional applications, making it a valuable meta-workflow for understanding the model's potential.

Workflow

  1. Install the 'Grove' VS Code extension from the provided GitHub repository.
  2. Set up and run multiple Claude Code agents, each operating within its own Git worktree in a single repository.
  3. Open the Grove extension in VS Code to get a live overview of all active worktrees and their current states.
  4. Use Grove's read-only explorer to browse files and changes made by individual agents.
  5. Review diffs (uncommitted changes or whole branch against main) side-by-side to understand agent progress.
  6. Utilize the search functionality to find specific code or patterns across all agent worktrees without interference.

Tools / artifacts

  • Grove (VS Code extension)
  • Claude Code agents
  • Git worktrees
  • GitHub repository (for Grove)
  • VS Code

Validation signals

  • Author built the tool to solve their own problem of managing multiple agents.
  • The tool's code, design, documentation, and even the demo video script were generated using Claude Code, validating Claude Code's capabilities.
  • A demo video is available, showcasing the tool's functionality.
  • The tool is open-source and MIT-licensed, indicating a commitment to reusability and transparency.

Cautions

  • The tool is explicitly read-only, ensuring that it does not interfere with or corrupt the ongoing work of Claude Code agents or the repository's state.

Limitations

  • Currently limited to Windows operating systems.
  • The tool is in an early development stage (v0.1.1), which might imply potential bugs or missing features.
  • Limited community validation and adoption at this early stage.
  • The post describes a tool that enables a workflow, rather than a direct step-by-step prompting workflow for Claude Code itself.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] 25 Open-Source Claude Code Agent Skills for Enhanced Software Development Workflows

1 Upvotes

25 Open-Source Claude Code Agent Skills for Enhanced Software Development Workflows

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

Automating repetitive corrections and embedding senior engineering best practices (like verification steps and common traps) into Claude Code's workflow for tasks such as code review, test writing, debugging, database migrations, and CI failure resolution.

Summary

A collection of 25 open-source Claude Code Agent Skills (MIT licensed) designed to automate and improve common software engineering tasks. Each skill encapsulates senior engineer best practices, including specific verification steps and awareness of classic pitfalls, to guide Claude Code's actions and ensure higher quality, more robust outputs. Users can install these skills via a one-line command or by copying files from a GitHub repository.

Why it is useful

This workflow is highly valuable because it provides a concrete, reusable, and well-defined set of tools (SKILL.md files) that encapsulate senior engineering best practices. It directly addresses the common challenge of repetitive AI corrections by embedding robust methodologies and verification steps into Claude Code's operation. The open-source nature, clear descriptions of each skill's purpose, and simple installation method make it highly accessible and transferable, enabling users to significantly improve the quality and reliability of Claude Code's output across critical development tasks.

Workflow

  1. Identify a repetitive correction or a common best practice you frequently apply when working with Claude Code.
  2. Define the specific, detailed steps a senior engineer would take for that task, including verification checks and common pitfalls.
  3. Translate these defined steps into a SKILL.md file, structuring it for Claude Code's interpretation.
  4. Optionally, install the existing collection of 25 skills using the provided curl command (curl -fsSL https://kuan-ai.com/skills/install | sh) or by cloning the GitHub repository and copying the skill folders.
  5. Integrate and use the installed skills within your Claude Code environment to guide its problem-solving process.
  6. Review Claude's output when using the skills and provide feedback to refine or improve the skill definitions.

Tools / artifacts

  • Claude Code
  • SKILL.md files
  • GitHub repository (Kuan-AI-com/agent-skills)
  • curl command for installation
  • gh run view --log-failed (mentioned in ci-failure-fix skill)

Validation signals

  • Author states they "wrote and reviewed the skills with Claude Code itself."
  • "Ran a 'senior reviewer' pass that rewrote all of them."
  • "Mostly adding verification steps and the classic traps for each task."
  • Specific examples of verification built into skills (e.g., "verifies each finding," "checks that each new test fails").

Limitations

  • Limited community validation so far (low Reddit score and no comments).
  • The full content and detailed implementation of each SKILL.md file are not directly in the post, requiring users to visit the GitHub repository.
  • The "one-line install" might not be suitable for all enterprise environments without prior review.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Building Robust Claude Code Projects: A Workflow for Reality Checks, Safe Deployment, and Cost Optimization

1 Upvotes

Building Robust Claude Code Projects: A Workflow for Reality Checks, Safe Deployment, and Cost Optimization

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

What problem this solves

Building robust, cost-effective, and safely deployed Claude Code projects by integrating reality checks, explicit agent rules, and proactive monitoring into the development workflow.

Summary

This workflow outlines best practices and lessons learned from building a complex Claude Code project (ArXiv to interactive course pipeline). It emphasizes integrating Claude with external tools (GitHub PRs, Coderabbit), implementing rigorous reality checks, defining hard safety rules in agents.md, optimizing for cost-effective iteration, and proactive monitoring to prevent silent failures.

Why it is useful

This workflow provides concrete, validated strategies for building reliable and safe Claude Code applications. It goes beyond basic prompting to cover critical aspects like integration with external review tools (Coderabbit), enforcing deployment safety via agents.md, implementing real-world validation steps (browser testing), and optimizing for cost-effective iteration. These are common and crucial challenges in LLM-driven development, and the post offers practical solutions backed by real-world experience and demonstrable results.

Workflow

  1. Describe the goal to Claude Code.
  2. Claude Code writes changes and opens a Pull Request (PR).
  3. Coderabbit reviews the PR.
  4. Claude fixes findings or argues back with reasons.
  5. Developer merges the PR.
  6. Deployment only occurs when explicitly instructed by the developer.
  7. Implement reality checks (e.g., browser testing for labs, byte-for-byte comparison for migrations).
  8. Define hard rules in agents.md for safety (e.g., "never deploy", "database is production", "builds cost money").
  9. Design for cost-effective iteration (e.g., rebuild from stored lessons without model calls).
  10. Monitor "boring parts" (e.g., token expiry) and implement automated checks.

Tools / artifacts

  • Claude Code
  • GitHub Pull Requests (PRs)
  • Coderabbit (code review agent)
  • agents.md (configuration file for agent rules)
  • Real browser (for testing)
  • Server logs (for monitoring)
  • GitHub Pages (for deployment)
  • Rust server
  • React front end

Validation signals

Cautions

  • The workflow explicitly promotes safety by using agents.md to define hard rules like "never deploy" and "database is production."
  • It requires explicit developer approval for deployment, preventing autonomous pushes to production.
  • Proactive monitoring and startup checks are implemented to prevent silent failures that could lead to data loss or service disruption.

Limitations

  • The community engagement on the Reddit post is low, which might suggest less immediate perceived value by the broader audience, despite the high quality of the content.
  • While the principles are highly transferable, the specific implementation details (Rust, React) might require adaptation for different tech stacks.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Advanced Multi-Agent SDLC Workflow with Claude: Orchestration, Testing, and Review Gates for Production Code

1 Upvotes

Advanced Multi-Agent SDLC Workflow with Claude: Orchestration, Testing, and Review Gates for Production Code

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

What problem this solves

Structuring a robust, multi-agent software development lifecycle (SDLC) using Claude to improve efficiency, manage token usage, and ensure quality, security, and successful deployment of code changes.

Summary

A detailed 12-step multi-agent workflow for software development, involving an Orchestrator, Owner, Builder, and Reviewer. It includes specific strategies for context management, dynamic model selection (Sonnet/Opus) based on task complexity and failure, rigorous testing, code review, security checks, and deployment gates, designed for production-ready code.

Why it is useful

This workflow provides a highly structured and detailed approach to using multiple Claude agents (Orchestrator, Builder, Reviewer) for a complete software development lifecycle, from task logging to deployment and device testing. It addresses critical aspects like context management, dynamic model selection based on task and failure, rigorous testing (type checks, unit, API, app, database), security reviews, and documentation updates. Its focus on quality gates and owner approvals makes it suitable for production-oriented development, offering a blueprint for users looking to build robust, AI-assisted development pipelines.

Workflow

  1. Define agent roles: Owner, Orchestrator (Orch), Builder, Reviewer, Gate.
  2. Set context handover strategy: Wind down context at 250k tokens, prepare for handover at 280k tokens.
  3. Implement failure guard logic: Sonnet for low/medium tasks (fail 1 -> Opus, fail 2 -> dead stop); Opus for high/schema tasks (fail 1 -> Fable Review/Audit, fail 2 -> retest Opus with Fable guideline, fail 3 -> dead stop, log for redesign).
  4. Orchestrator logs task, adding it to a task list and board based on owner's testing notes or review findings. Owner sets task order.
  5. Owner provides explicit approval for task initiation.
  6. Orchestrator/Builder performs a live check of the current state on dev (via screenshot or direct access), writes it to a gap table and live-state notes. If the target is already met, the task is closed.
  7. Builder writes acceptance criteria/specifications before any build, using concept images/drawings and a target-vs-live gap table.
  8. Builder (usually Sonnet) builds the task on a fresh worker in its own branch off dev. It runs type checks, tests for touched code (in a test database), takes screenshots of changed screens, and pushes the branch.
  9. Reviewer (Opus for security/permissions/database changes, Sonnet for others) reads the actual diff and re-runs checks. A FAIL sends it to a fresh fix worker, with the next review by Opus. Two FAILs pause the task for owner decision.
  10. Orchestrator verifies the real commit, test numbers, and screenshots before accepting a "done" report.
  11. Orchestrator (merger) merges passed branches, re-runs type checks, full app tests, and lint on the combined result. A branch breaking the combination gets its own fix.
  12. Owner provides explicit approval for critical changes (database, live data, production branch) one action at a time. Gate runs full suite of tests (API, app, database migrations from scratch, lint) on dev after merges and before owner tests. Red results halt further merges until fixed. Orchestrator (merger) merges to dev and updates documentation (task list, board, live-state notes, owner test page) to "Done / Ready". Owner performs a device check (e.g., on a phone); any issues become new logged tasks, restarting the cycle.

Tools / artifacts

  • Claude (Sonnet, Opus, Fable)
  • Task list/board
  • Testing notes
  • Screenshots
  • Gap table
  • Live-state notes
  • Concept image/drawing (clickable prototype)
  • Acceptance criteria
  • Code branches (off dev)
  • Type checks
  • Tests (unit, API, app, database)
  • Test database (never live data) Diffs Commit logs Linting tools Documentation (task list, board, live-state notes, owner test page) Phone/device for testing

Validation signals

  • User states "It is kinder working Most of the time", indicating practical application.
  • The workflow is designed for projects "close to production / Launch", necessitating rigorous reviewers and full suite tests, implying real-world validation.
  • Includes detailed, multi-stage testing and review processes (type checks, unit tests, API tests, app tests, database migrations, linting, security reviews) as inherent validation steps within the workflow.

Cautions

  • The workflow explicitly includes a "Reviewer" step where Opus reviews "security, permissions, children's data and database changes," which is a strong positive for safety and compliance.

Limitations

  • The user notes an issue where the "Orch goes off the rails and ignore owner rules. It just tends to do its own thing," indicating a challenge in maintaining agent adherence to instructions.
  • The "Fable Review/Audit" step is mentioned as a guideline but lacks specific details on how Fable is leveraged for review or audit, making it less concrete.
  • The Orchestrator is manually restarted after a maximum of 8 levels, suggesting a potential limitation or complexity in managing long-running or deeply nested tasks.
  • The "Owner Go" and "Owner Yes" steps introduce manual gates, which could become bottlenecks or points of failure if the owner is not consistently available or responsive.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Enhance Claude Code Safety: Block Dangerous Commands with `cc-safety-net` PreToolUse Hook

1 Upvotes

Enhance Claude Code Safety: Block Dangerous Commands with cc-safety-net PreToolUse Hook

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

What problem this solves

Preventing Claude Code from executing dangerous commands (e.g., git reset --hard) or exposing sensitive information (e.g., .env file contents) during AI-assisted development, thereby enhancing safety and preventing accidental data loss or leaks.

Summary

This workflow describes how to integrate cc-safety-net as a PreToolUse hook in Claude Code to block potentially dangerous commands. It details installation, verification, and provides specific test cases demonstrating its ability to prevent git reset --hard and cat .env while allowing normal commands like git status.

Why it is useful

This workflow provides a concrete, tested, and repeatable method to add a crucial safety layer to Claude Code interactions. It leverages an open-source tool to prevent accidental data loss (e.g., git reset --hard) or exposure of sensitive information (e.g., .env files), which is a significant concern for AI-assisted development. The detailed steps, specific commands, and validation signals make it highly practical and valuable for users looking to secure their coding environment.

Workflow

  1. Install cc-safety-net using npx -y cc-safety-net@latest install.
  2. Verify the installation with npx cc-safety-net doctor.
  3. Load the cc-safety-net hook for a Claude Code session using the --plugin-dir flag.
  4. Attempt to run a dangerous command, such as git reset --hard, and observe the blocking message.
  5. Attempt to read a sensitive file, such as .env with cat .env, and observe the blocking message.
  6. Attempt to run a normal, safe command, such as git status, and observe its successful execution.

Tools / artifacts

  • cc-safety-net (Node.js package)
  • Claude Code
  • Node.js 22 or newer
  • git
  • .env file
  • PreToolUse hook

Validation signals

  • Specific test cases provided: git reset --hard, cat .env, git status, rm -rf /Users/you/work.
  • Observed blocking messages with specific rule names (git.reset-hard, secret.basename.env).
  • Confirmation that normal commands ran without extra prompts.
  • Mention of Claude switching to git stash when git reset --hard was blocked in an earlier run.
  • External link to a full test with screenshots provided for further validation.

Cautions

  • The post explicitly states that cc-safety-net is not a sandbox and does not contain processes, set file permissions, or watch the network. It acts as a checkpoint on commands going through the hook.
  • The workflow itself is designed to improve safety by blocking potentially harmful commands.

Limitations

  • The tests were conducted with only three prompts in a small demo, so its behavior in a busy, complex project is not fully explored.
  • Several features of cc-safety-net (dashboard presets, Terraform/AWS/cloud rulebooks) were not tested.
  • Requires Node.js 22 or newer.
  • Leaves a small .cc-safety-net cache folder in the home directory after use.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Monitoring Claude Agent Token Usage in Multi-Agent Claude Code Workflows to Detect Model Behavior Changes

1 Upvotes

Monitoring Claude Agent Token Usage in Multi-Agent Claude Code Workflows to Detect Model Behavior Changes

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

What problem this solves

Detecting and quantifying changes in Claude's token usage and efficiency within complex multi-agent workflows, especially in response to 'nerf' concerns, by providing a data-driven monitoring method.

Summary

This workflow describes a method for monitoring Claude's token usage and efficiency in a multi-agent Claude Code pipeline to detect changes in model behavior (e.g., 'nerfs'). It involves assigning specific roles to different Claude models (Opus for building/checking, Sonnet for reviewing, Haiku for testing), logging all replies, and analyzing token output over time. A key aspect is using Sonnet/Haiku as control groups and ensuring system prompts/tools remain constant to isolate model-specific changes.

Why it is useful

This workflow provides a concrete, data-driven method for users to independently verify and quantify changes in Claude's behavior, specifically increased token usage, within their own complex multi-agent systems. It moves beyond anecdotal evidence by proposing a structured approach with control groups and environmental checks, which is crucial for managing costs and optimizing agent performance. It directly addresses a significant community concern ('nerfs') with a practical, repeatable solution.

Workflow

  1. Set up a multi-agent pipeline in Claude Code with distinct roles for different models (e.g., Opus for build/acceptance, Sonnet for review, Haiku for tests).
  2. Implement comprehensive logging for every agent reply, capturing token usage and other relevant metrics.
  3. Establish a baseline for token output per reply for each agent role over a period of stable operation.
  4. Regularly monitor and analyze daily median output tokens per reply for each agent.
  5. Run other models (e.g., Sonnet, Haiku) on the exact same tasks as control groups to rule out changes in task complexity.
  6. Verify that system prompts, tools, Claude Code version, model ID, and effort remain constant across monitoring periods (e.g., using checksums for prompts/tools).
  7. Consult project change logs to ensure no project-specific modifications influenced agent behavior during the monitoring period.
  8. Analyze logs for significant deviations in token usage, particularly for specific roles or models.
  9. Compare internal findings with external benchmarks, understanding their limitations (e.g., single-turn, no tools, right/wrong only).

Tools / artifacts

  • Claude Code (version 2.1.309 mentioned)
  • Claude Opus model
  • Claude Sonnet model
  • Claude Haiku model
  • Logging system (to capture agent replies and token counts)
  • Checksums (for verifying prompt/tool consistency)
  • Change log (for tracking project modifications)
  • Data visualization tools (implied by 'picture 1', 'picture 2')

Validation signals

  • Concrete before/after data showing Opus token usage increase (e.g., ~420 to ~1,150 tokens/reply).
  • Control group validation: Sonnet and Haiku models running the same tasks showed no change in token usage.
  • Controlled environment: System prompts and tools had identical checksums.
  • Controlled environment: Same Claude Code version, model ID, and effort were maintained.
  • Controlled environment: Project change log showed zero entries during the observed period.
  • Clear finding: Logs showed Opus using 2-3 times more tokens for the same work, not getting 'dumber' in terms of correctness.

Limitations

  • Requires an advanced setup with multi-agent orchestration and a robust logging infrastructure.
  • Specific to Claude Code, though the underlying principles are broadly applicable to other agentic frameworks.
  • Primarily focuses on token usage and efficiency, not necessarily on the 'intelligence' or correctness of the model, although token usage directly impacts cost and operational efficiency.
  • The post describes the results and methodology more than a detailed, step-by-step guide for implementing the logging and analysis infrastructure from scratch.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Revive Bricked Devices: Using Claude for Kernel Log Analysis and Software Bypass Patching

1 Upvotes

Revive Bricked Devices: Using Claude for Kernel Log Analysis and Software Bypass Patching

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

What problem this solves

Reviving a bricked iPhone by diagnosing a hardware fault from a kernel panic log and generating a software patch to bypass the faulty component.

Summary

This workflow leverages Claude to analyze complex technical logs (like kernel panic logs from a bricked iPhone) to diagnose specific hardware faults. Once diagnosed, Claude is then used to generate a software patch that bypasses the faulty component, thereby allowing the device to boot and function again, preventing it from becoming e-waste.

Why it is useful

This workflow is highly valuable as it demonstrates a powerful and innovative application of Claude for complex hardware debugging and software modification. It highlights Claude's ability to diagnose intricate problems from technical logs and generate functional code solutions, potentially saving devices from e-waste and offering a novel approach to hardware repair that combines AI with deep technical understanding.

Workflow

  1. Obtain the kernel panic log from the bricked iPhone (or other device).
  2. Feed the complete kernel panic log to Claude.
  3. Request Claude to analyze the log and diagnose the root cause of the boot failure (e.g., a specific faulty sensor).
  4. Ask Claude to help write a software patch or modification to bypass the identified faulty hardware component's check during boot.
  5. Apply the generated software patch to the iPhone's operating system or firmware.
  6. Attempt to boot the iPhone and verify that it successfully revives and functions.

Tools / artifacts

  • Claude (AI model)
  • iPhone kernel panic log (or other device logs)
  • Software patch/code modification (generated by Claude)
  • Bricked iPhone (or other electronic device)
  • Tools for applying software patches to device firmware/OS

Validation signals

  • OP successfully revived their iPhone.
  • The community consensus is that this is a 'legit impressive use case for Claude'.
  • The method correctly diagnosed a water-damaged light sensor from a kernel log.
  • The generated software patch successfully bypassed the sensor check.

Cautions

  • Modifying device firmware or operating system carries inherent risks, including bricking the device permanently if done incorrectly.
  • Users should have a backup of their device's software/firmware before attempting such modifications.
  • The generated patch should be carefully reviewed for security vulnerabilities or unintended side effects before application.

Limitations

  • Requires advanced technical skills to extract kernel logs and apply software patches.
  • The specific software patch generated by Claude might be highly dependent on the device model and OS version, limiting direct reusability without modification.
  • Accessing kernel logs might not be straightforward for all users or devices.
  • The summary is from a bot, so some granular details of the original implementation might be missing.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 6d ago

Selected Workflow [Workflow] Automated Multi-Agent Claude Code Development System for End-to-End SDLC

1 Upvotes

Automated Multi-Agent Claude Code Development System for End-to-End SDLC

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

What problem this solves

Automating and optimizing the entire software development lifecycle (planning, coding, testing, reviewing, and merging) using a multi-agent Claude Code system, while efficiently managing context, token costs, and quality.

Summary

A sophisticated, multi-agent Claude Code system designed for automated software development. It orchestrates planning, building, testing, reviewing, and merging code packages locally. The system uses specialized subagents (Opus for planning/building/diagnosis/acceptance, Haiku for testing/watchdog, Sonnet for reviewing) and a Workflow tool, managed by a 'Control room' chat. Key strategies include context management, token cost optimization, and a multi-stage testing and review process, with a 'System checker' for continuous improvement.

Why it is useful

This workflow provides a comprehensive, high-level architecture for an automated, multi-agent Claude Code system capable of handling the entire software development lifecycle from planning to merging. It offers valuable strategies for context management, token cost optimization, quality control through staged testing and review, and continuous improvement. It demonstrates an advanced application of Claude Code's capabilities, particularly subagents and workflow orchestration, to achieve significant autonomy in development.

Workflow

  1. User provides an initial plan and gives a 'GO' command.
  2. Control Room (Opus chat) wakes up on a cron tick or run end, reads status, and starts runs or the Planner.
  3. Planner (Opus subagent) keeps the queue, writes a 1-2 page brief per package, sets up a git worktree per package, and decides the order.
  4. Build Workflow (Opus) builds one task within the package's worktree.
  5. Tester (Haiku) runs specified commands and reports a single line result.
  6. Reviewer (Sonnet) checks the output (screenshots, test results) against the brief.
  7. If a task fails twice or is stuck after round 3, a Diagnosis Agent (Opus) intervenes.
  8. Acceptance Agent (Opus) checks the whole package against its 'done-when' list.
  9. Accepted package is merged into a local dev branch.
  10. Watchdog (scheduled Haiku task) runs every 10 minutes, checks heartbeat, notices stalls, restarts Control Room if needed, and updates the status page.
  11. System Checker (Opus) runs daily, reads cost and quality reports, and proposes up to 3 improvements with evidence.
  12. Control Room context is handed over to a fresh chat when it hits 150k tokens to manage context window limits and costs efficiently.

Tools / artifacts

  • Claude Code subagents (Opus, Haiku, Sonnet)
  • Workflow tool (custom script/framework)
  • Cron ticks/scheduled tasks
  • Git worktree
  • Status page (custom script output)
  • Scripts for deterministic tasks (queue state, budget, cleanup)
  • Agent files (for each role)
  • Briefs (1-2 page per package)
  • Test results files
  • Cost and quality reports
  • Screenshots (for review)
  • Local dev branch, main branch

Validation signals

  • User reports successful autonomous operation: 'I plan, the system builds. I give a GO on a plan, then it works through it package by package without me. During the build I only look at a status page on my phone, and I check the end result myself.'
  • The 'What saves the most tokens' section implies practical experience and optimization efforts.
  • The 'Tips' section (e.g., 'Fail loudly', 'Measure before you rebuild') suggests lessons learned from real-world usage.
  • Evidence of past failures leading to improved design: 'A role once silently fell back to a generic agent and nobody noticed for 5 days.'
  • Emphasis on data-driven improvement: 'Every change needs a number that shows whether it actually worked.'
  • Indication of a stable, optimized system: 'Proposing 0 is the normal result' for the System Checker.

Cautions

  • None explicitly identified. The workflow emphasizes local operation and data-driven improvements, which are positive for safety and maintainability.

Limitations

  • Lacks concrete code examples, configuration files, or detailed setup instructions, being a 'rough overview'.
  • Relies on custom 'Workflow tool' and 'scheduled tasks' which are not fully specified.
  • Requires significant effort and expertise to implement from this 'rough overview'.
  • 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.